Detailed explanation of Java binary operations (power node arrangement)

This article introduces Java binary operation skills to everyone, including shifting, bit operationsoperators and other related knowledge points. It is very good. Friends who are interested can refer to it.

Shift

Most operations in bit operations are left shift and right shift. In Java, this corresponds to the two operators >. Examples are as follows:

/* 00000001 << 1 = 00000010 */
1 << 1 == 2 
/* 00000001 << 3 = 00001000 */
1 << 3 == 8
/* 11111111 11111111 11111111 11110000 >> 4 = 11111111 11111111 11111111 11111111 */
0xFFFFFFF0 >> 4 == 0xFFFFFFFF 
/* 00001111 11111111 11111111 11111111 >> 4 = 00000000 11111111 11111111 11111111 */
0x0FFFFFFF >> 4 == 0x00FFFFFF

Note: Shifting to the right is a signed operator. Like many languages, Java uses the highest bit to represent the positive and negative values. The highest bit of a negative number is always 1. A binary number starting with 1 will also start with 1 after shifting, and a binary tree starting with 0 will still start with 0 after shifting. So be careful: Java can perform bitwise operations on integers.
You can use the third operator called "unsigned right shift"

operator

: >>> to implement a shift filled with "0" bit, this shift ignores the sign bit and always fills it with "0".

/* 10000000 00000000 00000000 00000000 >>> 1 = 01000000 00000000 00000000 00000000 */
0x80000000 >>> 1 == 0x40000000
/* 10000000 00000000 00000000 00000000 >> 1 = 11000000 00000000 00000000 00000000 */
0x80000000 >> 1 == 0xC0000000

One of the biggest uses is to quickly find powers of 2. Shifting 1 to the left by 1 bit is 2, shifting 2 bits is 4, shifting 3 bits is 8... Similarly, shifting 1 bit to the right is equivalent to dividing the number by 2.

Another use is to create masks. Bit masks can be used to mask or modify certain specified bits in a binary number, which will be explained in detail in the next section. If we want to create a mask of

00001000, the code is very simple:

int bitmask = 1 << 3;

You can use bitwise operators to create more complex masks. Bitwise operations will also be explained in the next section. operator.

Bitwise operatorsThe following are four common bitwise operators in Java:

 ~ – Bitwise negation
 & – Bitwise AND
 ~ – Bitwise XOR
 | – Bitwise OR
 The simple application is as follows (for simplicity, only binary is shown)

• 1010 & 0101 == 0000
  1100 & 0110 == 0100
  1010 | 0101 == 1111
  1100 | 0110 == 1110
  ~1111 == 0000
  ~0011 == 1100
  1010 ^ 0101 == 1111
  1100 ^ 0110 == 1010

For example, you can "set" a specified bit on a binary number to 1 through the "OR" operation without affecting other bits.

10000001 | 00100000 = 10100001 /* 第五位设为1 */
10000001 | 1 << 5 = 10100001 /* 同样作用 */
00000000 | 1 << 2 | 1 << 5 = 00100100

If you want to selectively set a certain bit to 0, you can AND the number with a number that has all 1's but a certain bit is 0.

01010101 & ~(1<<2) == 01010101 & 11111011 == 01010001

About bit orderAssume the highest bit is on the left:

10010110
^   ^
|   |------- 第 0 位
|
|-------------- 第 7 位

Note that the value of bit 0 is 2^0, the first bit is 2^1,..., the value of the 7th bit is 2^7.

Using ParseInt#A convenient way to manipulate binary numbers in your code is to use the Integer.parseInt() method. Integer.parseInt(“101″,2) represents converting the binary number 101 into a decimal number (5). This means that with this method you can even use binary numbers in a

for loop

:

/* 从5到15的循环 */
for (int b = Integer.parseInt("0101",2); b <= Integer.parseInt("1111",2); b++) {
  /* 做些什么 */
}

bit read and writeSuggestion: Implement a class that converts binary bits (bits) into streams and reads and writes them. Try not to use Java's input and output streams, because Java's streams can only operate on bytes. You will find the functions "give me the next N bits" and "move the pointer forward M bits" very useful. For example, you can read enough data to determine the length of the longest Huffman code. When you get the actual length of the Huffman code you just read, you can move the pointer forward by the corresponding length. Such a class can divide the ugly side of bit operations into a familiar block of code.

Similarly, if you are pursuing speed, you will unexpectedly find that table lookup is so powerful. If you have a Huffman code starting with 0, and the other codes are all length 3 and starting with 1, this means you need a

table

that can hold 8(2^3) items, Your table may look like this:

char code[8];
int codelen[8];
code[0] = 'a'; codelen[0] = 1;
code[1] = 'a'; codelen[1] = 1;
code[2] = 'a'; codelen[2] = 1;
code[3] = 'a'; codelen[3] = 1;
code[4] = 'b'; codelen[4] = 3;
code[5] = 'c'; codelen[5] = 3;
code[6] = 'd'; codelen[6] = 3;
code[7] = 'e'; codelen[7] = 3;

Through two searches, you can locate the character you are looking for, and you can also know how far ahead the next character is. This is much more cost-effective than looping over and over again to find all characters, and saves more memory.

The above is the detailed content of Detailed explanation of Java binary operations (power node arrangement). For more information, please follow other related articles on the PHP Chinese website!