Operasi bitwise di Jawa

Anda mungkin biasa dengan perkataan "pukul". Jika belum, mari kita kenalinya :) Sedikit ialah unit minimum ukuran maklumat dalam komputer. Namanya berasal dari bahasa Inggeris " digit binari " - "nombor binari". Sedikit boleh dinyatakan sebagai salah satu daripada dua nombor: 1 atau 0. Terdapat sistem nombor khas berdasarkan satu dan sifar - binari. Kami tidak akan menyelidiki rimba matematik dan hanya ambil perhatian bahawa sebarang nombor di Jawa boleh ditukar kepada bentuk binarinya. Untuk melakukan ini, anda perlu menggunakan kelas pembalut. Sebagai contoh, berikut ialah cara melakukannya untuk nombor 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 menambah ruang untuk kebolehbacaan) ialah nombor 342 dalam binari. Kami sebenarnya telah membahagikan nombor ini kepada bit individu - sifar dan satu. Dengan merekalah kita boleh melakukan operasi yang dipanggil bitwise.

• ~— pengendali “TIDAK” bitwise.

Ia berfungsi dengan sangat mudah: ia melalui setiap bit nombor kami dan menukar nilainya kepada sebaliknya: sifar kepada satu, satu kepada sifar. Jika kita menggunakannya pada nombor 342 kita, inilah yang kita dapat: 101010110 - nombor 342 dalam binari 010101001 - hasil ungkapan ~342 Tetapi kerana pembolehubah int mengambil masa 4 bait, i.e. 32 bit, sebenarnya, nombor dalam pembolehubah disimpan sebagai: 00000000 00000000 00000001 01010110- nombor 342 dalam pembolehubah jenis int dalam java 11111111 11111111 11111110 10101001- hasil ungkapan ~342 dalam java Mari cuba lakukan ini dalam amalan:

public class Main {

   public static void main(String[] args) {

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

Output konsol:

11111111111111111111111010101001

• &— operator bitwise “DAN”

Seperti yang anda lihat, ia ditulis agak serupa dengan logik "DAN" ( &&). Operator &&, seperti yang anda ingat, kembali truehanya jika kedua-dua operan adalah benar. Bitwise &berfungsi dengan cara yang sama: ia membandingkan dua nombor sedikit demi sedikit. Hasil perbandingan ini ialah nombor ketiga. Sebagai contoh, mari kita ambil nombor 277 dan 432: 100010101 - nombor 277 dalam bentuk binari 110110000 - nombor 432 dalam bentuk binari Seterusnya, pengendali &membandingkan bit pertama nombor atas dengan bit pertama yang lebih rendah. Oleh kerana ini ialah pengendali "DAN", hasilnya akan sama dengan 1 hanya jika kedua-dua bit adalah sama dengan 1. Dalam semua kes lain, hasilnya akan menjadi 0. 100010101 & 110110000 _______________ 100010000 - hasil kerja & Kami mula-mula membandingkan bit pertama daripada dua nombor antara satu sama lain, kemudian bit kedua, ketiga, dsb. Seperti yang anda lihat, hanya dalam dua kes kedua-dua bit dalam nombor sama dengan 1 (bit pertama dan kelima). Hasil semua perbandingan lain ialah 0. Oleh itu, pada akhirnya kami mendapat nombor 100010000. 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”. Prinsip operasi adalah sama - kami membandingkan dua nombor sedikit demi sedikit. Hanya sekarang jika sekurang-kurangnya satu bit sama dengan 1, hasilnya akan sama dengan 1. Mari kita lihat nombor yang sama - 277 dan 432:

100010101 | 110110000 _______________ 110110101 - hasil kerja | Di sini hasilnya berbeza: hanya bit yang sifar dalam kedua-dua nombor kekal sifar. Hasil kerja 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 eksklusif ATAU (juga dikenali sebagai XOR)

Kami tidak pernah menemui pengendali sedemikian sebelum ini. Tetapi tidak ada yang rumit mengenainya. Ia kelihatan seperti "atau" biasa. Perbezaannya adalah satu: "atau" biasa kembali truejika sekurang-kurangnya satu operan adalah benar. Tetapi tidak semestinya satu - jika kedua-duanya ada true- maka hasilnya true. Tetapi "atau" eksklusif kembali truehanya jika salah satu operan adalah benar. Jika kedua-dua operan adalah benar, "atau" biasa akan kembali true("sekurang-kurangnya satu adalah benar"), tetapi eksklusif atau akan kembali false. Itulah sebabnya ia dipanggil eksklusif. Mengetahui prinsip operasi bitwise sebelumnya, anda mungkin boleh melakukan sendiri operasi 277^432 dengan mudah. Tetapi mari kita memikirkannya bersama-sama sekali lagi :) 100010101 ^ 110110000 _______________ 010100101 - hasil kerja ^ Berikut adalah hasil kami. Bit yang sama dalam kedua-dua nombor mengembalikan 0 (formula "satu daripada" tidak berfungsi). Tetapi mereka yang membentuk pasangan 0-1 atau 1-0 akhirnya bertukar menjadi satu unit. Akibatnya, kami mendapat nombor 010100101. Dalam sistem perpuluhan, ia sepadan dengan nombor 165. Mari lihat jika kami mengira dengan betul:

public class Main {

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

Output konsol:

165

Super! Semuanya betul-betul seperti yang kita fikirkan :) Sekarang adalah masa untuk membiasakan diri dengan operasi yang dipanggil anjakan bit. Nama itu, pada dasarnya, bercakap untuk dirinya sendiri. Kami akan mengambil beberapa nombor dan menggerakkan bitnya ke kiri dan kanan :) Mari lihat rupanya:

