Vad är Java-bitvisa ope­ra­to­rer och hur använder man dem?

Med Java-bitvisa ope­ra­to­rer kan du ma­ni­pu­le­ra enskilda bitar på vilket sätt du vill. De sju ope­ra­to­rer­na är uppbyggda på liknande sätt och följer fasta regler som är lätta att lära sig.

Vad är bitvisa ope­ra­to­rer och vad används de till?

Java-ope­ra­to­rer är ett viktigt verktyg när man arbetar med pro­gram­me­rings­språ­ket. Förutom många andra möj­lig­he­ter och funk­tio­ner ger de dig möjlighet att ma­ni­pu­le­ra de minsta möjliga in­for­ma­tions­en­he­ter­na: 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 da­ta­ty­per­na (byte, char, int, short, long).

Även om du inte behöver funk­tio­nen dagligen kan den vara användbar i många si­tu­a­tio­ner. Den kan till exempel vara praktisk om du vill spara utrymme när du kon­ver­te­rar 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 kretso­pe­ra­tio­ner. Därför är det viktigt att förstå den grund­läg­gan­de funk­tio­nen hos Java-bitvisa ope­ra­to­rer.

Vilka bitvisa ope­ra­to­rer finns det i Java?

Det finns totalt sju olika bitvisa ope­ra­to­rer i Java. För att få en hel­täc­kan­de för­stå­el­se börjar vi med ope­ran­der­na a och b.

• ~ (bitvis NOT, kom­ple­ment): Denna operator in­ver­te­rar bitar. En 0 blir en 1 och en 1 blir en 0.
• & (bitvis AND): Denna operator ger ut en 1 om båda ope­ran­der­na är 1. I annat fall ges en 0 ut.
• | (bitvis OR): Denna operator ger 1 om en av de två ope­ran­der­na också är 1.
• ^ (XOR eller bitvis exklusiv OR): Denna operator ger ut en 0 om båda ope­ran­der­na har samma värde. Annars ger den ut en 1.
• << (väns­ter­för­skjut­ning): Denna operator för­skju­ter operanden a åt vänster med b po­si­tio­ner. Om detta re­sul­te­rar i mellanrum fylls mel­lan­rum­men med 0.
• >> (hö­ger­för­skjut­ning med tecken, arit­me­tisk): Denna operator för­skju­ter alla bitar i a med b po­si­tio­ner åt höger. Om biten med det högsta värdet var inställd före ex­e­kve­ring­en förblir den inställd efteråt. Negativa tal förblir negativa.
• >>>> (osignerad hö­ger­för­skjut­ning, logisk): Denna operator för­skju­ter bitarna i a åt höger med b po­si­tio­ner. Mel­lanslag fylls alltid med 0.

Bitvis NOT

Java-bi­to­pe­ra­tö­ren bitvis NOT re­pre­sen­te­ras av en tilde (~). Den negerar alla bitar och för­vand­lar 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 kon­ver­te­rar detta binära tal tillbaka till ett de­ci­mal­tal 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 re­sul­ta­tet.

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

Om du har angett allt korrekt ska re­sul­ta­tet 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 re­sul­ta­tet 1. Om så inte är fallet (båda bitarna är 0 eller en av bitarna är 0), blir re­sul­ta­tet 0. I exemplet nedan tittar vi på de två de­ci­mal­ta­len 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 re­sul­te­ran­de 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 kon­ver­te­rar detta till ett de­ci­mal­tal blir re­sul­ta­tet 16.

Koden ser ut så här:

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

Ut­mat­ning­en 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å ope­ran­der­na ha värdet 1 för att re­sul­ta­tet ska bli 1. Om vi tar talen från fö­re­gå­en­de exempel ser det ut så här:

18 = 10010 25 = 11001

Eftersom alla bitar utom den tredje siffran in­ne­hål­ler minst en 1 blir det re­sul­te­ran­de 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);
}
}

XOR

XOR eller bitvis exklusiv OR (^) liknar bitvis OR. Med bitvis OR måste en eller båda ope­ran­der­na 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ör­stå­el­se 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 re­sul­ta­tet 0. Den andra biten i 18 är 0, men den andra biten i 25 är 1. Detta ger värdet 1. Om vi fort­sät­ter får vi siffran 01011. I de­ci­mal­form är detta 11.

Här är koden:

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

Väns­ter­för­skjut­ning

Väns­ter­för­skjut­ning för­skju­ter bitarna i värdet a åt vänster med avståndet b. De re­sul­te­ran­de tomma platserna fylls med 0. Ett int-värde som upptar 32 bitar i ett minne il­lu­stre­rar 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 de­ci­mal­vär­det 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);
}
}

Hö­ger­för­skjut­ning med tecken

Hö­ger­för­skjut­ning 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ör­skju­ter 20 eller 10010 två platser åt höger blir re­sul­ta­tet 100 eller 4.

Här är koden:

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

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ö­ger­för­skjut­ning utan tecken

I princip fungerar Java-bi­to­pe­ra­tö­ren hö­ger­för­skjut­ning utan tecken (>>>) på samma sätt. Den enda skill­na­den är att de utrymmen som skapas på vänster sida genom för­skjut­ning­en åt höger alltid fylls med 0. Detta re­sul­te­rar alltid i ett positivt tal, även om start­vär­det var negativt.