pengendali Java Bitwise

Dalam pelajaran hari ini, kita akan berkenalan dengan Operator Bitwise Java dan mempertimbangkan contoh cara untuk bekerja dengan mereka. Anda mungkin biasa dengan perkataan "bit". Jika tidak, mari kita ingat kembali apa maksudnya :) A bit ialah unit maklumat terkecil dalam komputer. Namanya berasal daripada digit binari . Sedikit boleh dinyatakan dengan satu daripada dua nombor: 1 atau 0. Terdapat sistem nombor binari khas berdasarkan satu dan sifar. Kami tidak akan menyelami hutan matematik di sini. Kami hanya akan ambil perhatian bahawa sebarang nombor dalam Java boleh ditukar kepada bentuk binari. Untuk melakukan ini, anda perlu menggunakan kelas pembalut. Sebagai contoh, berikut ialah cara anda boleh 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 tambah ruang untuk memudahkan bacaan) ialah nombor 342 dalam sistem perpuluhan. Kami sebenarnya telah memecahkan nombor ini kepada bit individu: sifar dan satu. Operasi yang dilakukan pada bit dipanggil bitwise .

• ~ - bitwise TIDAK.

Pengendali ini sangat mudah: ia melepasi setiap bit nombor kami, dan membalikkan bit: sifar menjadi satu, dan satu menjadi sifar. Jika kita menggunakannya pada nombor 342 kita, inilah yang berlaku: 101010110 ialah 342 diwakili sebagai nombor perduaan 010101001 ialah nilai ungkapan ~342 Mari kita cuba mengamalkannya:

public class Main {

   public static void main(String[] args) {

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

Output konsol: 169 169 ialah hasil kami ( 010101001 ) dalam sistem perpuluhan biasa :)

• & - bitwise DAN

Seperti yang anda lihat, ia kelihatan agak serupa dengan logik AND ( && ). Operator && , anda akan ingat, mengembalikan benar hanya jika kedua-dua operan adalah benar. Bitwise & berfungsi dengan cara yang sama: ia membandingkan dua nombor sedikit demi sedikit. Perbandingan menghasilkan nombor ketiga. Sebagai contoh, mari kita ambil nombor 277 dan 432: 110110000 ialah 277 diwakili sebagai nombor binari 1000101011 ialah 432 diwakili sebagai nombor binari Seterusnya, pengendali & membandingkan bit pertama nombor atas dengan bit pertama nombor bawah. Kerana ini adalah operator AND, hasilnya akan menjadi 1 hanya jika kedua-dua bit adalah 1. Dalam mana-mana kes lain, hasilnya ialah 0. 100010101 && operator Pertama, kita membandingkan bit pertama dua nombor, kemudian bit kedua, kemudian ketiga, dan seterusnya. Seperti yang anda lihat, dalam dua kes sahaja kedua-dua bit yang sepadan dalam nombor yang sama dengan 1 (bit pertama dan kelima). Semua perbandingan lain menghasilkan 0s. Jadi pada akhirnya kita mendapat nombor 10001000. Dalam sistem perpuluhan, ia sepadan dengan nombor 272. Mari kita semak:

public class Main {

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

Output konsol: 272

• | - bitwise ATAU.

Operator ini berfungsi dengan cara yang sama: membandingkan dua nombor sedikit demi sedikit. Hanya sekarang jika sekurang-kurangnya satu bit ialah 1, maka hasilnya ialah 1. Mari kita lihat nombor yang sama (277 dan 432): 100010101 | 110110000 _______________ 110110101 - hasil daripada | operator Di sini kita mendapat hasil yang berbeza: satu-satunya bit yang kekal sifar ialah bit yang sifar dalam kedua-dua nombor. Hasilnya ialah nombor 110110101. Dalam sistem perpuluhan, ia sepadan dengan nombor 437 Mari kita semak:

public class Main {

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

Output konsol: 437 Kami mengira semuanya dengan betul! :)

• ^ - bitwise XOR (eksklusif ATAU)

Kami masih belum menemui pengendali ini. Tetapi tidak ada yang rumit mengenainya. Ia serupa dengan pengendali OR biasa. Terdapat satu perbezaan: OR biasa mengembalikan benar jika sekurang-kurangnya satu operan adalah benar. Tetapi ia tidak semestinya satu: jika kedua-dua operan adalah benar, hasilnya adalah benar. Tetapi eksklusif ATAU mengembalikan benar hanya jika betul-betul salah satu operan adalah benar. Jika kedua-dua operan adalah benar, OR biasa mengembalikan benar ("sekurang-kurangnya satu benar"), tetapi XOR mengembalikan palsu. Itulah sebabnya ia dipanggil eksklusif ATAU. Mengetahui bagaimana operator bitwise sebelumnya berfungsi, anda mungkin boleh mengira dengan mudah 277 ^ 432. Tetapi mari kita gali bersama-sama sekali lagi :) 100010101 ^ 110110000 _______________ 010100101 - hasil daripada ^operator Itulah keputusan kami. Bit yang sama dalam kedua-dua nombor menghasilkan 0 (bermaksud ujian "satu-satunya" gagal). Tetapi bit yang membentuk pasangan 0-1 atau 1-0 menjadi satu. Keputusan kami ialah nombor 010100101. Dalam sistem perpuluhan, ia sepadan dengan nombor 165. Mari lihat sama ada pengiraan kami betul:

public class Main {

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

Output konsol: 165 Super! Segala-galanya adalah seperti yang kita fikirkan :) Kini tiba masanya untuk berkenalan dengan operator anjakan bit. Nama bercakap untuk dirinya sendiri. Kami mengambil beberapa nombor, dan menggerakkan bitnya ke kiri atau kanan :) Mari lihat rupanya:

