本文翻译自：Why doesn't Java support unsigned ints?

Why doesn't Java include support for unsigned integers? 为什么Java不包含对无符号整数的支持？

It seems to me to be an odd omission, given that they allow one to write code that is less likely to produce overflows on unexpectedly large input. 在我看来，这是一个奇怪的遗漏，因为它们允许人们编写不太可能在意外的大输入上产生溢出的代码。

Furthermore, using unsigned integers can be a form of self-documentation, since they indicate that the value which the unsigned int was intended to hold is never supposed to be negative. 此外，使用无符号整数可以是一种自我文档形式，因为它们表明unsigned int意图保留的值绝不应该是负数。

Lastly, in some cases, unsigned integers can be more efficient for certain operations, such as division. 最后，在某些情况下，无符号整数对于某些操作（例如除法）可能更有效。

What's the downside to including these? 包含这些内容的不利之处是什么？

---

#1楼

参考：https://stackoom.com/question/1nx4/为什么Java不支持无符号整数

---

#2楼

With JDK8 it does have some support for them. 使用JDK8，它确实有一些支持。

We may yet see full support of unsigned types in Java despite Gosling's concerns. 尽管有Gosling的担忧，我们仍然可以看到Java中对无符号类型的完全支持。

---

#3楼

Java does have unsigned types, or at least one: char is an unsigned short. Java确实有无符号类型，或者至少有一个：char是unsigned short。 So whatever excuse Gosling throws up it's really just his ignorance why there are no other unsigned types. 因此无论戈斯林抛出什么借口，实际上只是他的无知为什么没有其他无符号类型。

Also Short types: shorts are used all the time for multimedia. 短型：短裤一直用于多媒体。 The reason is you can fit 2 samples in a single 32-bit unsigned long and vectorize many operations. 原因是您可以在一个32位无符号长度中拟合2个样本并对多个操作进行向量化。 Same thing with 8-bit data and unsigned byte. 与8位数据和无符号字节相同。 You can fit 4 or 8 samples in a register for vectorizing. 您可以在寄存器中放入4或8个样本进行矢量化。

---

#4楼

I know this post is too old; 我知道这篇文章太旧了; however for your interest, in Java 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 ³² −1. 但是为了您的兴趣，在Java 8及更高版本中，您可以使用int数据类型来表示无符号的32位整数，其最小值为0，最大值为2 ³² -1。 Use the Integer class to use int data type as an unsigned integer and static methods like compareUnsigned() , divideUnsigned() etc. have been added to the Integer class to support the arithmetic operations for unsigned integers. 使用Integer类将int数据类型用作无符号整数，并将诸如compareUnsigned() ， divideUnsigned()等静态方法添加到Integer类中，以支持无符号整数的算术运算。

---

#5楼

Because unsigned type is pure evil. 因为unsigned类型是纯粹的邪恶。

The fact that in C unsigned - int produces unsigned is even more evil. 在C unsigned - int生成unsigned的事实更加邪恶。

Here is a snapshot of the problem that burned me more than once: 以下是不止一次烧毁我的问题的快照：

// We have odd positive number of rays, 
// consecutive ones at angle delta from each other.
assert( rays.size() > 0 && rays.size() % 2 == 1 );// Get a set of ray at delta angle between them.
for( size_t n = 0; n < rays.size(); ++n )
{// Compute the angle between nth ray and the middle one.// The index of the middle one is (rays.size() - 1) / 2,// the rays are evenly spaced at angle delta, therefore// the magnitude of the angle between nth ray and the // middle one is: double angle = delta * fabs( n - (rays.size() - 1) / 2 ); // Do something else ...
}

Have you noticed the bug yet? 你注意到了这个bug吗？ I confess I only saw it after stepping in with the debugger. 我承认我只是在踩到调试器后才看到它。

