变量赋值的奇怪方式

Question

I have been working in C++ and Java and in both the languages I have often times come across a strange way of variable assignment, using bitwise operators. Instead of what could have been a simple assignment using the assignment operator it is complicated using bit operators like left shift. For example, in Java's ServerSocketChannel class we see the following assignments:

public static final int OP_READ = 1 << 0;
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;

I am trying to understand here what have we gained by using the << operator. We could have made simple assignments to assign the variables as 1,4,8,16 respectively as below:

public static final int OP_READ = 1;
public static final int OP_WRITE = 4; 
public static final int OP_CONNECT = 8; 
public static final int OP_ACCEPT = 16;  

What is the value add in using << operator here ?

Answer 1

This is for clarity/readability (when it matters).

At the byte code level, OP_ACCEPT = 16 or OP_ACCEPT = 1 << 4 are the same thing (via javap -constants <YourClass> )

It's just easier to see exactly how many times this has been shifted. Usually this matters when you do different operations that are bound to power of two operations.

On example would be HashMap (or I assume HashXXX structures), where, at least in java, buckets are chosen on the next power of two, always. This simplifies processing or may be, rationalizing, thus number of buckets is declared as :

 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

At the same time, where, power of two, does not matter, variables are not declared like this:

static final int TREEIFY_THRESHOLD = 8;
static final int MIN_TREEIFY_CAPACITY = 64

Think of how a bucket is chosen for example in case of HashMap via (n - 1) & hash , where n is the number of buckets (always a power of two). A default capacity of 16 (or better 1 << 4 ), means that the last 4 bits are zero, doing a minus 1 will make them all ones. So, in a way , 1 << 4 for HashMap would mean that the last 4 bits only are taken into consideration (until next re-hash). Now think 1 << 28 for example... without shift this would be pretty long to reason about.

A least for me, for such cases, doing for example an or or and would make faster sense on such variables.

Answer 2

They're the most efficient way of representing something whose state is defined by several "yes or no" properties. ACLs are a good example; if you have let's say 4 discrete permissions (read, write, execute, change policy), it's better to store this in 1 byte rather than waste 4 .

When you left shift 1 bit, the number get multiplied by 2.

for example take binary number of 5 = 0101 after left shifting 1 time it will become 1010, that is equivalent to 10.