什么（int＆Integer.MAX_VALUE）％int在Java中做什么？

Question

In Java, I encountered the following line:

e.g.: (1 & Integer.MAX_VALUE) % 4
e.g.: (2 & Integer.MAX_VALUE) % 5

What does it do? I have tried the code, but I couldn't comprehend its purpose or functionality. What is the code trying to check?

Basically, it's (int & Integer.MAX_VALUE) % int .

Actual code (from Hadoop training class):

public int getPartition(StringPairWritable key, Text value, int numReduceTasks) {
    return (key.getLeft().hashCode() & Integer.MAX_VALUE) % numReduceTasks;
}

Answer 1

i & Integer.MAX_VALUE does the same thing as this code:

if(i < 0) {
    i = (i + Integer.MAX_VALUE + 1);
}

The % is a regular remainder operation.

It's a quick way of ensuring that an integer is positive if you don't care about it's actual value (eg if you want to turn random numbers that can be both positive and negative into only positive values).

Answer 2

The Integer.MAX_VALUE is 0x7FFFFFFF . Thus num & Integer.MAX_VALUE clears the highest bit in num . The % numReduceTasks is normal remainder after division by numReduceTasks .

This is done to convert the signed number to the non-negative number and then get the evenly distributed value from 0 to numReduceTasks-1 . Note that if you write Math.abs(key.getLeft().hashCode()) % numReduceTasks you may get negative number if hashCode() happens to be Integer.MIN_VALUE as Math.abs(Integer.MIN_VALUE) is still Integer.MIN_VALUE . So & Integer.MAX_VALUE is a safer alternative.

Answer 3

There are two parts here:

• What the function actually does from a Java perspective, and
• What purpose the function actually serves , from a Hadoop perspective.

Let's cover the Java side of it first. It's fairly straightforward bitwise math, in that it clears the sign bit and turns the value into a positive integer.

That's easy enough to demonstrate here; let's assume that our key is -128876912, which is 0xF8517E90 . The max value for an int is 0x7FFFFFFF .

If we look at the actual math operation, the sign bit is cleared (along with quite a few other bits, in this case), and we get a positive integer value.

1111 1000 0101 0001 0111 1110 1001 0000
0111 1111 1111 1111 1111 1111 1111 1111
---------------------------------------
0111 1000 0101 0001 0111 1110 1001 0000

If the value is positive, then the net result is that we get back the same value.

This is important, since a hash code can come back negative; I don't believe that you want a negative value for a reason that's important a bit later.

For the partitioning bit, this is a bit more Hadoop knowledge than I can truly claim, but after reading the docs , it informs you which partition the value falls under. That is where the modulo comes in; you're guaranteed to get a value between [0, partition) , thus specifying which reducer the particular bit of data is processed by.

From my reading of it, this is one of the default supplied partitioners, and may not be entirely suitable for your uses (you may want to group your data in a different way , for instance).

Answer 4

If the expression in the code is really

(i & Integer.MAX_VALUE) % j

it computes the residue class of i mod j . Note that i % j is the remainder of a division, a symmetric (wrt i == 0) function, whereas the residue class, which is a periodic function.