# Mitä ovat Java-bittitason operaattorit ja miten niitä käytetään?

Java-bittikohtaisilla operaattoreilla voit manipuloida yksittäisiä bittejä haluamallasi tavalla. Seitsemän operaattoria on rakennettu samalla tavalla ja ne noudattavat helposti opittavia kiinteitä sääntöjä.

## Mitä ovat bittitason operaattorit ja mihin niitä käytetään?

Java-operaattorit ovat tärkeä työkalu ohjelmointikielen käytössä. Monien muiden mahdollisuuksien ja toimintojen lisäksi ne antavat sinulle mahdollisuuden manipuloida pienimpiä mahdollisia tietoyksiköitä: bittejä. Biteillä (*binääriluvuilla*) on oma numerojärjestelmä, joka perustuu arvoihin 0 ja 1. Jos haluat kysellä binääriarvoja bitti kerrallaan, tarvitset Java-kielessä bittikohtaisen operaattorin. Voit soveltaa tätä **numeerisiin tietotyyppeihin** (byte, char, int, short, long).

Vaikka et tarvitse tätä toimintoa päivittäin, se voi olla hyödyllinen monissa tilanteissa. Se voi olla kätevä esimerkiksi, jos haluat säästää tilaa **tietojen muuntamisessa**, jos haluat käyttää **XOR-operaattoria** tai jos **haluat vain muuttaa bittiä**. Ne ovat myös kaikkien korkeampien piiritoimintojen perusta. Siksi on tärkeää ymmärtää Java-bittitoimintojen perusominaisuudet.

## Mitkä Java-bittitason operaattorit ovat olemassa?

Java-kielessä on yhteensä seitsemän erilaista bittitason operaattoria. Jotta saisimme kattavan käsityksen, aloitamme operandeista *a* ja *b*.

- **~ (bittitason NOT, komplementti)**: Tämä operaattori kääntää bitit. 0 muuttuu 1:ksi ja 1 muuttuu 0:ksi.
- **&amp; (bittitason AND)**: Tämä operaattori tuottaa tulokseksi 1, jos molemmat operandit ovat 1. Muussa tapauksessa tulokseksi tulee 0.
- **| (bittitason OR)**: Tämä operaattori tuottaa 1:n, jos jompikumpi operandeista on myös 1.
- **^ (XOR tai bittitason eksklusiivinen OR)**: Tämä operaattori tuottaa 0:n, jos molemmilla operandeilla on sama arvo. Muussa tapauksessa se tuottaa 1:n.
- **&lt;&lt; (vasen siirto)**: Tämä operaattori siirtää operandin *a* vasemmalle *b* paikkaa. Jos tämä aiheuttaa tyhjiä paikkoja, ne täytetään nollilla.
- **&gt;&gt; (oikealle siirto merkin kanssa, aritmeettinen)**: Tämä operaattori siirtää kaikki *a:* n bitit *b* paikkaa oikealle. Jos suurimman arvon omaava bitti oli asetettu ennen suorittamista, se pysyy asetettuna myös jälkeenpäin. Negatiiviset luvut pysyvät negatiivisina.
- **&gt;&gt;&gt;&gt; (merkitsemätön oikealle siirtäminen, looginen)**: Tämä operaattori siirtää *a:* n bitit *b* paikkaa oikealle. Välilyönnit täytetään aina nollilla.

## Bittitason NOT

Java-bittikohtaisen operaattorin bittikohtainen NOT esitetään tilde-merkillä (~). Se **kumoaa kaikki bitit**, muuttamalla nollat ykkösiksi ja ykköset nolliksi. Otetaan esimerkiksi luku 20. Binäärimuodossa se näyttää tältä: 10100. Jos sovellamme bittitason NOT-operaattoria, jokainen luvun bitti vaihtuu: 10100 muuttuu **01011:ksi**. Tämä on lausekkeen ~20 arvo. Jos muunnamme tämän binääriluvun takaisin desimaaliluvuksi, saamme arvon -21. Jos haluat kokeilla tätä prosessia Java-kielellä, kirjoita seuraava koodi ja Java-komento `System.out.println` tulostaaksesi tuloksen.

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

Jos olet syöttänyt kaikki tiedot oikein, tuloksena pitäisi näkyä ”-21”.

## Bittitason AND