Beralih ke kiri

Peralihan bit ke kiri ditunjukkan oleh << Berikut ialah contoh:

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, nombor x = 64 dipanggil nilai. Ia adalah serpihan nilai yang akan kita alihkan. Kami akan mengalihkan bit ke kiri (anda boleh meneka ini mengikut arah operator << ) Dalam sistem binari, nombor 64 = 1000000 Nombor y = 3 dipanggil jarak anjakan. Jarak anjakan menunjukkan bilangan bit ke kanan/kiri yang anda mahu alihkan bit nombor x Dalam contoh kami, kami akan mengalihkannya 3 bit ke kiri. Untuk melihat proses peralihan dengan lebih jelas, lihat gambar. Dalam contoh ini, kami menggunakan int s. Int menduduki 32 bit dalam ingatan komputer. Beginilah rupa nombor 64 asal kami: Dan sekarang kami mengambil setiap bit kami dan mengalihkannya ke kiri sebanyak 3 tempat: Lihatlah apa yang kami dapat. Seperti yang anda lihat, semua bit kami telah beralih, dan 3 sifar lagi telah ditambah dari tepi julat. Tiga, kerana kita beralih sebanyak 3. Jika kita telah beralih sebanyak 10, 10 sifar akan ditambah. Oleh itu, ungkapan x << y bermaksud "alihkan bit nombor x ke kiri dengan y tempat". Hasil ungkapan kami ialah nombor 1000000000, iaitu 512 dalam sistem perpuluhan. Mari semak:

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);
   }
}

Output konsol: 512 Spot on! Secara teorinya, bit boleh dialihkan tanpa henti, tetapi kerana nombor kami adalah int , kami hanya mempunyai 32 digit binari yang tersedia. Daripada jumlah ini, 7 telah diduduki oleh 64 (1000000). Oleh itu, jika kami mengalihkan 27 tempat ke kiri, satu-satunya tempat kami akan bergerak melepasi julat jenis data dan hilang. Hanya sifar akan kekal!

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);
   }
}