Because n is of unsigned type size_t the entire expression n - (rays.size() - 1) / 2 evaluates as unsigned . 因为n是无符号类型size_t所以整个表达式n - (rays.size() - 1) / 2计算结果为unsigned 。 That expression is intended to be a signed position of the n th ray from the middle one: the 1st ray from the middle one on the left side would have position -1, the 1st one on the right would have position +1, etc. After taking abs value and multiplying by the delta angle I would get the angle between n th ray and the middle one. 该表达式旨在成为来自中间的第n射线的有符号位置：左侧中间的第1条射线的位置为-1，右侧的第1条射线的位置为+1，等等。在获取abs值并乘以delta角后，我将获得第n光线与中间光线之间的角度。

Unfortunately for me the above expression contained the evil unsigned and instead of evaluating to, say, -1, it evaluated to 2^32-1. 不幸的是，上面的表达式包含了邪恶的无符号，而不是评估，比如-1，它被评估为2 ^ 32-1。 The subsequent conversion to double sealed the bug. 随后转换为double密封的bug。

After a bug or two caused by misuse of unsigned arithmetic one has to start wondering whether the extra bit one gets is worth the extra trouble. 在因滥用unsigned算术而导致的一两个错误之后，必须开始想知道额外的位是否值得额外麻烦。 I am trying, as much as feasible, to avoid any use of unsigned types in arithmetic, although still use it for non-arithmetic operations such as binary masks. 我尽可能地尝试避免在算术中使用unsigned类型，尽管仍然将它用于非算术运算，例如二进制掩码。

---

#6楼

I once took a C++ course with someone on the C++ standards committee who implied that Java made the right decision to avoid having unsigned integers because (1) most programs that use unsigned integers can do just as well with signed integers and this is more natural in terms of how people think, and (2) using unsigned integers results in lots easy to create but difficult to debug issues such as integer arithmetic overflow and losing significant bits when converting between signed and unsigned types. 我曾经和C ++标准委员会的某个人一起参加过C ++课程，他暗示Java做出了正确的决定，避免使用无符号整数，因为（1）大多数使用无符号整数的程序都可以用有符号整数做得更好，这在人们如何思考的条件，以及（2）使用无符号整数导致很多容易创建，但很难调整诸如整数算术溢出和在有符号和无符号类型之间转换时丢失有效位的问题。 If you mistakenly subtract 1 from 0 using signed integers it often more quickly causes your program to crash and makes it easier to find the bug than if it wraps around to 2^32 - 1, and compilers and static analysis tools and runtime checks have to assume you know what you're doing since you chose to use unsigned arithmetic. 如果你错误地使用有符号整数从0中减去1，它通常会更快地导致程序崩溃，并且比查找错误更容易找到错误，并且编译器和静态分析工具以及运行时检查必须假设你知道自从你选择使用无符号算术后你正在做什么。 Also, negative numbers like -1 can often represent something useful, like a field being ignored/defaulted/unset while if you were using unsigned you'd have to reserve a special value like 2^32 - 1 or something similar. 此外，像-1这样的负数通常代表一些有用的东西，比如一个字段被忽略/默认/未设置，而如果你使用无符号，你必须保留一个特殊值，如2 ^ 32 - 1或类似的东西。

Long ago, when memory was limited and processors did not automatically operate on 64 bits at once, every bit counted a lot more, so having signed vs unsigned bytes or shorts actually mattered a lot more often and was obviously the right design decision. 很久以前，当内存有限且处理器不能同时自动运行64位时，每一位都计算得更多，因此签名与无符号字节或短路实际上更为重要，显然是正确的设计决策。 Today just using a signed int is more than sufficient in almost all regular programming cases, and if your program really needs to use values bigger than 2^31 - 1, you often just want a long anyway. 今天只使用带符号的int在几乎所有常规编程案例中都是绰绰有余的，如果你的程序确实需要使用大于2 ^ 31 - 1的值，那么你通常只需要很长的时间。 Once you're into the territory of using longs, it's even harder to come up with a reason why you really can't get by with 2^63 - 1 positive integers. 一旦你进入使用多头的领域，你就更难想出为什么你真的无法通过2 ^ 63-1正整数。 Whenever we go to 128 bit processors it'll be even less of an issue. 每当我们使用128位处理器时，它都会成为一个问题。