Java bi­ti­vii­si­liste ope­raa­to­ri­tega saate üksikuid bitte ma­ni­pu­lee­rida nii, nagu soovite. Seitse ope­raa­to­rit on üles ehitatud sarnaselt ja järgivad kindlaid reegleid, mida on lihtne õppida.

Mis on bi­ti­vii­si­li­sed ope­raa­to­rid ja milleks neid ka­su­ta­takse?

Java ope­raa­to­rid on prog­ram­mee­ri­mis­keele ka­su­ta­misel oluline tööriist. Lisaks paljudele teistele või­ma­lus­tele ja funkt­sioo­ni­dele annavad need võimaluse ma­ni­pu­lee­rida väik­sei­maid või­ma­likke in­foyk­susi: bitte. Bitidel (bi­naar­koo­di­del) on oma numbrite süsteem, mis põhineb väär­tus­tel 0 ja 1. Kui soovite küsida bi­naarväär­tusi bithaaval, vajate Java-s bi­ti­teh­ni­list ope­raa­to­rit. Seda saab rakendada numb­ri­lis­tele and­me­tüü­pi­dele (byte, char, int, short, long).

Kuigi te ei vaja seda funkt­siooni iga­päe­va­selt, võib see paljudes olu­kor­da­des ka­su­likuks osutuda. Näiteks võib see olla kasulik, kui soovite andmete tei­sen­da­misel ruumi säästa, kui soovite kasutada XOR-ope­raa­to­rit või kui soovite lihtsalt ühte bitti muuta. Need on ka kõigi kõrgema taseme voo­luahe­late ope­rat­sioo­nide aluseks. Seetõttu on oluline mõista Java bi­ti­vii­si­liste ope­raa­to­rite põhilist funkt­sio­naal­sust.

Millised Java bi­ti­vii­si­li­sed ope­raa­to­rid on olemas?

Java-s on kokku seitse erinevat bi­ti­vii­si­list ope­raa­to­rit. Üldise aru­saa­mise saamiseks alustame ope­ran­di­test a ja b.

  • ~ (bitwise NOT, komp­le­men­taar): See operaator pöörab bittidest ümber. 0 muutub 1-ks ja 1 muutub 0-ks.
  • & (bitwise AND): See operaator väljastab 1, kui mõlemad operandid on 1. Muul juhul väl­jas­ta­takse 0.
  • | (bi­ti­vii­si­line OR): See operaator annab tu­le­mu­seks 1, kui üks kahest ope­ran­dist on samuti 1.
  • ^ (XOR või bi­ti­vii­si­line eksklu­siivne OR): See operaator väljastab 0, kui mõlemad operandid on sama väär­tu­sega. Muul juhul väljastab see 1.
  • << (vasakule ni­hu­ta­mine): see operaator nihutab operandi a b po­sit­siooni võrra vasakule. Kui selle tu­le­mu­seks on tühikud, täi­de­takse tühikud 0-ga.
  • >> (pa­rem­poolne ni­hu­ta­mine märgiga, arit­mee­ti­line): See operaator nihutab kõik a biti b po­sit­siooni võrra paremale. Kui enne täitmist oli seatud kõrgeima väär­tu­sega bit, jääb see pärast täitmist samuti seatuks. Ne­ga­tiiv­sed numbrid jäävad ne­ga­tiiv­seks.
  • >>>> (märgita pa­rem­poolne nihutus, loogiline): see operaator nihutab a bitti paremale b po­sit­siooni võrra. Tühikud täi­de­takse alati 0-ga.

Bitwise NOT

Java bi­ti­vii­si­line operaator bi­ti­vii­si­line NOT on esindatud tildega (~). See negeerib kõik bitid, muutes nullid ühtedeks ja ühed nullideks. Võtame näiteks numbri 20. Bi­naar­selt näeb see välja järg­mi­selt: 10100. Kui rakendame bitwise NOT ope­raa­to­rit, vahetuvad kõik numbri bitid: 10100 muutub 01011-ks. See on väljendi ~20 väärtus. Kui tei­sen­dame selle bi­naar­numbri tagasi küm­nend­numbri, saame väärtuse -21. Kui soovite seda protsessi Java-s proovida, sisestage järgmine kood ja Java-käsk System.out.println tulemuse väl­jas­ta­miseks.

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

Kui olete kõik õigesti si­ses­ta­nud, peaks väl­jun­diks olema „-21”.

Bi­ti­vii­si­line AND