Beralih ke kiri

Peralihan bit kiri ditunjukkan oleh 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, nombor itu x=64dipanggil nilai. Ia adalah bahagiannya yang akan kita alihkan. Kami akan mengalihkan bit ke kiri (ini boleh ditentukan oleh arah tanda <<) Dalam sistem binari, nombor 64 = 1000000 Nombor itu y=3dipanggil kuantiti. Kuantiti menjawab soalan "berapa banyak bit ke kanan/kiri harus bit nombor dianjakkan x?" Dalam contoh kami, kami akan mengalihkannya 3 bit ke kiri. Untuk menjadikan proses peralihan lebih jelas, mari lihat gambar. Dalam contoh kami, kami menggunakan nombor jenis int. Int's menduduki 32 bit memori komputer. Inilah rupa nombor asal 64 kami: Dan sekarang kami, dalam erti kata literal, mengambil setiap bit kami dan mengalihkannya ke kiri sebanyak 3 sel: Inilah yang kami dapat. Seperti yang anda lihat, semua bit kami telah beralih, dan 3 lagi sifar telah ditambah dari luar julat. 3 - kerana kita beralih sebanyak 3. Jika kita beralih sebanyak 10, 10 sifar akan ditambah. Jadi ungkapan itu x << ybermaksud "menganjakkan bit хsel nombor y ke kiri." Hasil ungkapan kami ialah nombor 1000000000, yang dalam sistem perpuluhan adalah sama dengan 512. Mari kita semak:

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

Output konsol:

512

betul! Secara teori, bit boleh dialihkan selama-lamanya. Tetapi kerana kami mempunyai nombor int, terdapat hanya 32 sel yang tersedia. Daripada jumlah ini, 7 sudah diduduki oleh nombor 64 (1,000,000). Oleh itu, jika kita membuat, sebagai contoh, 27 anjakan ke kiri, satu-satunya unit kita akan keluar dari julat dan "tulis ganti". Hanya sifar akan kekal!

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

Output konsol:

0

Seperti yang kami jangkakan, yang melangkaui sel 32 bit dan hilang. Kami mendapat nombor 32-bit yang terdiri daripada sifar sahaja. Sememangnya, dalam sistem perpuluhan ia sepadan dengan 0. Peraturan mudah untuk mengingati anjakan kiri: Dengan setiap anjakan kiri, nombornya didarabkan dengan 2. Sebagai contoh, mari kita cuba mengira hasil ungkapan tanpa gambar dengan bit. 111111111 << 3 Kita perlu untuk mendarab nombor 111111111 dengan 2 tiga kali. Hasilnya, kita mendapat 888888888. Mari kita tulis kod dan semaknya:

public class Main {

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

Output konsol:

888888888

Peralihan kanan

Mereka ditunjukkan oleh tanda >>. Mereka melakukan perkara yang sama, hanya ke arah lain! :) Jangan cipta semula roda dan cuba lakukan ini dengan nombor 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);
   }
}

Hasil daripada peralihan sebanyak 2 ke kanan, dua sifar melampau nombor kami berada di luar julat dan dipadamkan. Kami mendapat nombor 10000, yang dalam sistem perpuluhan sepadan dengan nombor 16. Output ke konsol:

16

Peraturan mudah untuk mengingati anjakan kanan: Setiap anjakan kanan membahagi dua, membuang sebarang baki. Sebagai contoh, 35 >> 2 ini bermakna kita perlu membahagi 35 dengan 2 2 kali, membuang baki 35/2 = 17(membuang baki 1) 17:2 = 8(membuang baki 1) Jumlah 35 >> 2hendaklah sama dengan 8. Semak:

public class Main {

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

Output konsol:

8

Keutamaan operasi di Jawa

Semasa anda menulis atau membaca kod, anda akan sering menjumpai ungkapan di mana beberapa operasi dilakukan secara serentak. Adalah sangat penting untuk memahami dalam urutan apa yang akan dilakukan, jika tidak, hasilnya mungkin tidak dijangka. Oleh kerana terdapat banyak operasi di Jawa, semuanya dipisahkan ke dalam jadual khas:

Keutamaan Operator

Semua operasi dilakukan dari kiri ke kanan, tetapi mengambil kira keutamaannya. Sebagai contoh, jika kita menulis: int x = 6 - 4/2; pertama operasi bahagi (4/2) akan dilakukan. Walaupun dia berada di barisan kedua, dia mempunyai keutamaan yang lebih tinggi. Tanda kurung atau kurungan segi empat sama menukar sebarang keutamaan kepada maksimum. Anda mungkin ingat ini dari sekolah. Contohnya, jika anda menambahkannya pada ungkapan: int x = (6 - 4)/2; penolakan akan dilakukan terlebih dahulu, kerana ia dikira dalam kurungan. Operator logik mempunyai &&keutamaan yang agak rendah, seperti yang dapat dilihat dari jadual. Oleh itu, selalunya ia akan dilaksanakan terakhir. Sebagai contoh: boolean x = 6 - 4/2 > 3 && 12*12 <= 119; Ungkapan ini akan dilaksanakan 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;

• Seterusnya pengendali perbandingan akan dilaksanakan:

  4 > 3 = true

  boolean x = true && 144 <= 119;

• 144 <= 119 = false

  boolean x = true && false;

• Dan akhirnya, pengendali terakhir akan dilaksanakan &&.

  boolean x = true && false;

  boolean x = false;

  Operator penambahan ( +), sebagai contoh, mempunyai keutamaan yang lebih tinggi daripada operator perbandingan !=(“tidak sama”);

  Oleh itu dalam ungkapan:

  boolean x = 7 != 6+1;

  mula-mula operasi 6+1 akan dilakukan, kemudian semak 7!=7 (salah), dan pada akhirnya hasilnya akan diberikan kepada falsepembolehubah x. Tugasan secara amnya mempunyai keutamaan paling rendah daripada semua operasi - lihat dalam jadual.

Fuh! Kuliah kami panjang, tetapi anda berjaya! Jika anda tidak memahami sepenuhnya beberapa bahagian ini dan kuliah sebelumnya, jangan risau, kami akan menyentuh topik ini lebih daripada sekali pada masa hadapan. Berikut adalah beberapa pautan berguna untuk anda:

• Operator Logik - Syarahan JavaRush mengenai operasi logik. Kami tidak akan sampai kepada mereka dalam masa terdekat, tetapi anda boleh membacanya sekarang, tidak akan ada bahaya