Bitmanipuláció ebben a kurzusban:

A(z) Bitmanipuláció fogalomról

A Javában vannak operátorok egy integráltípus bitjeinek kezelésére (byte, short, int, long vagy char).

Eltolásoperátorok

A << operátorral balra tolhatod a biteket, a >> operátorral pedig jobbra.

// Shift two places to the left
0b0000_1011 << 2;
// # => 0b0010_1100

// Shift two places to the right
0b0000_1011 >> 2;
// # => 0b0000_0010

A >>-t előjeles eltolás vagy aritmetikai eltolás operátornak is nevezik, mert a beszúrt bit megegyezik az előjelbitjével. Ez a bal szélső bit, és 0, ha az érték pozitív, illetve 1, ha negatív. A << operátorral való balra tolás mindig nullákat szúr be a jobb oldalon.

// Shift 2 places to the right preserves the sign
// The binary value is two's complement of 0b0000_0110 (or 0x00000026), so the binary representation will be
// 1000_0000_0000_0000_0000_0000_0010_0110
int value = -0x7FFFFFDA;

// Shift two places to the right, preserving the sign bit
value >> 2;
// # => 1110_0000_0000_0000_0000_0000_0000_1001

Ha jobbra tolásnál nullákat kell beszúrni, használd helyette a >>> operátort. A tolásnál nullák beszúrását logikai eltolásnak is nevezik.

// Shift two places to the right, inserting 0s on the left
value >>> 2;
// # => 0010_0000_0000_0000_0000_0000_0000_1001

Bitenkénti műveletek

Bitenkénti ÉS

A bitenkénti ÉS (&) operátor két értéket vesz, és minden biten elvégzi az ÉS műveletet. Összehasonlítja az első érték minden bitjét a második érték ugyanazon a helyen lévő bitjével. Ha mindkettő 1, akkor az eredmény bitje 1. Egyébként az eredmény bitje 0.

0b0110_0101 & 0b0011_1100;
// # => 0b0010_0100

Bitenkénti VAGY

A bitenkénti VAGY (|) operátor két értéket vesz, és minden biten elvégzi a VAGY műveletet. Összehasonlítja az első érték minden bitjét a második érték ugyanazon a helyen lévő bitjével. Ha valamelyik bit 1, az eredmény bitje 1. Egyébként 0.

0b0110_0101 | 0b0011_1100;
// # => 0b0111_1101

Bitenkénti XOR

A bitenkénti XOR operátor (^) bitenkénti XOR műveletet végez két értéken. A bitenkénti ÉS és VAGY operátorokhoz hasonlóan összehasonlítja az első érték minden bitjét a második érték ugyanazon a helyen lévő bitjével. Ha csak az egyikük 1, az eredményül kapott bit 1. Egyébként 0.

0b0110_0101 ^ 0b0011_1100;
// # => 0b0101_1001

Bitenkénti NEM (~)

Végül a bitenkénti NEM operátor (~) minden bitet megfordít. A korábbi operátorokkal ellentétben ez egy unáris operátor, amely csak egyetlen értéken működik.

~0b0110_0101;
// # => 0b1001_1010