unsigned : Java Glossary

unsigned
in Java bytes, shorts, ints and longs are all considered signed. The only unsigned type is the 16-bit char. To use the sign bit as an additional data bit you have to promote to the next bigger data type with sign extension then mask off the high order bits. i.e. To get the
byte b;
// ...
int i = b & 0xff;

To get the effect of a 16-bit unsigned use char.

To get the effect of a 32-bit unsigned:

int i;
// ...
long l = i & 0xffffffffL;
If you have an extensive amount of unsigned work to do, especially 64-bit unsigned, you might find the WBEM classes useful.

Here

// combining two unsigned shorts into an unsigned int.
short ush = 4;
short usl = 9999;
int ucombined = ( ush & 0xffff ) << 16 | ( usl & 0xffff );

For 64-bit unsigned, consider that addition and subtraction give you the same results whether you consider the operands signed or unsigned. When you multiply two unsigned 64-bit operands together you get a 128-bit result which won’t fit in a long anyway, so 64-bit unsigned multiply is not useful. To implement an unsigned 64-bit division, you could handle it 32 bits as a time, much the way you handled decimal division in grade 4. Check the signs first, if they are 0 just use ordinary division.

You could store a signed or unsigned number in byte, char, int or long.

Sometimes you get the same result in terms of bits whether you treat quantities as signed or unsigned.

Does Signed/Unsigned Matter?
Operator 8-bit 16-bit 32-bit 64-bit
= load
= store
+- addition/subtraction
* multiplication
/ division
% remainder
== != equality
< <= > >= comparison
& | ~ ! bitwise
>>> >> << shift

For large unsigned numbers, look into BigInteger and a BigDecimal.

Displaying

Java’s Integer.toString interprets the value as signed. Here is how to treat it as unsigned.

/**
 * Convert an unsigned int to a String.
 * @param i the int to convert.
 * @return the equivalent unsigned String
 */
public static void unsignedToString( int i )
   {
   return Long.toString( i & 0xffffffffL )
   }
To display unsigned longs, use Long.toHexString. Writing a base 10 unsigned converter would be a challenge.

Gotchas

Working with a mixture of constants and bytes, it is easy to trip up when int constants don’t sign extend and (byte) constants do. Consider this example:

Why?

Gosling, one of the creators of Java, said he left out unsigned types because of the way they complicated the C and C++ languages. They create too many corner cases where gotchas hide.

I see so more problem than with char. Unsigned bytes could be promoted to int, just like char.

I think the reason was the original C had signed bytes. Back then, 7-bit ASCII (American Standard Code for Information Interchange) was in vogue, which did not need the sign bit. The sign bit was free to use as a special flag.


CMP homejump to top

available on the web at:

http://mindprod.com/jgloss/unsigned.html
  

optional Replicator mirror
of mindprod.com
on local hard disk J:

J:\mindprod\jgloss\unsigned.html
logo
Please email your , letters to the editor, errors, omissions, typos, formatting errors, ambiguities, unclear wording, broken/redirected link reports, suggestions to improve this page or comments to Roedy Green : feedback email. If you want your message, your name or email kept confidential, not considered for public posting, please explicitly specify that. Unless you state otherwise, I will treat your message as a letter to the editor that I may or may not publish in the feedback section. After that, it will be too late to retract it. If you disagree with something I said, especially when sending an ad-hominem attack, a rant composed mainly of obscenities or a death threat, please quote the offending passage and cite the web page where you found it, tell me why you think it is wrong, and, if possible, provide some supporting evidence. I can’t very well fix erroneous or ambiguous text if I can’t find it.
Blog
IP:[65.110.21.43]
Your face IP:[67.202.9.192]
You are visitor number 90,550.