Java中的unsigned int（primitive）和Integer（Object）用法

Question

I'm following the Java tutorial on Primitive Data Types . Early on, it states that

In Java SE 8 and later, you can use the int data type to represent an unsigned 32-bit integer, which has a minimum value of 0 and a maximum value of 2^32-1. Use the Integer class to use int data type as an unsigned integer.

What I'm understanding from this quote is that I can now store up to 2^32-1 as an int as long as I use the Integer wrapper object rather than the int primitive data type. But when I tried this out, my compiler is complaining that the value I'm using is too large, 2^31. I've tried this using both the primitive data type and Object.

Integer integerObjectLarge = 2147483648; //2^31
int integerPrimitiveLarge = 2147483648; //2^31

How exactly do I use an int/Integer to store unsigned value, such as 2^31?

Answer 1

I don't think Java has added a true unsigned 32-bit int type. The only thing that's changed is that the Integer class now contains some methods that will treat a 32-bit integer(s) as an unsigned 32-bit integer. See compareUnsigned , divideUnsigned , parseUnsignedInt , and several others in the javadoc for Integer . Long has some new methods too.

But basically, if you store the bit pattern (for example) 10001000_11110000_10010110_11000010 in an int , there's nothing in the int that says "This is an unsigned integer" or "This is a signed integer". It depends on what methods you use to work with it.

Answer 2

But when I tried this out, my compiler is complaining that the value I'm using is too large, 2^31.

You have an error because the literal 2147483648 is syntactically invalid.

---

How exactly do I use an int/Integer to store unsigned value, such as 2^31?

You can still perform unsigned arithmetic using the new methods of the Integer class, just don't use invalid literals:

int n = 2147483647 + 1;  // 2^31

System.out.println(Integer.toUnsignedString(n));  // treat int as unsigned
System.out.println(Integer.toString(n));          // treat int as signed

2147483648
-2147483648

---

What I'm understanding from this quote is that I can now store up to 2^32-1 as an int as long as I use the Integer wrapper object rather than the int primitive data type.

You can store the unsigned int using the primitive type int , but using the value as an unsigned type requires you to use the utility methods of Integer , as can be seen above.

Answer 3

You've always been able to store "unsigned" integer literals by using hex:

 int x = 0xffffffff;
 // or any value >= 0x80000000;

This is because, for all practical purposes, the compiler thinks these are "signed".

You still can't assign a decimal value > 2^31 - 1 because it would create all sorts of backwards compatibility issues if this were suddenly allowed.