Operator Java Bitwise

Dalam pelajaran hari ini, kita akan mengenal Operator Java Bitwise dan mempertimbangkan contoh cara bekerja dengannya. Anda mungkin akrab dengan kata "bit". Jika tidak, mari kita ingat artinya :) Sedikit adalah unit informasi terkecil di komputer. Namanya berasal dari digit biner . Sedikit dapat dinyatakan dengan salah satu dari dua angka: 1 atau 0. Ada sistem bilangan biner khusus berdasarkan satu dan nol. Kami tidak akan mempelajari hutan matematika di sini. Kami hanya akan mencatat bahwa angka apa pun di Jawa dapat diubah menjadi bentuk biner. Untuk melakukan ini, Anda perlu menggunakan kelas pembungkus. Misalnya, inilah cara Anda melakukan ini untuk int :

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(Integer.toBinaryString(x));
   }
}

Output konsol: 101010110 1010 10110 (saya menambahkan spasi agar lebih mudah dibaca) adalah angka 342 dalam sistem desimal. Kami benar-benar memecah angka ini menjadi bit individual: nol dan satu. Operasi yang dilakukan pada bit disebut bitwise .

• ~ - bitwise TIDAK.

Operator ini sangat sederhana: melewati setiap bit nomor kita, dan membalikkan bit: nol menjadi satu, dan satu menjadi nol. Jika kita menerapkannya pada angka 342 kita, inilah yang terjadi: 101010110 adalah 342 direpresentasikan sebagai angka biner 010101001 adalah nilai ekspresi ~342 Mari kita coba mempraktikkannya:

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(~x);
   }
}

Output konsol: 169 169 adalah hasil kami ( 010101001 ) dalam sistem desimal yang sudah dikenal :)

• & - bitwise DAN

Seperti yang Anda lihat, tampilannya sangat mirip dengan logika AND ( && ). Operator && , seperti yang Anda ingat, mengembalikan true hanya jika kedua operand benar. Bitwise & bekerja dengan cara yang sama: membandingkan dua angka sedikit demi sedikit. Perbandingan menghasilkan angka ketiga. Sebagai contoh, mari kita ambil angka 277 dan 432: 110110000 adalah 277 direpresentasikan sebagai angka biner 1000101011 adalah 432 direpresentasikan sebagai angka biner Selanjutnya, operator & membandingkan bit pertama dari angka atas dengan bit pertama dari angka bawah. Karena ini adalah operator AND, hasilnya akan menjadi 1 hanya jika kedua bitnya adalah 1. Dalam kasus lain, hasilnya adalah 0. 100010101 && operator Pertama, kita bandingkan bit pertama dari dua angka, lalu bit kedua, lalu bit ketiga, dan seterusnya. Seperti yang Anda lihat, hanya dalam dua kasus kedua bit yang sesuai dalam angka sama dengan 1 (bit pertama dan kelima). Semua perbandingan lainnya menghasilkan 0s. Jadi pada akhirnya kita mendapatkan angka 10001000. Dalam sistem desimal, itu sesuai dengan angka 272. Mari kita periksa:

public class Main {

   public static void main(String[] args) {
       System.out.println(277&432);
   }
}

Keluaran konsol: 272

• | - sedikit demi sedikit ATAU.

Operator ini bekerja dengan cara yang sama: membandingkan dua angka sedikit demi sedikit. Hanya sekarang jika setidaknya salah satu bitnya adalah 1, maka hasilnya adalah 1. Mari kita lihat angka yang sama (277 dan 432): 100010101 | 110110000 _______________ 110110101 - hasil dari | operator Di sini kita mendapatkan hasil yang berbeda: satu-satunya bit yang tetap nol adalah bit yang nol di kedua angka. Hasilnya adalah angka 110110101. Dalam sistem desimal, ini sesuai dengan angka 437 Mari kita periksa:

public class Main {

   public static void main(String[] args) {
       System.out.println(277|432);
   }
}

Keluaran konsol: 437 Kami menghitung semuanya dengan benar! :)

• ^ - bitwise XOR (OR eksklusif)

