Bitvise operationer, del 2

1. Bitvist venstreskift

Java har også 3 bitvise skiftoperatorer : Hvis du virkelig har brug for det, kan du meget enkelt flytte alle bits af et tal flere positioner til venstre eller højre.

For at flytte bits af et tal til venstre skal du bruge den bitvise venstre shift-operator . Sådan er det skrevet:

a << b

Hvor aer det tal, hvis bits bliver flyttet, og ber et tal, der angiver, hvor mange gange bits af tallet skal flyttes atil venstre. Under denne operation er de lavordens bit, der tilføjes til højre, nuller.

Eksempler:

0b00000011 << 1

0b00000110

0b00000011 << 2

0b00001100

0b00000011 << 5

0b01100000

0b00000011 << 20

0b001100000000000000000000

At flytte et ciffer til venstre har samme effekt som at gange et tal med 2.

Vil du gange et tal med 16? 16 er det samme som 2 ⁴ . Så du flytter tallet 4 cifre til venstre

2. Skift til højre bitvist

Bits kan også flyttes til højre. For at gøre dette skal du bruge den bitvise højreskiftoperator . Sådan er det skrevet:

a >> b

Hvor aer det antal, hvis bits bliver flyttet, og ber antallet af gange, der skal flyttes bits af tallet atil højre.

Eksempler:

0b11000011 >> 1

0b01100001

0b11000011 >> 2

0b00110000

0b11000011 >> 5

0b00000110

0b11000011 >> 20

0b00000000

At flytte et ciffer til højre har samme effekt som at dividere et tal med 2.

Under denne operation er de højordens bit, der tilføjes til venstre, nuller, men ikke altid !

Når bits af et tal forskydes til højre, ville værdien af ​​fortegnsbitten normalt også skifte, og fortegnet for tallet ville gå tabt. For negative tal (hvor bit længst til venstre er 1), får denne bit en særlig behandling. Når bits af et tal flyttes til højre, 0tilføjes a til venstre, hvis bit længst til venstre var 0, og a 1tilføjes til venstre, hvis bit længst til venstre var 1.

Men i eksemplet ovenfor ser det ikke ud til at være resultatet. Hvorfor? Fordi heltallige bogstaver er ints, og  faktisk betyder . Det vil sige, at bit længst til venstre er nul.0b111111110b00000000000000000000000011111111

Mange programmører er frustrerede over denne højreskift-adfærd og foretrækker, at nummeret altid er polstret med nuller. Så Java tilføjede endnu en højreskiftoperator .

Sådan er det skrevet:

a >>> b

Hvor a er det antal, hvis bits bliver flyttet, og b  er antallet af gange, der skal flyttes bits af tallet atil højre. Denne operator tilføjer altid nuller til venstre, uanset den oprindelige værdi af tallets fortegnsbit a.

3. Arbejde med flag

Programmører skabte en næsten helt ny studieretning på basis af bitvise og skiftende operationer: at arbejde med flag.

Når computere havde meget lidt hukommelse, var det meget populært at proppe en masse information ind i et enkelt nummer. Et tal blev behandlet som en række bits: en int er 32 bit, og en lang er 64 bit.

Du kan skrive en masse information i et sådant tal, især hvis du skal gemme logiske ( trueeller false) værdier. En enkelt longer som et booleanarray bestående af 64 elementer. Disse bits blev kaldt flag og blev manipuleret ved hjælp af følgende operationer:

• sæt flag
  (gør en bestemt bit lig med 1)
• nulstil flag
  (gør en bestemt bit lig med 0)
• tjek flag
  (tjek værdien af ​​en bestemt bit)

Og her er, hvordan det gøres med bitvise operatører.

Sætter et flag

For at indstille en bestemt bit til 1skal du udføre en bitvis ELLER-operation mellem det nummer, hvis bit du vil indstille, og et specielt oprettet tal, hvor kun den bit er 1.

Antag for eksempel, at du har tallet 0b00001010, og du skal indstille den 5. bit til 1. I så fald skal du:

0b00001010 | 0b00010000 = 0b00011010

Hvis den 5. bit allerede var blevet indstillet til én, ville intet have ændret sig.

Generelt kan operationen med at sætte et flag skrives som følger

a | (1 << b)

Hvor a er det nummer, hvis bit vil blive sat til 1. Og b er positionen af ​​det bit, der skal indstilles. Her er det super praktisk at bruge venstreskifteoperatøren, da du med det samme kan se, hvilken bit vi arbejder med.

Nulstilling af et flag

For at nulstille en bestemt bit (dvs. indstille den til 0) uden at forstyrre andre bits, skal du udføre en &operation mellem det nummer, hvis bit du vil nulstille (dvs. indstillet til 0) og et specielt oprettet tal, hvor alle bits er lig 1undtagen for den bit, du vil nulstille.

Antag for eksempel, at du har nummeret 0b00001010, og du skal indstille den 4. bit til 0. I så fald skal du:

0b00001010 & 0b11110111 = 0b00000010

Hvis den 4. bit allerede var blevet sat til nul, ville intet have ændret sig.

Generelt kan operationen med at nulstille et flag skrives som følger

a & ~(1 << b)

Hvor a er det nummer, hvis bit vil blive nulstillet til 0. Og b er positionen for bit, der skal ryddes.

For at få et tal, hvor alle bits er 1undtagen den, vi ønsker skal være nul, flytter vi først 1 b  positioner til venstre og bruger derefter den bitvise NOToperator til at invertere resultatet.

Kontrollerer et flag

Udover at indstille eller nulstille et specifikt flag, skal du nogle gange bare tjekke om et givent flag er sat, altså om en bestemt bit er lig med 1. Dette er ret nemt at gøre med lidt &.

Antag for eksempel, at du skal kontrollere, om den 4. bit er sat til 1i nummeret 0b00001010. Så skal du gøre dette:

if ( (0b00001010 & 0b00001000) == 0b00001000 )

Generelt kan operationen med at kontrollere et flag skrives som følger

(a & (1 << b)) == (1 << b)

Hvor a er nummeret, hvis bit bliver tjekket. Og b er bidets position, der skal kontrolleres.

4. Kryptering

Den bitvise XORoperation bruges ofte af programmører til simpel kryptering. Generelt ser sådan kryptering sådan ud:

result = number ^ password;

Hvor number er de data, vi ønsker at kryptere, password er et særligt nummer, der bruges som "adgangskode" til dataene, og result er det krypterede nummer.

number == (number ^ password) ^ password;

Det vigtige her er, at når operatoren XORanvendes på et tal to gange, producerer den det oprindelige tal, uanset "adgangskoden".

For at komme dig number fra encrypted result, skal du blot udføre operationen igen:

original number = result ^ password;

Eksempel:

class Solution
{
   public static int[] encrypt(int[] data, int password)
   {
     int[] result = new int[data.length];
     for (int i = 0; i <  data.length; i++)
       result[i] = data[i] ^ password;
     return result;
   }

   public static void main(String[] args)
   {
     int[] data =  {1, 3, 5, 7, 9, 11};
     int password = 199;

     // Encrypt the array of data
     int[] encrypted = encrypt(data, password);
     System.out.println(Arrays.toString(encrypted));

     // Decrypt the array of data
     int[] decrypted = encrypt(encrypted, password);
     System.out.println(Arrays.toString(decrypted));
   }
}