Why is there no unsigned type is java?

Question

Just wondering? Why no unsigned int or unsigned long? I have often used these in the past but java requires me to do some clever stuff to get over the limitation.

Answer 1

i found this on the net somewhere. it doesn't mention anything about java but it does seem to fit the typical "don't include anything that can be confusing or misunderstood" mold that java utilizes:
"One problem is that unsigned types tend to decrease your
ability to detect common programming errors. Another is that
they often increase the likelihood that clients of your classes
will use the classes incorrectly.
Consider first error detection. Suppose a programmer defines
an Array object as follows:
int f(); // f and g are functions that return
int g(); // ints; what they do is unimportant
Array<double> a(f()-g()); // array size is f()-g()
There�s nothing wrong with this definition for a, except for the
possibility that the programmer writing it made an error. Instead
of the size of the array being f()-g(), perhaps it
should have been g()-f(). Or maybe it should have been
f()+g(). Or possibly it should have been f()-g()+1; off-byone
errors are certainly common enough. Heck, it�s even possible
that f()-g() is correct, but f() or g() is returning a
bad value. Any of these scenarios could lead to the Array
constructor being passed a size that was less than zero. As
the author of the Array class, there�s no way you can keep
clients from making mistakes such as these, but you can do
the next best thing: you can detect such errors and act on
them.
Well, actually, maybe you can�t. You can�t if you declared Array�s
constructor to take an unsigned value, because if a
negative number is passed to a function as an unsigned, the
number seen by the function isn�t negative at all. Instead, it�s
a very large positive number. As a result, you�d have no way
within the Array constructor of distinguishing between a
large, but valid, positive size value and a large, but invalid,
positive size value arising from passing in a negative number.
Hence, you�d be unable to detect programming errors that result
in negative array sizes being requested. Because such errors
are not uncommon, this makes your class easy to use
incorrectly."