Output konsol: 0 Seperti yang dijangkakan, yang bergerak melepasi 32 bit yang tersedia dan hilang. Kami berakhir dengan nombor 32-bit yang terdiri daripada sifar sahaja. Sememangnya, ini sepadan dengan 0 dalam sistem perpuluhan. Berikut ialah peraturan mudah untuk mengingati anjakan ke kiri: Untuk setiap anjakan ke kiri, nombornya didarabkan dengan 2. Mari cuba kira ungkapan berikut tanpa gambar bit 111111111 << 3 Kita perlu mendarabkan nombor 111111111 dengan 2. Hasilnya, kami mendapat 888888888. Mari tulis beberapa kod dan semak:

public class Main {

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

Output konsol: 888888888

Beralih ke kanan

Operasi ini dilambangkan dengan >> . Ia melakukan perkara yang sama, tetapi ke arah lain! :) Kami tidak akan mencipta semula roda. Mari cuba 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);
   }
}

Hasil daripada peralihan ke kanan sebanyak 2, dua sifar melampau dalam nombor kami bergerak keluar dari julat dan hilang. Kami mendapat 10000, yang sepadan dengan nombor 16 dalam sistem perpuluhan Output Konsol: 16 Berikut ialah peraturan mudah untuk mengingati anjakan ke kanan: Setiap anjakan ke kanan membahagi dua, membuang sebarang baki. Sebagai contoh, 35 >> 2 bermakna kita perlu membahagikan 35 dengan 2 dua kali, membuang baki 35/2 = 17 (buang baki 1) 17/2 = 8 (buang baki 1) Pada akhirnya, 35 >> 2 sepatutnya sama dengan 8. Mari kita semak:

public class Main {

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

Output konsol: 8

Keutamaan operator dalam Java

Semasa menulis dan membaca kod, anda sering akan menemui ungkapan yang menggabungkan beberapa operasi. Adalah sangat penting untuk memahami susunan ia akan dilaksanakan (jika tidak, anda mungkin terkejut dengan hasilnya) Oleh kerana Java mempunyai banyak operasi, setiap satu daripadanya telah diberikan tempat dalam jadual khas:

Keutamaan Operator

Semua operasi dilakukan dari kiri ke kanan, dengan mengambil kira keutamaannya. Sebagai contoh, jika kita menulis

int x  = 6 - 4/2;

maka operasi bahagi ( 4/2 ) akan dilakukan terlebih dahulu. Walaupun ia berada di tempat kedua, ia mempunyai keutamaan yang lebih tinggi. Tanda kurung dan kurungan menunjukkan keutamaan maksimum. Anda mungkin ingat itu dari sekolah. Contohnya, jika anda menambahkannya pada ungkapan

int x  = (6 - 4)/2;

maka penolakan dilakukan terlebih dahulu, kerana ia disertakan dalam kurungan. Keutamaan operator && logik agak rendah (lihat jadual), jadi ia biasanya akan terakhir. Sebagai contoh:

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

Ungkapan ini akan dilaksanakan seperti 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;

Seterusnya, pengendali perbandingan dilaksanakan:

• 4 > 3 = benar

boolean x = true && 144 <= 119;

• 144 <= 119 = palsu

boolean x = true && false;

Dan, akhirnya, operator AND ( && ) akan dilaksanakan terakhir.

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

Sebagai contoh, pengendali penambahan( + ) mempunyai keutamaan yang lebih tinggi daripada operator perbandingan != (tidak sama); Oleh itu, dalam ungkapan

boolean x = 7 != 6+1;

operasi 6+1 akan dilakukan dahulu, kemudian semakan 7 != 7 (yang menilai kepada palsu), dan akhirnya penetapan hasil (palsu) kepada pembolehubah x (tugasan secara amnya mempunyai keutamaan yang paling rendah daripada semua operator; lihat meja). Fuh! Ia adalah satu pengajaran yang besar, tetapi anda berjaya! Jika anda tidak memahami sepenuhnya beberapa pelajaran ini atau sebelumnya, jangan risau. Kami akan menyentuh topik ini lebih daripada sekali pada masa hadapan. Beberapa pelajaran CodeGym tentang operasi logik dan berangka. Kami tidak akan mendapatkannya dalam masa terdekat, tetapi tidak ada salahnya anda membacanya sekarang.