Bevezetés
Bitmanipuláció
A Java rendelkezik operátorokkal a byte, short, int, long vagy char típusok bitjeinek manipulálásához.
Eltoló operátorok
A << operátorral balra, a >> operátorral pedig jobbra tolhatod a biteket.
// Shift two places to the left
0b0000_1011 << 2;
// # => 0b0010_1100
// Shift two places to the right
0b0000_1011 >> 2;
// # => 0b0000_0010
A << operátor mindig 0-kat szúr be a jobb oldalon.
A >> viszont ugyanazt a bitet szúrja be, mint a bal szélső bit (1, ha a szám negatív, vagy 0, ha pozitív).
// Shift 2 places to the right preserves the sign
// This is a negative value, whose binary representation is
// 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
A >>> operátort akkor használd helyette, ha jobbra tolásnál 0-kat kell beszúrni.
// 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.
Az első érték minden bitjét összehasonlítja a második érték ugyanabban a pozícióban lévő bitjével.
Ha mindkettő 1, akkor az eredmény bitje 1.
Ellenkező esetben 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.
Az első érték minden bitjét összehasonlítja a második érték ugyanabban a pozícióban lévő bitjével.
Ha bármelyik bit 1, az eredmény bitje 1.
Ellenkező esetben 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 ugyanabban a pozícióban lévő bitjével.
Ha csak az egyikük 1, az eredményül kapott bit 1.
Ellenkező esetben 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 egyoperandusú operátor, amely csak egy értéken működik.
~0b0110_0101;
// # => 0b1001_1010
Utasítások
A barátod épp most küldött neked egy üzenetet egy fontos titokkal.
Hogy ne legyen könnyű másoknak elolvasni, az üzenetet egy sor bitmanipulációval titkosították.
Neked kell megírnod a metódusokat, amelyek segítenek visszafejteni az üzenetet.
1. Toldd vissza a biteket
Az üzenet visszafejtésének első lépése, hogy visszavonjuk a titkosításnál végzett eltolást: a biteket visszatoljuk jobbra.
A visszafejtés további lépései abból indulnak ki, hogy a bal oldalról 0-k kerülnek be.
Valósítsd meg a Secrets.shiftBack metódust, amely egy értéket és az eltolás helyeinek számát kapja, és végrehajtja az eltolást.
Secrets.shiftBack(0b1001, 2);
# => 0b0010
2. Állíts be néhány bitet
Ezután van néhány bit, amit 1-re kell állítani.
Valósítsd meg a Secrets.setBits metódust, amely egy értéket és egy maszkot kap, és visszaadja az eredményt, miután az érték bitjeit 1-re állította.
Az érték azon bitjeit kell 1-re állítani, ahol a maszk bitje is 1.
Minden más bit változatlan marad.
Secrets.setBits(0b0110, 0b0101);
# => 0b0111
3. Fordítsd meg a megadott biteket
A titkosítás során néhány bitet megfordítanak.
Ahhoz, hogy visszafejtsük az üzenetet, ezeket vissza kell fordítani.
Valósítsd meg a Secrets.flipBits metódust, amely egy értéket és a maszkot kapja.
A maszk megmutatja, hogy az érték mely bitjeit kell megfordítani.
Ha egy bit 1 a maszkban, akkor az értékben lévő bit megfordul.
Minden más bit változatlan marad.
Secrets.flipBits(0b1100, 0b0101);
# => 0b1001
4. Töröld a megadott biteket
Végül vannak olyan bitek is, amelyek mindig 0-ra fejtődnek vissza.
Valósítsd meg a Secrets.clearBits metódust, amely egy értéket és egy maszkot kap.
A value azon bitjeit kell 0-ra állítani, ahol a maszkban 1 áll.
Minden más bit változatlan marad.
Secrets.clearBits(0b0110, 0b0101);
# => 0b0010
Tanulófeladat
