Operasi bitwise di Java

Anda mungkin akrab dengan kata “mengalahkan”. Jika belum, yuk kita kenali :) Bit adalah satuan minimum pengukuran informasi dalam sebuah komputer. Namanya berasal dari bahasa Inggris “ digit biner ” - “bilangan biner”. Sebuah bit dapat dinyatakan sebagai salah satu dari dua angka: 1 atau 0. Ada sistem bilangan khusus berdasarkan satu dan nol - biner. Kami tidak akan mempelajari belantara matematika dan hanya mencatat bahwa bilangan apa pun di Java dapat dikonversi ke bentuk binernya. Untuk melakukan ini, Anda perlu menggunakan kelas wrapper. Misalnya, berikut cara melakukannya untuk suatu nomor int:

public class Main {

   public static void main(String[] args) {

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

Keluaran konsol:

101010110

1010 10110 (saya menambahkan spasi agar mudah dibaca) adalah angka 342 dalam biner. Kami sebenarnya telah membagi angka ini menjadi bit-bit individual - nol dan satu. Dengan mereka kita dapat melakukan operasi yang disebut bitwise.

• ~— operator “TIDAK” bitwise.

Cara kerjanya sangat sederhana: ia menelusuri setiap bit angka kita dan mengubah nilainya menjadi kebalikannya: nol menjadi satu, satu menjadi nol. Jika kita menerapkannya ke nomor kita 342, inilah yang kita dapatkan: 101010110 adalah angka 342 dalam biner 010101001 adalah hasil dari ekspresi ~342 Tetapi karena variabel int membutuhkan 4 byte, yaitu 32 bit, sebenarnya angka dalam variabel disimpan sebagai: 00000000 00000000 00000001 01010110- angka 342 dalam variabel bertipe int di java 11111111 11111111 11111110 10101001- hasil ekspresi ~342 di java Mari kita coba melakukan ini dalam praktik:

public class Main {

   public static void main(String[] args) {

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

Keluaran konsol:

11111111111111111111111010101001

• &— operator bitwise “DAN”

Seperti yang Anda lihat, penulisannya sangat mirip dengan logika “DAN” ( &&). Operator &&, seperti yang Anda ingat, truehanya kembali jika kedua operan benar. Bitwise &bekerja dengan cara yang sama: membandingkan dua angka sedikit demi sedikit. Hasil perbandingan ini adalah angka ketiga. Sebagai contoh, mari kita ambil angka 277 dan 432: 100010101 - angka 277 dalam bentuk biner 110110000 - angka 432 dalam bentuk biner Selanjutnya, operator &membandingkan bit pertama dari angka atas dengan bit pertama dari angka yang lebih rendah. Karena ini adalah operator “DAN”, hasilnya akan sama dengan 1 hanya jika kedua bit sama dengan 1. Dalam kasus lainnya, hasilnya akan menjadi 0. 100010101 & 110110000 _______________ 100010000 - hasil kerja & Pertama-tama kita bandingkan bit pertama dari dua angka satu sama lain, lalu bit kedua, ketiga, dan seterusnya. Seperti yang Anda lihat, hanya dalam dua kasus kedua bit memiliki angka yang sama dengan 1 (bit pertama dan kelima). Hasil perbandingan lainnya adalah 0. Oleh karena itu, pada akhirnya kita mendapatkan angka 100010000. Dalam sistem desimal, ini 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”. Prinsip operasinya sama - kami membandingkan dua angka sedikit demi sedikit. Hanya sekarang jika setidaknya salah satu bitnya sama dengan 1, hasilnya akan sama dengan 1. Mari kita lihat angka yang sama - 277 dan 432:

100010101 | 110110000 _______________ 110110101 - hasil pekerjaan | Di sini hasilnya berbeda: hanya bit-bit yang nol di kedua angka yang tetap nol. Hasil pengerjaannya adalah angka 110110101. Dalam sistem desimal sama 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 eksklusif OR (juga dikenal sebagai XOR)

Kami belum pernah menjumpai operator seperti itu sebelumnya. Tapi tidak ada yang rumit dalam hal ini. Ini terlihat seperti “atau” biasa. Perbedaannya adalah satu: “atau” biasa kembali truejika setidaknya satu operan benar. Namun belum tentu salah – kalau keduanya ada true– maka hasilnya true. Namun “atau” eksklusif truehanya muncul jika salah satu operannya benar. Jika kedua operan benar, maka “or” biasa akan menghasilkan true(“setidaknya satu yang benar”), tetapi or akan eksklusif false. Makanya disebut eksklusif. Mengetahui prinsip operasi bitwise sebelumnya, Anda mungkin dapat dengan mudah melakukan sendiri operasi 277^432. Tapi lebih baik kita cari tahu bersama-sama sekali lagi :) 100010101 ^ 110110000 _______________ 010100101 - hasil kerja ^ Inilah hasil kita. Bit-bit yang sama pada kedua angka menghasilkan 0 (rumus “salah satu” tidak berfungsi). Namun yang membentuk pasangan 0-1 atau 1-0 akhirnya berubah menjadi satu kesatuan. Hasilnya, kita mendapat angka 010100101. Dalam sistem desimal, ini sama dengan angka 165. Mari kita lihat apakah kita menghitung dengan benar:

public class Main {

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

Keluaran konsol:

165

Super! Semuanya persis seperti yang kita pikirkan :) Sekaranglah waktunya untuk mengenal operasi yang disebut pergeseran bit. Nama itu, pada prinsipnya, berbicara sendiri. Kita ambil beberapa nomor dan gerakkan bitnya ke kiri dan ke kanan :) Mari kita lihat seperti apa:

Bergeser ke kiri

Pergeseran bit ke kiri ditunjukkan dengan tanda << Contoh:

public class Main {

   public static void main(String[] args) {
       int x = 64;//meaning
       int y = 3;//quantity

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

Dalam contoh ini, bilangan tersebut x=64disebut nilai. Bagian-bagiannyalah yang akan kita ubah. Kita akan menggeser bitnya ke kiri (hal ini dapat ditentukan dari arah tandanya <<). Dalam sistem biner, bilangan 64 = 1000000 Bilangan tersebut y=3disebut besaran. Kuantitas menjawab pertanyaan “berapa bit ke kanan/kiri yang harus digeser bit-bit suatu bilangan x?” Dalam contoh kita, kita akan menggesernya 3 bit ke kiri. Agar proses perpindahannya lebih jelas, mari kita lihat gambarnya. Dalam contoh kita, kita menggunakan angka bertipe int. Intmenempati 32 bit memori komputer. Seperti inilah bentuk angka 64 asli kita: Dan sekarang kita, dalam arti sebenarnya, mengambil setiap bit kita dan menggesernya ke kiri sebanyak 3 sel: Inilah yang kita dapatkan. Seperti yang Anda lihat, semua bit kami telah bergeser, dan 3 angka nol lagi telah ditambahkan dari luar rentang. 3 - karena kita menggeser sebanyak 3. Jika kita menggeser sebanyak 10, 10 angka nol akan ditambahkan. Jadi ungkapan tersebut x << yberarti “menggeser bit-bit dari хsel angka y ke kiri.” Hasil ekspresi kita adalah angka 1000000000, yang dalam sistem desimal sama dengan 512. Mari kita periksa:

public class Main {

   public static void main(String[] args) {
       int x = 64;//meaning
       int y = 3;//quantity

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

Keluaran konsol:

512

Itu benar! Secara teori, bit dapat digeser tanpa batas waktu. Tapi karena kita punya nomornya int, hanya tersedia 32 sel. Dari jumlah tersebut, 7 sudah ditempati oleh angka 64 (1.000.000). Oleh karena itu, jika kita melakukan, misalnya, 27 pergeseran ke kiri, satu-satunya unit kita akan keluar dari jangkauan dan “menimpa”. Hanya angka nol yang tersisa!

public class Main {

   public static void main(String[] args) {
       int x = 64;//meaning
       int y = 26;//quantity

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

Keluaran konsol:

0

Seperti yang kami duga, yang satu melampaui sel 32 bit dan menghilang. Kami mendapat nomor 32-bit yang hanya terdiri dari nol. Tentu saja, dalam sistem desimal nilainya sama dengan 0. Aturan sederhana untuk mengingat pergeseran ke kiri: Dengan setiap pergeseran ke kiri, angkanya dikalikan dengan 2. Sebagai contoh, mari kita coba menghitung hasil ekspresi tanpa gambar dengan bit. 111111111 << 3mengalikan angka 111111111 dengan 2 sebanyak tiga kali, sehingga kita mendapatkan 888888888. Mari kita tulis kodenya dan periksa:

public class Main {

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

Keluaran konsol:

888888888

Pergeseran kanan

Mereka ditandai dengan tanda >>. Mereka melakukan hal yang sama, hanya saja ke arah lain! :) Mari kita tidak menemukan kembali roda dan mencoba melakukan ini dengan nomor yang sama int 64.

public class Main {

   public static void main(String[] args) {
       int x = 64;//meaning
       int y = 2;//quantity

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

Sebagai akibat dari pergeseran sebesar 2 ke kanan, dua angka nol ekstrim dari bilangan kita keluar dari jangkauan dan terhapus. Kami mendapat angka 10.000, yang dalam sistem desimal sesuai dengan angka 16. Output ke konsol:

16

Aturan sederhana untuk mengingat shift kanan: Setiap shift kanan dibagi dua, membuang sisanya. Misalnya 35 >> 2 kita perlu membagi 35 dengan 2 sebanyak 2 kali, membuang sisanya 35/2 = 17(membuang sisa 1) 17:2 = 8(membuang sisa 1) Totalnya 35 >> 2harus sama dengan 8. Periksa:

public class Main {

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

Keluaran konsol:

8

Prioritas operasi di Jawa

Saat Anda menulis atau membaca kode, Anda akan sering menemukan ekspresi di mana beberapa operasi dilakukan secara bersamaan. Sangat penting untuk memahami urutan pelaksanaannya, jika tidak, hasilnya mungkin tidak terduga. Karena ada banyak operasi di Java, semuanya dipisahkan ke dalam tabel khusus:

Prioritas Operator

Semua operasi dilakukan dari kiri ke kanan, tetapi dengan mempertimbangkan prioritasnya. Misalnya, jika kita menulis: int x = 6 - 4/2; pertama operasi pembagian (4/2) akan dilakukan. Meskipun dia berada di urutan kedua, dia memiliki prioritas lebih tinggi. Tanda kurung atau tanda kurung siku mengubah prioritas apa pun menjadi maksimum. Anda mungkin ingat ini dari sekolah. Misalnya, jika Anda menambahkannya ke ekspresi: int x = (6 - 4)/2; pengurangan akan dilakukan terlebih dahulu, karena dihitung dalam tanda kurung. Operator logika memiliki &&prioritas yang agak rendah, seperti dapat dilihat dari tabel. Oleh karena itu, paling sering ini akan dieksekusi terakhir. Misalnya: boolean x = 6 - 4/2 > 3 && 12*12 <= 119; Ekspresi ini akan dieksekusi seperti ini:

• 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 perbandingan akan dieksekusi:

  4 > 3 = true

  boolean x = true && 144 <= 119;

• 144 <= 119 = false

  boolean x = true && false;

• Dan terakhir, operator terakhir akan dieksekusi &&.

  boolean x = true && false;

  boolean x = false;

  Operator penjumlahan ( +), misalnya, memiliki prioritas lebih tinggi dibandingkan operator pembanding !=(“tidak sama”);

  Oleh karena itu dalam ekspresi:

  boolean x = 7 != 6+1;

  pertama operasi 6+1 akan dilakukan, kemudian pemeriksaan 7!=7 (salah), dan pada akhirnya hasilnya akan ditetapkan ke falsevariabel x. Penugasan umumnya memiliki prioritas terendah dari semua operasi - lihat tabel.

Fiuh! Ceramah kita panjang, tapi kamu berhasil! Jika Anda belum sepenuhnya memahami beberapa bagian dari kuliah ini dan kuliah sebelumnya, jangan khawatir, kami akan membahas topik ini lebih dari sekali di masa mendatang. Berikut ini beberapa tautan berguna untuk Anda:

• Operator Logis - Kuliah JavaRush tentang operasi logis. Kami tidak akan membahasnya dalam waktu dekat, tetapi Anda dapat membacanya sekarang, tidak ada salahnya