CODEWITHSUNDEEP
javaintegerunsigned
Harshdeep
Harshdeep

Reputation: 5824

Declaring an unsigned int in Java

Is there a way to declare an unsigned int in Java?

Or the question may be framed as this as well: What is the Java equivalent of unsigned?

Just to tell you the context I was looking at Java's implementation of String.hashcode(). I wanted to test the possibility of collision if the integer were 32 unsigned int.

Upvotes: 423

Views: 718225

Answers (10)

Eugene
Eugene

Reputation: 120998

Many people have said it, as of java-8, it is possible to work with unsigned types, but its not possible to declare those. I had to do a bit of drawing to understand how the implementation works for :

public static int compareUnsigned(int x, int y) {
   return compare(x + MIN_VALUE, y + MIN_VALUE);
}

So will write it in here, may be someone finds it useful.

                                                 MAX_VALUE in unsigned format 
                                                      (2 pow 64) - 1
                                                           ---
                                                          |   |
(2 pow 63) - 1                                            |   |
(MAX_VALUE)                                               |   |
   ---                                                     ---    <-- 2 pow 63
  |   |                                                   |   |
  |   |                                                   |   |
  |   |                                                   |   |
   ---  <-- 0 (zero)   +   Integer.MIN_VALUE =             ---                                
  |   |                                          MIN_VALUE in unsigned format            
  |   |                                                  (zero)
  |   |
   ---
(MIN_VALUE)
- (2 pow 63)

If we take Integer.MIN_VALUE and think about it in terms of unsigned, then it is equal to 2 pow 63. So if we add that value to any other long value, we will shift it "upwards" by that "2 pow 63".

To take it to the extreme, the lowest possible value in the signed world would be : -(2 pow 63), add Integer.MIN_VALUE and we get zero.

The highest possible value in signed world is (2 pow 63) - 1, add Integer.MIN_VALUE and we get (2 pow 64) - 1.

That range : zero to (2 pow 64) - 1 is still 64 bits, like any long, thus the comparison can happen.

Upvotes: 0

Zsolt Safrany
Zsolt Safrany

Reputation: 13620

