Unsigned int (primitive) and Integer (Object) usage in Java

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.