Bittitason AND **vertaa kahta lukua binäärimuodossa** bitti kerrallaan. Ensimmäisen luvun ensimmäinen bitti verrataan toisen luvun ensimmäiseen bittiin, toinen bitti toiseen bittiin ja niin edelleen. Jos molemmat bitit ovat 1, tuloksena on 1. Jos näin ei ole (molemmat bitit ovat 0 tai toinen biteistä on 0), tuloksena on 0. Alla olevassa esimerkissä tarkastelemme kahta desimaalilukua 18 ja 25. Binäärilukuna 18 on 10010 ja 25 binäärimuodossa on 11001. Vertaillaan nyt näitä kahta lukua ja määritetään niistä kolmas luku.

18 = 10010 25 = 11001

Numeroiden kaksi ensimmäistä bittiä ovat molemmat 1, joten tuloksena oleva numero alkaa myös 1:llä. Numero 25:n toinen bitti on myös 1, mutta numeron 18 toinen bitti on 0, joten kolmannen numeron numero on 0. Kun olemme käyneet läpi molemmat numerot bitti bittiä, saamme binääriluvun **10000**. Jos muunnamme tämän desimaaliluvuksi, tulos on 16.

Koodi näyttää tältä:

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

Konsolin tulosteen tulisi olla 16.

## Bittitason OR

Java-operaattori bitwise OR vertaa myös kahta lukua bitti bitiltä. Tässä tapauksessa kuitenkin vain toisen operandin arvon on oltava 1, jotta tulos on 1. Jos otamme edellisen esimerkin luvut, se näyttää tältä:

18 = 10010 25 = 11001

Koska kaikki bitit paitsi kolmas numero sisältävät vähintään yhden 1:n, tuloksena oleva luku on: **11011**. Muunnettuna saamme 27.

Tässä on esimerkki koodina:

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

## XOR

XOR tai bittitason eksklusiivinen OR (^) on samanlainen kuin bittitason OR. Bittitason OR:n tapauksessa yhden tai molempien operandien on oltava 1, jotta tuloksena saadaan 1. XOR:n tapauksessa tuloksena saadaan 1 vain, jos **täsmälleen toinen arvoista** on 1. Jotta XOR:n toiminta tulisi paremmin selväksi, katsotaanpa esimerkkiä:

18 = 10010 25 = 11001

Kahden ensimmäisen bitin arvo on 1, joten tämän Java-bittien operaattorin avulla tulos on 0. 18:n toinen bitti on 0, mutta 25:n toinen bitti on 1. Tuloksena on arvo 1. Jos jatkamme, saamme luvun **01011**. Desimaalimuodossa tämä on 11.

Tässä on koodi:

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

## Vasen siirtymä

Vasen siirto siirtää arvon *a* bittejä vasemmalle etäisyydellä *b*. Tuloksena syntyvät **tyhjät kohdat täytetään nollilla**. Tämä on helppo ymmärtää, kun tarkastellaan int-arvoa, joka vie muistista 32 bittiä. Otetaan *j* älleen luku 20 tai 10010 ja siirretään sitä b-arvolla 2, jolloin saadaan c-arvo **1001000**. Loppuun lisätään kaksi nollaa. 1001000 vastaa desimaalilukua 72.

Tässä on prosessin koodi:

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

## Oikealle siirtäminen merkin kanssa

Oikealle siirtäminen toimii päinvastoin. Tässä arvosta *a* siirretään bittejä oikealle arvolla *b*, mikä tuottaa arvon c. Tuloksena **viimeiset bitit jäävät pois**. Jos siirrämme 20 tai 10010 kaksi paikkaa oikealle, tulos on **100** tai 4.

Tässä on koodi:

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

On tärkeää huomata, että jos *a* on positiivinen luku, välit täytetään nollalla. Jos se on negatiivinen, välit korvataan ykkösellä.

## Oikealle siirtäminen ilman merkkiä

Periaatteessa Java-bittitason operaattori oikealle ilman merkkiä (&gt;&gt;&gt;) toimii samalla tavalla. Ainoa ero on, että oikealle siirtämisen vasemmalle puolelle syntyvät välit **täytetään aina nollilla**. Tämä johtaa aina positiiviseen lukuun, vaikka alkuarvo olisi negatiivinen.


This is a markdown version of: [https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-bittitason-operaattorit/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-bittitason-operaattorit/) for AI/LLM consumption.