Med Java-bitvisa operatorer kan du manipulera enskilda bitar på vilket sätt du vill. De sju operatorerna är uppbyggda på liknande sätt och följer fasta regler som är lätta att lära sig.

Vad är bitvisa operatorer och vad används de till?

Java-operatorer är ett viktigt verktyg när man arbetar med programmeringsspråket. Förutom många andra möjligheter och funktioner ger de dig möjlighet att manipulera de minsta möjliga informationsenheterna: bitar. Bitar (binära siffror) har sitt eget talsystem baserat på värdena 0 och 1. Om du vill fråga binära värden bit för bit behöver du en bitvis operator i Java. Du kan tillämpa detta på de numeriska datatyperna (byte, char, int, short, long).

Även om du inte behöver funktionen dagligen kan den vara användbar i många situationer. Den kan till exempel vara praktisk om du vill spara utrymme när du konverterar data, om du vill använda XOR-operatorn eller om du bara vill ändra en bit. De är också grunden för alla högre kretsoperationer. Därför är det viktigt att förstå den grundläggande funktionen hos Java-bitvisa operatorer.

Vilka bitvisa operatorer finns det i Java?

Det finns totalt sju olika bitvisa operatorer i Java. För att få en heltäckande förståelse börjar vi med operanderna a och b.

  • ~ (bitvis NOT, komplement): Denna operator inverterar bitar. En 0 blir en 1 och en 1 blir en 0.
  • & (bitvis AND): Denna operator ger ut en 1 om båda operanderna är 1. I annat fall ges en 0 ut.
  • | (bitvis OR): Denna operator ger 1 om en av de två operanderna också är 1.
  • ^ (XOR eller bitvis exklusiv OR): Denna operator ger ut en 0 om båda operanderna har samma värde. Annars ger den ut en 1.
  • << (vänsterförskjutning): Denna operator förskjuter operanden a åt vänster med b positioner. Om detta resulterar i mellanrum fylls mellanrummen med 0.
  • >> (högerförskjutning med tecken, aritmetisk): Denna operator förskjuter alla bitar i a med b positioner åt höger. Om biten med det högsta värdet var inställd före exekveringen förblir den inställd efteråt. Negativa tal förblir negativa.
  • >>>> (osignerad högerförskjutning, logisk): Denna operator förskjuter bitarna i a åt höger med b positioner. Mellanslag fylls alltid med 0.

Bitvis NOT

Java-bitoperatören bitvis NOT representeras av en tilde (~). Den negerar alla bitar och förvandlar nollor till ettor och ettor till nollor. Låt oss ta exemplet med siffran 20. I binär form ser den ut så här: 10100. Om vi tillämpar bitvis NOT-operatorn kommer varje bit i talet att bytas: 10100 blir 01011. Detta är värdet av uttrycket ~20. Om vi konverterar detta binära tal tillbaka till ett decimaltal får vi värdet -21. Om du vill prova denna process i Java, ange följande kod och Java-kommandot System.out.println för att visa resultatet.

public class Main {
	public static void main(String[] args) {
	int value1 = 20;
	System.out.println(~value1);
}
}
java

Om du har angett allt korrekt ska resultatet visa ”-21”.

Bitvis AND

Bitvis AND jämför två tal i deras binära form bit för bit. Den första biten i det första talet jämförs med den första biten i det andra talet, den andra med den andra biten och så vidare. Om båda bitarna är 1, blir resultatet 1. Om så inte är fallet (båda bitarna är 0 eller en av bitarna är 0), blir resultatet 0. I exemplet nedan tittar vi på de två decimaltalen 18 och 25. Som binärt tal är 18 10010 och 25 i binär notation är 11001. Låt oss nu jämföra dessa två tal och bestämma ett tredje tal utifrån dem.

18 = 10010 25 = 11001

De två första bitarna i siffrorna är båda 1, så det resulterande talet börjar också med 1. Den andra biten i 25 är också 1, men den andra biten i 18 är 0, vilket gör siffran i det tredje talet till en 0. Efter att ha gått igenom båda talen bit för bit får vi det binära talet 10000. Om vi konverterar detta till ett decimaltal blir resultatet 16.

Koden ser ut så här:

public class Main {
	public static void main(String[] args) {
	System.out.println(18&25);
}
}
java

Utmatningen i konsolen ska vara 16.

Bitvis OR

Java-operatorn bitvis OR jämför också två tal bit för bit. I det här fallet måste dock endast en av de två operanderna ha värdet 1 för att resultatet ska bli 1. Om vi tar talen från föregående exempel ser det ut så här:

18 = 10010 25 = 11001

Eftersom alla bitar utom den tredje siffran innehåller minst en 1 blir det resulterande talet: 11011. Omräknat får vi 27.

Så här ser exemplet ut i kod:

public class Main {
	public static void main(String[] args) {
	System.out.println(18|25);
}
}
java

XOR

XOR eller bitvis exklusiv OR (^) liknar bitvis OR. Med bitvis OR måste en eller båda operanderna vara 1 för att utdata ska bli 1. Med XOR blir utdata dock endast 1 om exakt ett av de två värdena är 1. För att få en bättre förståelse för hur XOR fungerar, låt oss titta på ett exempel:

18 = 10010 25 = 11001

De två första bitarna har värdet 1, så med denna bitvisa operator i Java blir resultatet 0. Den andra biten i 18 är 0, men den andra biten i 25 är 1. Detta ger värdet 1. Om vi fortsätter får vi siffran 01011. I decimalform är detta 11.

Här är koden:

public class Main {
	public static void main(String[] args) {
	System.out.println(18^25);
}
}
java

Vänsterförskjutning

Vänsterförskjutning förskjuter bitarna i värdet a åt vänster med avståndet b. De resulterande tomma platserna fylls med 0. Ett int-värde som upptar 32 bitar i ett minne illustrerar detta tydligt. Låt oss återigen ta siffran 20 eller 10010 och förskjuta den med b-värdet 2 för att få c-värdet 1001000. Två nollor placeras i slutet. 1001000 motsvarar decimalvärdet 72.

Så här ser processen ut i kod:

public class Main {
	public static void main(String[] args) {
	int a = 20;
	int b = 2;
	int c = (a << b);
	System.out.println(c);
}
}
java

Högerförskjutning med tecken

Högerförskjutning fungerar tvärtom. Här förskjuts bitar av värdet a åt höger med värdet b, vilket ger värdet c. Som resultat utelämnas de sista bitarna. Om vi förskjuter 20 eller 10010 två platser åt höger blir resultatet 100 eller 4.

Här är koden:

public class Main {
	public static void main(String[] args) {
	System.out.println(20 >> 2);
}
}
java

Det är viktigt att notera att om a är ett positivt tal fylls luckorna med 0. Om det är negativt ersätts luckorna med 1.

Högerförskjutning utan tecken

I princip fungerar Java-bitoperatören högerförskjutning utan tecken (>>>) på samma sätt. Den enda skillnaden är att de utrymmen som skapas på vänster sida genom förskjutningen åt höger alltid fylls med 0. Detta resulterar alltid i ett positivt tal, även om startvärdet var negativt.

Gå till huvudmeny