TechCodeview

Java nyelven egy operátor a megadott műveleteket végrehajtó szimbólum. Ebben a részben csak a bitenkénti operátor és típusai megfelelő példákkal.

A bitenkénti operátor típusai

A Java bitenkénti operátorának hat típusa van:

• Bitenként ÉS
• Bitenkénti exkluzív VAGY
• Bitenkénti bezáró VAGY
• Bitenkénti dicséret
• Bit Shift operátorok

Magyarázzuk el részletesen a bitenkénti operátort.

Bitenkénti ÉS (&)

Ez egy bináris operátor, amelyet a szimbólum jelöl & . Akkor és csak akkor ad vissza 1-et, ha mindkét bit 1, különben 0-t ad vissza.

Használjuk a bitenkénti ÉS operátort egy Java programban.

int karakterlánchoz c++

BitwiseAndExample.java

 public class BitwiseAndExample { public static void main(String[] args) { int x = 9, y = 8; // bitwise and // 1001 & 1000 = 1000 = 8 System.out.println('x & y = ' + (x & y)); } } 

Kimenet

 x & y = 8 

Bitenkénti exkluzív VAGY (^)

Ez egy bináris operátor, amelyet a szimbólum jelöl ^ (ejtsd: caret). 0-t ad vissza, ha mindkét bit azonos, különben 1-et ad vissza.

Használjuk a bitenkénti kizárólagos VAGY operátort egy Java programban.

BitwiseXorExample.java

 public class BitwiseXorExample { public static void main(String[] args) { int x = 9, y = 8; // bitwise XOR // 1001 ^ 1000 = 0001 = 1 System.out.println('x ^ y = ' + (x ^ y)); } } 

Kimenet

 x ^ y = 1 

Bitenkénti bezáró VAGY (|)

Ez egy bináris operátor, amelyet a szimbólum jelöl | (pipának ejtve). 1-et ad vissza, ha valamelyik bit 1, egyébként 0-t ad vissza.

Használjuk a bitenkénti inkluzív VAGY operátort egy Java programban.

BitwiseInclusiveOrExample.java

 public class BitwiseInclusiveOrExample { public static void main(String[] args) y = ' + (x } 

Kimenet

 x | y = 9 

Bitenkénti kiegészítés (~)

Ez egy unáris operátor, amelyet a szimbólum jelöl ~ (tildeként ejtve). A bit inverzét vagy komplementerét adja vissza. Minden 0-t 1-re és minden 1-et 0-ra tesz.

róka vs farkas

Használjuk a bitenkénti komplement operátort egy Java programban.

BitwiseComplimentExample.java

 public class BitwiseComplimentExample { public static void main(String[] args) { int x = 2; // bitwise compliment // ~0010= 1101 = -3 System.out.println('~x = ' + (~x)); } } 

Kimenet

 ~x = -3 

Bit Shift operátorok

A Shift operátor a bitek jobbra vagy balra tolására szolgál. Használhatunk shift operátorokat, ha tetszőleges számot osztunk vagy szorozunk 2-vel. A bit eltolásának általános formátuma a következő:

 variable <> number of places to shift; 

Például ha a=10

 a>>2; //shifts two bits a>>4; //shifts 4 bits 

A Java a következő típusú shift operátorokat kínálja:

• Aláírt jobb műszakkezelő vagy bitenkénti jobb műszakkezelő
• Aláírás nélküli jobb műszakkezelő
• Aláírt bal műszakkezelő vagy bitenkénti bal műszakkezelő

Megjegyzés: A Java nem támogatja az előjel nélküli balra váltó operátort (<<<).< h4>

Aláírt jobb váltókezelő (>>)

Az előjeles jobbra váltó operátor egy szám bitmintáját a felé tolja el jobb meghatározott számú pozícióval és kitölti a 0. Az operátort a szimbólum jelöli >>. Megőrzi a bal szélső bitet is (jelbit). Ha 0 a bal szélső bitnél jelenik meg, ez azt jelenti, hogy a szám pozitív . Ha 1 a bal szélső bitnél jelenik meg, ez azt jelenti, hogy a szám negatív .

Általánosságban elmondható, hogy ha a>>n-t írunk, az azt jelenti, hogy egy szám bitjeit jobbra toljuk egy meghatározott (n) pozícióval. A matematikai értelemben az előjeles jobbra váltó operátort a következőképpen ábrázolhatjuk:

Megjegyzés: Ha egy pozitív számra jobb eltolás operátort alkalmazunk, akkor a pozitív számot is megkapjuk az eredményben. Hasonlóképpen, ha egy negatív számra jobb eltolás operátort alkalmazunk, akkor a negatív számot is megkapjuk az eredményben.

Példa: Alkalmazza az előjeles jobbra eltolási operátort a megadott 4-es pozíciókkal, ha x = 256 és x = -256.

Ha x = 256

256 >> 4

256/2⁴= 16

Ha x = -256

-256 >> 4

-256/2⁴= -16

A fenti példában megfigyeltük, hogy eltolás után a 256 operátor 16-ra, a -256 pedig -16-ra alakul át.

Készítsünk egy Java programot, és implementáljuk a bal oldali shift operátort.

SignedRightShiftOperatorExample.java

 public class SignedRightShiftOperatorExample { public static void main(String args[]) { int x = 50; System.out.println('x>>2 = ' + (x >>2)); } } 

Kimenet

 x>>2 = 12 

Aláírt bal műszakkezelő (<<)< strong>

Az aláírt bal műszak operátora (<<) shifts a bit pattern to the left. it is represented by symbol <<.< strong>Megőrzi a bal szélső bitet is (jelbit). Nem őrzi meg a jelbitet.

 public class SignedLeftShiftOperatorExample { public static void main(String args[]) { int x = 12; System.out.println(&apos;x&lt;<1 = ' + (x << 1)); } < pre> <p> <strong>Output</strong> </p> <pre> x&lt;<1 24 = < pre> <h3>Unsigned Right Shift Operator (&gt;&gt;&gt;)</h3> <p>It shifts a zero at the leftmost position and fills 0. It is denoted by the symbol <strong>&gt;&gt;&gt;.</strong> Note that the leftmost position after &gt;&gt; depends on the sign bit. It does not preserve the sign bit.</p> <p> <strong>Example: If a=11110000 and b=2, find a&gt;&gt;&gt;b?</strong> </p> <p>a &gt;&gt;&gt; b = 11110000 &gt;&gt;&gt; 2 = <strong>00111100</strong> </p> <p>The left operand value is moved right by the number of bits specified by the right operand and the shifted bits are filled up with zeros. Excess bits shifted off to the right are discarded.</p> <p>Therefore, before shifting the bits the decimal value of a is 240, and after shifting the bits the decimal value of a is 60.</p> <p>Let&apos;s create a Java program and use the unsigned right shift operator.</p> <p> <strong>UnsignedRightShiftOperatorExample.java</strong> </p> <pre> public class UnsignedRightShiftOperatorExample { public static void main(String args[]) { int x = 20; System.out.println(&apos;x&gt;&gt;&gt;2 = &apos; + (x &gt;&gt;&gt;2)); } } </pre> <p> <strong>Output</strong> </p> <pre> x&gt;&gt;&gt;2 = 5 </pre> <hr></1></pre></1>

 x>>>2 = 5