Is there a Java library for unsigned number type wrappers? [closed]

Question

Obviously, Java doesn't support unsigned number types natively, and that's not going to change soon (comments starting in 2002). However, when working with databases, such as MySQL, they may come in handy every now and then. There are a lot of questions dealing with how to simulate unsigned numbers. For example:

• unsigned short in java
• Java: Unsigned numbers
• Understanding Java unsigned numbers

All of them superficially describe how it could be done. But is there any library actually going all the way and implementing suitable wrappers for UByte, UShort, UInteger, ULong? Preferably, those wrappers would extend java.lang.Number and provide an arithmetic API similar to that of java.math.BigInteger.

As can be seen in this document, there's a lot to think of, and a lot that can go wrong (e.g. how to bitwise shift, how to multiply, etc), so I don't want to do it myself. Also, I don't want to just use the next higher type (e.g. Short instead of Byte, etc.). I want the notion of an 8-bit, 16-bit, 32-bit, 64-bit number preserved, for best interaction with databases, for instance.

UPDATE:

Before you answer! Consider that I know all the workarounds, but I'd really really like to have exactly those 4 types with exactly the above properties. And maybe someone has already done that, so that's why I ask. No need to remind me of the workarounds.

Answer 1

When I needed this functionality inside of jOOQ, I haven't found anything like it, so I rolled my own Open Source library that I call jOOU (U for Unsigned):

http://github.com/jOOQ/jOOU

I understand that some may think this is overkill, but I'd really like to have precisely those wrappers wrapping what other languages call ubyte, ushort, uint, ulong. Hopefully with Valhalla, those wrappers can be turned into value types.

Of course, contributions to the arithmetics / bitwise operation implementations are very welcome!

Answer 2

There are some reasons why nobody created these wrappers in the way you want.

• Performance
• Garbage collector overhead
• no autoboxing / unboxing
• bad / useless interface.
• easier ways to deal with it exists

The first four points are demonstrated by a small C example:

unsigned int x=42, y, m=5, t=18; y = x * m + t; 

This would be translated into:

UInteger m = new UInteger(5); UInteger t = new UInteger(18); UInteger x = new UInteger(42);  UInteger y = x.multiplyBy(m); y = y.add(t); 

Several wrapper objects must be created, multiplyBy and add will generate some more. This will put quite some burden on the garbage collector if many calculations are done this way. The wrapping and unwrapping will also eat up your CPUs for nothing.

That even simple arithmetic is a PITA to write or read is also obvious.

For the same reasons NOBODY does arithmetic using the signed wrapper types.

All this is unnecessary if you do the calculations using the next-bigger signed type and cut off the upper part like this:

long x=42, y, m=5, t=18 y = (x*m + t) & 0xFFFFFFFF; 

Transfer between Java and a database can also be done using the next biggest signed type. And since JDBC will not create these unsigned wrapper types you would have to do exactly that by yourself only to transform the data into the unsigned wrappers thereafter.

I have done some CPU intensive data processing for myself and handled binary protocols. On these occasions I wished I had unsigned datatypes also. But emulating them in Java with wrapper types would have been more problematic than dealing with the problem directly on each single occasion.