Whether a value in an int is signed or unsigned depends on how the bits are interpreted - Java interprets bits as a signed value (it doesn't have unsigned primitives).

If you have an int that you want to interpret as an unsigned value (e.g. you read an int from a DataInputStream that you know should be interpreted as an unsigned value) then you can do the following trick.

int fourBytesIJustRead = someObject.getInt();
long unsignedValue = fourBytesIJustRead & 0xffffffffL;

Note: it is important that the hex literal is a long literal, not an int literal - hence the 'L' at the end.

Upvotes: 89

Jonathan Komar
Jonathan Komar

Reputation: 3096

There are good answers here, but I don’t see any demonstrations of bitwise operations. Like Visser (the currently accepted answer) says, Java signs integers by default (Java 8 has unsigned integers, but I have never used them). Without further ado, let‘s do it...

RFC 868 Example

What happens if you need to write an unsigned integer to IO? Practical example is when you want to output the time according to RFC 868. This requires a 32-bit, big-endian, unsigned integer that encodes the number of seconds since 12:00 A.M. January 1, 1900. How would you encode this?

Make your own unsigned 32-bit integer like this:

Declare a byte array of 4 bytes (32 bits)

Byte my32BitUnsignedInteger[] = new Byte[4] // represents the time (s)

This initializes the array, see Are byte arrays initialised to zero in Java?. Now you have to fill each byte in the array with information in the big-endian order (or little-endian if you want to wreck havoc). Assuming you have a long containing the time (long integers are 64 bits long in Java) called secondsSince1900 (Which only utilizes the first 32 bits worth, and you‘ve handled the fact that Date references 12:00 A.M. January 1, 1970), then you can use the logical AND to extract bits from it and shift those bits into positions (digits) that will not be ignored when coersed into a Byte, and in big-endian order.

my32BitUnsignedInteger[0] = (byte) ((secondsSince1900 & 0x00000000FF000000L) >> 24); // first byte of array contains highest significant bits, then shift these extracted FF bits to first two positions in preparation for coersion to Byte (which only adopts the first 8 bits)
my32BitUnsignedInteger[1] = (byte) ((secondsSince1900 & 0x0000000000FF0000L) >> 16);
my32BitUnsignedInteger[2] = (byte) ((secondsSince1900 & 0x000000000000FF00L) >> 8);
my32BitUnsignedInteger[3] = (byte) ((secondsSince1900 & 0x00000000000000FFL); // no shift needed

Our my32BitUnsignedInteger is now equivalent to an unsigned 32-bit, big-endian integer that adheres to the RCF 868 standard. Yes, the long datatype is signed, but we ignored that fact, because we assumed that the secondsSince1900 only used the lower 32 bits). Because of coersing the long into a byte, all bits higher than 2^7 (first two digits in hex) will be ignored.

Source referenced: Java Network Programming, 4th Edition.

Upvotes: 5

Simeon Visser
Simeon Visser

Reputation: 122496

Java does not have a datatype for unsigned integers.

You can define a long instead of an int if you need to store large values.

You can also use a signed integer as if it were unsigned. The benefit of two's complement representation is that most operations (such as addition, subtraction, multiplication, and left shift) are identical on a binary level for signed and unsigned integers. A few operations (division, right shift, comparison, and casting), however, are different. As of Java SE 8, new methods in the Integer class allow you to fully use the int data type to perform unsigned arithmetic:

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. Static methods like compareUnsigned, divideUnsigned etc have been added to the Integer class to support the arithmetic operations for unsigned integers.

Note that int variables are still signed when declared but unsigned arithmetic is now possible by using those methods in the Integer class.

Upvotes: 413

Carsten Semark
Carsten Semark

Reputation: 21

It seems that you can handle the signing problem by doing a "logical AND" on the values before you use them:

Example (Value of byte[] header[0] is 0x86 ):

System.out.println("Integer "+(int)header[0]+" = "+((int)header[0]&0xff));

Result:

Integer -122 = 134

Upvotes: 2

Romulo
Romulo

Reputation: 21

Just made this piece of code, wich converts "this.altura" from negative to positive number. Hope this helps someone in need

       if(this.altura < 0){    

                        String aux = Integer.toString(this.altura);
                        char aux2[] = aux.toCharArray();
                        aux = "";
                        for(int con = 1; con < aux2.length; con++){
                            aux += aux2[con];
                        }
                        this.altura = Integer.parseInt(aux);
                        System.out.println("New Value: " + this.altura);
                    }

Upvotes: 1

Ms. Molly Stewart-Gallus
Ms. Molly Stewart-Gallus

Reputation: 1168

Use char for 16 bit unsigned integers.

Upvotes: 5

Andrejs
Andrejs

Reputation: 27727

For unsigned numbers you can use these classes from Guava library:

They support various operations:

  • plus
  • minus
  • times
  • mod
  • dividedBy

The thing that seems missing at the moment are byte shift operators. If you need those you can use BigInteger from Java.

Upvotes: 10

Matthias Ronge
Matthias Ronge

Reputation: 10122

Perhaps this is what you meant?

long getUnsigned(int signed) {
    return signed >= 0 ? signed : 2 * (long) Integer.MAX_VALUE + 2 + signed;
}
  • getUnsigned(0) → 0
  • getUnsigned(1) → 1
  • getUnsigned(Integer.MAX_VALUE) → 2147483647
  • getUnsigned(Integer.MIN_VALUE) → 2147483648
  • getUnsigned(Integer.MIN_VALUE + 1) → 2147483649

Upvotes: 5

Lukas Eder
Lukas Eder

Reputation: 221185

We needed unsigned numbers to model MySQL's unsigned TINYINT, SMALLINT, INT, BIGINT in jOOQ, which is why we have created jOOU, a minimalistic library offering wrapper types for unsigned integer numbers in Java. Example:

import static org.joou.Unsigned.*;

// and then...
UByte    b = ubyte(1);
UShort   s = ushort(1);
UInteger i = uint(1);
ULong    l = ulong(1);

All of these types extend java.lang.Number and can be converted into higher-order primitive types and BigInteger. Hope this helps.

(Disclaimer: I work for the company behind these libraries)

Upvotes: 28

Related Questions