Bitwise AND võrdleb kahte numbrit nende binaarses vormis bit haaval. Esimese numbri esimest bitti võr­rel­dakse teise numbri esimese bitiga, teist bitti teise bitiga jne. Kui mõlemad bitid on 1, väl­jas­ta­takse 1. Kui see nii ei ole (mõlemad bitid on 0 või üks bittidest on 0), väl­jas­ta­takse 0. Allpool toodud näites vaatame kahte küm­nend­kohta 18 ja 25. Bi­naar­numb­ri­tena on 18 10010 ja 25 11001. Nüüd võrdleme neid kahte numbrit ja määrame nende põhjal kolmanda numbri.

18 = 10010 25 = 11001

Numbrites on esimesed kaks bitti mõlemad 1, seega algab tu­le­mus­num­ber samuti numbriga 1. Numbrite 25 teine bitt on samuti 1, kuid numbri 18 teine bitt on 0, mistõttu kolmanda numbri number on 0. Pärast mõlema numbri bittide lä­bi­vaa­ta­mist saame tu­le­mu­seks bi­naar­numbri 10000. Kui tei­sen­dame selle küm­nend­numbri, on tu­le­mu­seks 16.

Kood näeb välja järgmine:

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

Konsoli väljund peaks olema 16.

Bi­ti­vii­si­line OR

Java operaator bitwise OR võrdleb ka kahte numbrit bithaaval. Sel juhul peab aga ainult ühel kahest ope­ran­dist olema väärtus 1, et tu­le­mu­seks oleks 1. Kui võtame eelmise näite numbrid, siis see näeb välja järgmine:

18 = 10010 25 = 11001

Kuna kõik bittid, välja arvatud kolmas number, si­sal­da­vad vähemalt ühte 1, on tu­le­mu­seks number: 11011. Kon­ver­tee­ri­des saame tu­le­mu­seks 27.

Siin on näide, kuidas see kood välja näeb:

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

XOR

XOR ehk bi­ti­vii­si­line eksklu­siivne OR (^) on sarnane bi­ti­vii­si­lise OR-iga. Bi­ti­vii­si­lise OR-i puhul peab üks või mõlemad operandid olema 1, et väl­jun­diks oleks 1. XOR-i puhul aga on väl­jun­diks 1 ainult siis, kui täpselt üks kahest väär­tu­sest on 1. Et paremini mõista, kuidas XOR töötab, vaatame ühte näidet:

18 = 10010 25 = 11001

Esimesed kaks bitti on väär­tu­sega 1, seega Java bi­ti­teh­ni­lise ope­raa­tori abil on tu­le­mu­seks 0. 18 teine bitt on 0, kuid 25 teine bitt on 1. Selle tu­le­mu­seks on väärtus 1. Kui jätkame, saame numbri 01011. De­si­maal­süs­tee­mis on see 11.

Siin on kood:

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

Vasakule ni­hu­ta­mine

Vasakule ni­hu­ta­mine nihutab väärtuse a bitte vasakule kaugusega b. Tekkinud tühikud täi­de­takse numbriga 0. Seda il­lust­ree­rib hästi int-tüüpi väärtus, mis võtab mälus 32 bitti. Võtame taas numbri 20 ehk 10010 ja nihutame seda b-väär­tu­sega 2, saades c-väär­tu­seks 1001000. Lõppu lisatakse kaks nulli. 1001000 vastab küm­nend­väär­tu­sele 72.

Siin on näide, kuidas see protsess koodis välja näeb:

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

Paremini ni­hu­ta­mine märgiga

Pa­rem­poolne ni­hu­ta­mine toimib vas­tu­pi­di­selt. Siin ni­hu­ta­takse väärtuse a bitti väärtuse b võrra paremale, mis annab tu­le­mu­seks väärtuse c. Selle tu­le­mu­sena jäävad viimased bittid välja. Kui nihutame 20 või 10010 kaks kohta paremale, on tu­le­mu­seks 100 või 4.

Siin on kood:

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

Tähtis on märkida, et kui a on po­si­tiivne number, täi­de­takse tühikud numbriga 0. Kui see on ne­ga­tiivne, asen­da­takse tühikud numbriga 1.

Pa­rem­poolne nihutus ilma märgita

Põ­hi­mõt­te­li­selt toimib Java bi­ti­vii­si­line operaator pa­rem­poolne nihutus ilma märgita (>>>) samamoodi. Ainus erinevus on see, et pa­rem­poolse nihutuse tulemusel vasakule tekkinud tühikud täi­de­takse alati nullidega. Selle tu­le­mu­seks on alati po­si­tiivne number, isegi kui alg­väär­tus oli ne­ga­tiivne. 4c5f986ec517d687f98f93f0abe2fb9b

Go to Main Menu