Kami belum menemukan operator ini. Tapi tidak ada yang rumit tentang itu. Ini mirip dengan operator OR biasa. Ada satu perbedaan: OR biasa mengembalikan true jika setidaknya satu operan benar. Tapi tidak harus satu: jika kedua operan benar, hasilnya benar. Tetapi OR eksklusif mengembalikan nilai benar hanya jika tepat salah satu operan benar. Jika kedua operan benar, OR biasa mengembalikan benar ("setidaknya satu benar"), tetapi XOR mengembalikan salah. Itu sebabnya disebut OR eksklusif. Mengetahui cara kerja operator bitwise sebelumnya, Anda mungkin dapat dengan mudah menghitung 277 ^ 432. Tapi mari kita gali bersama sekali lagi :) 100010101 ^ 110110000 _______________ 010100101 - hasil dari ^operator Itulah hasil kami. Bit-bit yang sama di kedua angka menghasilkan 0 (artinya tes "hanya satu" gagal). Tapi bit yang membentuk pasangan 0-1 atau 1-0 menjadi satu. Hasil kita adalah angka 010100101. Dalam sistem desimal, ini sesuai dengan angka 165. Mari kita lihat apakah perhitungan kita benar:

public class Main {

   public static void main(String[] args) {
       System.out.println(277^432);
   }
}

Keluaran konsol: 165 Super! Semuanya seperti yang kita duga :) Sekarang saatnya berkenalan dengan operator bit shift. Nama berbicara untuk dirinya sendiri. Kami mengambil beberapa angka, dan memindahkan bitnya ke kiri atau ke kanan :) Mari kita lihat tampilannya:

Geser ke kiri

Pergeseran bit ke kiri ditunjukkan dengan << Berikut contohnya:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(Integer.toBinaryString(x));
       System.out.println(Integer.toBinaryString(z));
   }
}

Dalam contoh ini, angka x = 64 disebut nilai. Ini adalah bagian dari nilai yang akan kita ubah. Kami akan menggeser bit ke kiri (Anda bisa menebaknya dengan arah operator << ) Dalam sistem biner, angka 64 = 1000000 Angka y = 3 disebut jarak pergeseran. Jarak pergeseran menunjukkan berapa banyak bit ke kanan/kiri yang ingin Anda geser bit dari angka x Dalam contoh kita, kita akan menggesernya 3 bit ke kiri. Untuk melihat proses pergeseran lebih jelas, lihat gambarnya. Dalam contoh ini, kami menggunakan int s. Int menempati 32 bit dalam memori komputer. Beginilah tampilan nomor 64 asli kami: Dan sekarang kami mengambil masing-masing bit kami dan benar-benar menggesernya ke kiri sebanyak 3 tempat: Lihatlah apa yang kita punya. Seperti yang Anda lihat, semua bit kami telah bergeser, dan 3 angka nol lainnya telah ditambahkan dari tepi rentang. Tiga, karena kita menggeser 3. Jika kita menggeser 10, 10 nol akan ditambahkan. Jadi, ungkapan x << y berarti "menggeser bit-bit bilangan x ke kiri sebanyak y tempat". Hasil dari ekspresi kita adalah bilangan 1000000000, yaitu 512 dalam sistem desimal. Mari kita periksa:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

Keluaran konsol: 512 Tepat! Secara teoritis, bit dapat digeser tanpa henti, tetapi karena bilangan kita adalah int , kita hanya memiliki 32 digit biner yang tersedia. Dari jumlah tersebut, 7 sudah ditempati oleh 64 (1.000.000). Oleh karena itu, jika kita menggeser 27 tempat ke kiri, satu-satunya tempat kita akan bergerak di luar jangkauan tipe data dan hilang. Hanya nol yang tersisa!

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 26;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

Keluaran konsol: 0 Seperti yang diharapkan, yang bergerak melampaui 32 bit yang tersedia dan menghilang. Kami mengakhiri dengan angka 32-bit yang hanya terdiri dari nol. Secara alami, ini sesuai dengan 0 dalam sistem desimal. Berikut aturan sederhana untuk mengingat pergeseran ke kiri: Untuk setiap pergeseran ke kiri, angkanya dikalikan dengan 2. Mari kita coba hitung ekspresi berikut tanpa gambar bit 111111111 << 3 Kita perlu mengalikan angka 111111111 dengan 2 . Hasilnya, kami mendapatkan 888888888. Mari tulis beberapa kode dan periksa:

public class Main {

   public static void main(String[] args) {
       System.out.println(111111111 << 3);
   }
}

Keluaran konsol: 888888888

Geser ke kanan

Operasi ini dilambangkan dengan >> . Itu melakukan hal yang sama, tetapi ke arah lain! :) Kami tidak akan menemukan kembali roda. Mari kita coba dengan int 64 yang sama.

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 2;// Shift distance

       int z = (x >> y);
       System.out.println(z);
   }
}

Sebagai hasil dari pergeseran ke kanan sebesar 2, dua angka nol ekstrim di bilangan kita keluar dari jangkauan dan hilang. Kita mendapatkan 10000, yang sesuai dengan angka 16 dalam sistem desimal Keluaran konsol: 16 Berikut adalah aturan sederhana untuk mengingat pergeseran ke kanan: Setiap pergeseran ke kanan dibagi dua, membuang sisanya. Misalnya, 35 >> 2 berarti kita perlu membagi 35 dengan 2 dua kali, buang sisanya 35/2 = 17 (buang sisa 1) 17/2 = 8 (buang sisa 1) Pada akhirnya, 35 >> 2 seharusnya sama dengan 8. Mari kita periksa:

public class Main {

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

Keluaran konsol: 8

Prioritas operator di Jawa

Saat menulis dan membaca kode, Anda akan sering menemukan ekspresi yang menggabungkan beberapa operasi. Sangat penting untuk memahami urutan mereka akan dieksekusi (jika tidak, Anda mungkin akan terkejut dengan hasilnya) Karena Java memiliki banyak operasi, masing-masing telah diberi tempat di tabel khusus:

Prioritas Operator

Semua operasi dilakukan dari kiri ke kanan, dengan mempertimbangkan prioritasnya. Misalnya, jika kita menulis

int x  = 6 - 4/2;

maka operasi pembagian ( 4/2 ) akan dilakukan terlebih dahulu. Meskipun berada di urutan kedua, ia memiliki prioritas yang lebih tinggi. Tanda kurung dan tanda kurung menunjukkan prioritas maksimum. Anda mungkin ingat itu dari sekolah. Misalnya, jika Anda menambahkannya ke ekspresi

int x  = (6 - 4)/2;

maka pengurangan dilakukan terlebih dahulu, karena dilampirkan dalam tanda kurung. Prioritas operator && logis agak rendah (lihat tabel), sehingga biasanya akan menjadi yang terakhir. Misalnya:

boolean x = 6 - 4/2 > 3 && 12*12 <= 119;

Ekspresi ini akan dieksekusi sebagai berikut:

• 4/2 = 2

boolean x = 6 - 2 > 3 && 12*12 <= 119;

• 12*12 = 144

boolean x = 6 - 2 > 3 && 144 <= 119;

• 6-2 = 4

boolean x = 4 > 3 && 144 <= 119;

Selanjutnya, operator pembanding dieksekusi:

• 4 > 3 = benar

boolean x = true && 144 <= 119;

• 144 <= 119 = salah

boolean x = true && false;

Dan, terakhir, operator AND ( && ) akan dieksekusi terakhir.

boolean x = true && false;
boolean x = false;

Misalnya, operator penjumlahan( + ) memiliki prioritas lebih tinggi daripada operator pembanding != (tidak sama); Oleh karena itu, dalam ungkapan

boolean x = 7 != 6+1;

operasi 6+1 akan dilakukan terlebih dahulu, kemudian pemeriksaan 7 != 7 (yang dievaluasi menjadi salah), dan akhirnya penugasan hasil (salah) ke variabel x (penugasan umumnya memiliki prioritas terendah dari semua operator; lihat meja). Fiuh! Itu adalah pelajaran yang sangat besar, tetapi Anda berhasil! Jika Anda tidak sepenuhnya memahami beberapa pelajaran ini atau sebelumnya, jangan khawatir. Kami akan membahas topik ini lebih dari sekali di masa mendatang. Beberapa pelajaran CodeGym tentang operasi logis dan numerik. Kami tidak akan membahasnya dalam waktu dekat, tetapi tidak ada salahnya Anda membacanya sekarang.