Analisis kod sampel operasi bit Java

Operasi bitwise

Saya telah lama mempelajari operasi bitwise, tetapi saya sudah lama tidak menggunakannya sehingga saya rasa saya hampir melupakannya. Saya baru-baru ini melihat beberapa kod untuk aritmetik bit dan mendapati bahawa saya tidak dapat memahami semuanya, haha. Sudah tiba masanya untuk kembali dan mengejar perkara asas.

Semua nombor dalam atur cara disimpan dalam bentuk binari dalam ingatan komputer. Operasi bit adalah untuk beroperasi secara langsung pada bit binari integer dalam ingatan.

Pengendali untuk operasi bitwise:

运算符	含义
&	按位与
|	按位或
~	按位取反
^	按位异或
	左移
>>	带符号右移
>>>	无符号右移

Ini adalah pengetahuan yang sangat asas, tetapi jika anda tidak menggunakannya terlalu lama, anda pasti akan melupakannya Anda boleh menggunakannya lebih banyak semasa mengekod!

Cakap itu murah, tunjukkan kodnya.

Nota: Memang sukar untuk melihat aplikasinya apabila membincangkan perkara ini sahaja Anda boleh menyemak ringkasan orang lain.

Mari kita lihat aplikasi operasi bit dengan kod:

public final void writeInt(int v) throws IOException {
	  out.write((v >>> 24) & 0xFF);
	  out.write((v >>> 16) & 0xFF);
	  out.write((v >>>  8) & 0xFF);
	  out.write((v >>>  0) & 0xFF);
	  incCount(4);
}

Kod ini ialah kaedah dalam kelas DataOutputStream, digunakan untuk menulis integer integer dalam aliran . Penamaan kaedah ini sangat menarik, ia sama sekali berbeza dengan kaedah OutputStream dalam public abstract void write(int b) throws IOException. Parameter kaedah ini nampaknya menunjukkan bahawa ia boleh menulis integer ke aliran, tetapi fungsi kaedah tidak diteka, tetapi bergantung pada penerangan kaedah.

public abstract void write(int b) throws IOException

Pengenalan dalam API:

Menulis bait yang ditentukan kepada strim output ini Kontrak umum untuk tulis ialah satu bait ditulis kepada strim output. Bait yang akan ditulis ialah lapan bit tertib rendah bagi argumen b 24 bit tertib tinggi b diabaikan.

<. 🎜>Ia menulis bait tertentu ke dalam strim Kita tahu bahawa pembolehubah jenis int menduduki 32 bit dan bait menduduki 8 bit, jadi integer jenis int kurang daripada 256 (2^8) dan integer jenis bait ialah 8 terakhir. bit adalah sama.

Jadi kaedah ini menulis 8 bit terendah pembolehubah int dan mengabaikan baki 24 bit. Lebih berhati-hati apabila menggunakan kaedah ini!

Bait yang akan ditulis ialah lapan bit tertib rendah bagi argumen b 24 bit tertib tinggi b diabaikan.

Jadi, menulis pembolehubah jenis int sepenuhnya ke dalam strim bukanlah masalah yang sangat mudah. Mari kita kembali kepada kod di atas: Ia ditulis empat kali berturut-turut, setiap kali menulis satu bait data Dengan cara ini, pembolehubah jenis int ditukar kepada 4 bait dan ditulis ke dalam strim.

out.write((v >>> 24) & 0xFF); Kaedah ini adalah untuk menulis nombor 8 digit yang lebih rendah di atas, dan pelaksanaan khusus ini sepadan Dengan syarat mengikut subkelas.

Mari kita lihat rajah: Operasi mudah DAN: Dapat dilihat bahawa hasil operasi mengekalkan 8 bit yang lebih rendah, ini ialah

(v>>>24) & 0xFF Hasil daripada operasi.

Jadi bagaimana untuk mendapatkan nilai 8-bit yang tinggi? Ini memerlukan penggunaan operasi anjakan:

Dengan melakukan operasi anjakan, anda boleh mendapatkan setiap data 8-bit, dan kemudian melakukan operasi AND & & bitwise, Anda boleh sepenuhnya tulis integer ke dalam strim.

Demonstrasi Kod

Kod

package dragon;

/**
 * 分析这一个方法，目前水平有限，先从最简单的做起！
 * */

//		   public final void writeInt(int v) throws IOException {
//        out.write((v >>> 24) & 0xFF);
//        out.write((v >>> 16) & 0xFF);
//        out.write((v >>>  8) & 0xFF);
//        out.write((v >>>  0) & 0xFF);
//        incCount(4);
//    }


//上面这段代码是将一个32位整型，写入输出流。
//并且是将32位整型分为4个部分，每次写入8位。
//这是Java的特性。


public class DataOutputStreamAnalysis {
	public static void main(String[] args) {
		DataOutputStreamAnalysis analysis = new DataOutputStreamAnalysis();
		analysis.analysis(65535);
	}
	
	public void analysis(int number) {
		int number1, number2, number3, number4;  //后面的数字表示是一个32位整型的第几个8位。
		number1 = (number >>> 24) & 0xFF;    
		number2 = (number >>> 16) & 0xFF;    
		number3 = (number >>> 8) & 0xFF;
		number4 = (number >>> 0) & 0xFF;
		
		
		
		System.out.println(this.format(Integer.toBinaryString(number))+"  原始数据"); 
		System.out.println(this.format(Integer.toBinaryString(number1))+"  原始数据第一个8位");
		System.out.println(this.format(Integer.toBinaryString(number2))+"  原始数据第二个8位");
		System.out.println(this.format(Integer.toBinaryString(number3))+"  原始数据第三个8位");
		System.out.println(this.format(Integer.toBinaryString(number4))+"  原始数据第四个8位");
	}
	
	/**
	 * 输入一个二进制字符串，将其格式化，因为整型是
	 * 占32位的，但是转换成的二进制字符串，并没有32位*/
	public String format(String bstr) {
		int len = bstr.length();
		StringBuilder sb = new StringBuilder(35);
		for (int i = 0; i < 32-len; i++) {
			sb.append("0");
		}
		sb.append(bstr);
		sb.insert(8, " ");
		sb.insert(17, " ");
		sb.insert(26, " ");   //前面插入一个字符后，所有字符的索引都变了！
		return sb.toString();
	}
}

Keputusan

Arahan: Tiada di sini Pertimbangkan kes nombor negatif, tetapi semuanya adalah sama, kecuali ungkapan nombor negatif sedikit lebih menyusahkan. Selagi anda memahami nombor positif, nombor negatif tidak menjadi masalah.

Aplikasi operasi bit

1 Tentukan sama ada pembolehubah jenis int x ialah nombor ganjil atau genap

Lakukan operasi bit DAN pada pembolehubah , jika hasilnya ialah 0, maka pembolehubah x ialah nombor genap, jika tidak ia adalah nombor ganjil.

if (x & 1 ==0) 
	System.out.println("x是偶数");
if (x & 1 == 1) 
    System.out.println("x是奇数");

Penjelasan: Ini mudah difahami, kerana anjakan akhir nombor genap mestilah 0. (Perwakilan binari)

2. Ambil bit ke-k pembolehubah jenis int Nilai binari bit. Ungkapan:

x >> k & 1

(Adalah disyorkan untuk menambah tanda kurung untuk menjadikannya lebih jelas.)

3 kedudukan k-th bagi pembolehubah x ialah 1

Shift 1 ke kiri k bit, dan kemudian lakukan operasi logik ATAU dengan pembolehubah x, kemudian kedudukan k-th pembolehubah x ditetapkan kepada 1, dan bit lain kekal tidak berubah . Ungkapan:

x = x |. (1 << k)

4

Shift 1 ke kiri dengan k bit dan kemudian songsangkan hasilnya, dan kemudian tambahkan hasil pada pembolehubah untuk operasi logik Kemudian bit k-pembolehubah x akan dikosongkan kepada 0, dan bit lain akan kekal tidak berubah. Bit ungkapan:

x = x & ~(1 << k)

5. Kira purata dua integer

Bit ungkapan:

(x & y) + ((x ^ y) >> 1)

6 Untuk integer yang lebih besar daripada 1 x, tentukan sama ada x ialah kuasa 2

if (x & (x-1) == 0)
	System.out.println("x是2的次幂");

7. Darab nombor dengan kuasa ke-2

Ungkapan:

x = x. Contohnya: kembangkan x sebanyak 2 kali:

Operasi bitwise adalah lebih pantas daripada operasi aritmetik, kerana operasi bitwise memerlukan arahan yang lebih sedikit dan memerlukan lebih sedikit masa untuk melaksanakan Operasi itu kelihatan sangat pantas, tetapi operasi bitwise hanya boleh dilihat apabila sejumlah besar pelaksanaan dilakukan . Kelebihan operasi. Lagipun, komputer hari ini semakin pantas dan pantas.

Atas ialah kandungan terperinci Analisis kod sampel operasi bit Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!