为什么Java不支持无符号整数？

Question

为什么 Java 不支持无符号整数？

在我看来，这是一个奇怪的遗漏，因为它们允许人们编写不太可能在意外大的输入上产生溢出的代码。

此外，使用无符号整数可以是自文档的一种形式，因为它们表明无符号 int 想要保存的值永远不应该是负数。

最后，在某些情况下，无符号整数对于某些运算（例如除法）可能更有效。

包括这些有什么缺点？

Answer 1

这是来自对 Gosling 和其他人的采访，关于简单性：

Gosling：对于我来说，作为一名语言设计师，我现在并不真正认为自己是这样，“简单”真正的最终含义是我是否可以期望 J. Random Developer 将规范牢记在心。 例如，这个定义表明，Java 就不是——事实上，许多这些语言最终都会出现很多极端情况，而没有人真正理解这些情况。 对任何 C 开发人员进行有关无符号的测验，很快您就会发现几乎没有 C 开发人员真正了解无符号的情况以及无符号算术是什么。 诸如此类的事情使 C 变得复杂。 我认为 Java 的语言部分非常简单。 您必须查找的库。

Answer 2

从字里行间，我认为逻辑是这样的：

• 一般来说，Java 设计者希望简化
• 日常使用的数据类型的全部内容，他们认为最常见的需求是
• 用于实现某些算法的有符号数据类型，无符号 数据类型有时需要算术，但是将实现此类算法的程序员也将具备“解决”使用带符号数据类型进行无符号算术的知识。

大多数情况下，我认为这是一个合理的决定。 可能，我会：

• 使字节无符号，或者至少为这种数据类型提供有符号/无符号的替代方案，可能具有不同的名称（使其有符号有利于一致性，但是什么时候需要有符号字节？ ）
• 废除了“short”（你上次使用 16 位有符号算术是什么时候？）

不过，尽管有一点拼凑，对高达 32 位的无符号值进行操作并不算太糟糕，而且大多数人不需要无符号64 位除法或比较。

Answer 3

这是一个较老的问题，帕特确实简短地提到了 char，我只是想我应该为其他将来会看到这个问题的人扩展这个问题。 让我们仔细看看 Java 基本类型：

byte - 8 位有符号整数

short - 16 位有符号整数

int - 32-位有符号整数

long - 64 位有符号整数

char - 16 位字符（无符号整数）

尽管 char 不支持 unsigned算术，它本质上可以被视为一个无符号整数。 您必须将算术运算显式转换回 char，但它确实为您提供了一种指定无符号 数字的方法。

char a = 0;
char b = 6;
a += 1;
a = (char) (a * b);
a = (char) (a + b);
a = (char) (a - 16);
b = (char) (b % 3);
b = (char) (b / a);
//a = -1; // Generates complier error, must be cast to char
System.out.println(a); // Prints ? 
System.out.println((int) a); // Prints 65532
System.out.println((short) a); // Prints -4
short c = -4;
System.out.println((int) c); // Prints -4, notice the difference with char
a *= 2;
a -= 6;
a /= 3;
a %= 7;
a++;
a--;

是的，没有对无符号整数的直接支持（显然，如果有直接支持，我不必将大部分操作转换回 char）。 然而，确实存在无符号原始数据类型。 我也希望看到一个无符号字节，但我想将内存成本加倍并使用 char 是一个可行的选择。

---

编辑

JDK8 有新的 API Long< /code>和 Integer< /code>在将 long 和 int 值视为无符号值时提供辅助方法。

• compareUnsigned
• divideUnsigned
• parseUnsignedInt
• parseUnsignedLong
• remainderUnsigned
• toUnsignedLong
• toUnsignedString

此外，Guava 提供了许多辅助方法来执行类似的操作整数类型有助于缩小由于缺乏对无符号整数的本机支持而留下的空白。

Answer 4

Java 确实有无符号类型，或者至少有一种： char 是无符号短整型。 因此，无论高斯林提出什么借口，这实际上只是他对为什么没有其他未签名类型的无知。

还有短片类型：短片一直用于多媒体。 原因是您可以将 2 个样本放入一个 32 位无符号长整型中，并对许多操作进行向量化。 8 位数据和无符号字节也是如此。 您可以将 4 或 8 个样本放入寄存器中以进行矢量化。

Answer 5

一旦有符号和无符号整数混合在表达式中，事情就会开始变得混乱，您可能会丢失信息。 将 Java 限制为有符号整数只会真正解决问题。 我很高兴我不必担心整个签名/未签名的业务，尽管有时我确实会错过一个字节中的第 8 位。

Answer 6

http://skleaf.blogspot.com/2006/09 /java-tutorials-why-no-unsigned.html

这家伙说是因为 C 标准定义了涉及无符号和有符号整数的操作被视为无符号。 这可能会导致负有符号整数滚动到一个大的无符号整数，从而可能导致错误。

Answer 7

我认为 Java 本身就很好，添加 unsigned 会使它变得复杂而没有太多好处。
即使使用简化的整数模型，大多数 Java 程序员也不知道基本数字类型的行为方式 - 只需阅读这本书 Java Puzzlers 看看您可能存在哪些误解。

至于实用建议：

• 如果您的值有点任意大小并且不适合 int，请使用 long。
  如果它们不适合 long，请使用 BigInteger。

• 仅当您需要节省空间时才对数组使用较小的类型。

• 如果您正好需要 64/32/16/8 位，请使用 long/int/short/byte 并且不再担心符号位，除了除法、比较、右移和转换。

另请参阅这个关于“移植随机数”的答案从 C 到 Java 的生成器”。

Answer 8

我知道这篇文章太旧了； 不过，出于您的兴趣，在 Java 8 及更高版本中，您可以使用 int 数据类型来表示无符号 32 位整数，其最小值为 0，最大值为 2 ^{32-1。 使用 Integer 类将 int 数据类型用作无符号整数以及静态方法，例如 compareUnsigned()、divideUnsigned()Integer 类中添加了 code> 等，以支持无符号整数的算术运算。}

Answer 9

我听说过这样的故事：它们将包含在原始 Java 版本附近。 Oak 是 Java 的前身，在一些规范文档中提到了无符号值。 不幸的是，这些从未进入 Java 语言。 据任何人所知，他们只是没有得到实施，可能是由于时间限制。

Answer 10

对于JDK8，它确实对它们有一些支持。

尽管 Gosling 担心，但我们可能仍会看到 Java 中对无符号类型的完全支持。

Answer 11

我曾经和 C++ 标准委员会的某个人一起上过 C++ 课程，他暗示 Java 做出了避免使用无符号整数的正确决定，因为 (1) 大多数使用无符号整数的程序都可以与有符号整数一起使用，而且这在就人们的思维方式而言，（2）使用无符号整数会导致许多易于创建但难以调试的问题，例如整数算术溢出以及在有符号和无符号类型之间转换时丢失重要位。 如果你错误地使用有符号整数从 0 中减去 1，它通常会更快地导致你的程序崩溃，并且比它回绕到 2^32 - 1 更容易找到错误，并且编译器、静态分析工具和运行时检查必须假设您知道自己在做什么，因为您选择使用无符号算术。 此外，像 -1 这样的负数通常可以表示有用的东西，例如被忽略/默认/未设置的字段，而如果您使用无符号，则必须保留一个特殊值，例如 2^32 - 1 或类似的值。

很久以前，当内存有限并且处理器不能同时自动在 64 位上运行时，每个位都更重要，因此有符号字节或无符号字节或短路实际上更重要，并且显然是正确的设计决策。 如今，在几乎所有常规编程情况下，仅使用有符号 int 就足够了，如果您的程序确实需要使用大于 2^31 - 1 的值，那么您通常只需要 long 值。 一旦您开始使用长整型，就更难找出为什么不能使用 2^63 - 1 正整数的原因了。 每当我们使用 128 位处理器时，这个问题就更小了。

Answer 12

Java 出于务实的原因放弃了“C”规范中的一些精华，但随着开发人员的需求（关闭等），它们正在慢慢回归。

我提到第一个是因为它与本次讨论相关； 指针值遵守无符号整数算术。 并且，与此线程主题相关的是，在 Java 的有符号世界中维护无符号语义的困难。

我猜想如果有人让 Dennis Ritchie 的另一个自我为 Gosling 的设计团队提供建议，他们会建议给 Signed 一个“无穷大零”，这样所有地址偏移请求都会首先添加其代数环大小以避免负值。

这样，向数组抛出的任何偏移量都不会生成 SEGFAULT。 例如，在一个封装类中，我将其称为需要无符号行为的双精度型 RingArray - 在“自旋转循环”上下文中：

// ...
// Housekeeping state variable
long entrycount;     // A sequence number
int cycle;           // Number of loops cycled
int size;            // Active size of the array because size<modulus during cycle 0
int modulus;         // Maximal size of the array

// Ring state variables
private int head;   // The 'head' of the Ring
private int tail;   // The ring iterator 'cursor'
// tail may get the current cursor position
// and head gets the old tail value
// there are other semantic variations possible

// The Array state variable
double [] darray;    // The array of doubles

// somewhere in constructor
public RingArray(int modulus) {
    super();
    this.modulus = modulus;
    tail =  head =  cycle = 0;
    darray = new double[modulus];
// ...
}
// ...
double getElementAt(int offset){
    return darray[(tail+modulus+offset%modulus)%modulus];
}
//  remember, the above is treating steady-state where size==modulus
// ...

上述 RingArray 永远不会从负索引中“获取”，即使恶意请求者试图这样做。 请记住，还有许多要求先前（负）索引值的合法请求。

注意：外部 %modulus 取消引用合法请求，而内部 %modulus 掩盖了比 -modulus 更负面的负数中的公然恶意。 如果这出现在 Java +..+9 || 中 8+..+ 规范，那么问题将真正成为“无法“自我旋转”故障的程序员”。

我相信所谓的Java unsigned int“缺陷”可以用上面的一句话来弥补。

PS：只是为了给上面的 RingArray 内务处理提供上下文，这里有一个候选“set”操作来匹配上面的“get”元素操作：

void addElement(long entrycount,double value){ // to be called only by the keeper of entrycount
    this.entrycount= entrycount;
    cycle = (int)entrycount/modulus;
    if(cycle==0){                       // start-up is when the ring is being populated the first time around
        size = (int)entrycount;         // during start-up, size is less than modulus so use modulo size arithmetic
        tail = (int)entrycount%size;    //  during start-up
    }
    else {
        size = modulus;
        head = tail;
        tail = (int)entrycount%modulus; //  after start-up
    }
    darray[head] = value;               //  always overwrite old tail
}

Answer 13

因为 unsigned 类型是纯粹的邪恶。

事实上，在 C 中 unsigned - int 会产生 unsigned ，这一事实更加邪恶。

这是不止一次让我烦恼的问题的快照：

// 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 ...
}

你注意到这个错误了吗？ 我承认我只是在使用调试器后才看到它。

由于 n 为无符号类型 size_t，因此整个表达式 n - (rays.size() - 1) / 2 的计算结果为 unsigned。 该表达式旨在成为中间第 n 条射线的有符号位置：左侧中间的第 1 条射线的位置为 -1，右边第一个的位置为 +1，等等。在获取绝对值并乘以 delta 角度后，我将得到第 n 条射线与中间射线之间的角度一。

不幸的是，对我来说，上面的表达式包含邪恶的无符号，并且不是计算为 -1，而是计算为 2^32-1。 随后转换为 double 解决了该错误。

在由于滥用无符号算术而导致一两个错误之后，人们必须开始怀疑是否值得为此付出额外的努力。 我正在尽可能避免在算术中使用无符号类型，尽管仍然将其用于非算术运算（例如二进制掩码）。

Answer 14

你的问题是“为什么Java不支持无符号整数”？

我对你问题的回答是，Java 想要所有的原始类型：byte、char、short、int 和 long 应被视为 byte、word、dword 和 qword分别，就像在汇编中一样，Java 运算符是对除 char 之外的所有基本类型的有符号操作，但仅对 char 进行操作仅无符号 16 位。

因此，静态方法应该是 32 位和 64 位的无符号操作也。

您需要最终类，可以调用其静态方法来执行无符号操作。

您可以创建这个最终类，将其命名为您想要的任何名称并实现它的静态方法。

如果您不知道如何实现静态方法，那么这个链接可能会帮助您。

在我看来，Java 与 C++ 完全不相似，如果它既不支持无符号类型也不支持运算符重载，所以我认为 Java 应该被视为与 C++ 和 C 完全不同的语言。

顺便说一句，它的语言名称也完全不同。

所以我不建议在 Java 中键入类似于 C 的代码，我根本不建议键入类似于 C++ 的代码，因为那样在 Java 中你将无法执行接下来在 C++ 中要做的事情，也就是说，代码根本不会继续像 C++ 那样，对我来说，这样编码、改变中间的样式是不好的。

我建议也为签名操作编写和使用静态方法，这样您就不会在代码中看到签名和未签名操作的运算符和静态方法的混合，除非您只需要代码中的签名操作，并且可以仅使用运算符。

另外，我建议避免使用 short、int 和 long 原始类型，并使用 word、dword分别是 和 qword，并且您将调用无符号操作和/或有符号操作的静态方法，而不是使用运算符。

如果您打算仅执行签名操作并仅在代码中使用运算符，那么可以使用这些基本类型 short、int 和 long< /强>。

实际上，word、dword 和 qword 并不存在于该语言中，但是您可以为它们创建新类每个以及每个的实现都应该非常简单：

类 word 仅保存原始类型 short，类 dword 保存原始类型 <仅strong>int，类qword仅包含原始类型long。 现在，所有无符号和有符号方法都是静态或非静态的，您可以在每个类中实现，即通过在 word 类上给出含义名称来实现所有无符号和有符号的 16 位操作，所有通过在 dword 类上给出含义名称来进行无符号和有符号的 32 位操作，以及通过在 qword 类上给出含义名称来进行的所有 64 位操作（无论是无符号还是有符号）。

如果您不喜欢为每个方法提供太多不同的名称，您始终可以在 Java 中使用重载，很高兴看到 Java 也没有删除它！

如果您想要 8 位有符号运算的方法而不是运算符，以及根本没有运算符的 8 位无符号运算的方法，那么您可以创建 Byte 类（请注意，第一个字母“B”是大写，所以这不是原始类型byte）并实现此类中的方法。

关于按值传递和按引用传递：

如果我没记错的话，就像在 C# 中一样，原始对象自然是按值传递，但类对象自然是按引用传递，所以这意味着 Byte、word、dword 和 qword 默认情况下将通过引用传递，而不是通过值传递。 我希望 Java 能像 C# 一样拥有 struct 对象，
因此所有Byte、word、dword和qword都可以实现为struct而不是 class，因此默认情况下它们是按值传递的，而不是按引用传递的，就像 C# 中的任何结构体对象一样，像原始类型一样，默认情况下是按值传递而不是按引用传递，但是因为 Java 比 C# 更糟糕，我们必须处理这个问题，所以只有类和接口，它们默认通过引用传递，而不是通过值传递。 因此，如果您想按值而不是按引用传递 Byte、word、dword 和 qword 对象，例如对于 Java 和 C# 中的任何其他类对象，您只需使用复制构造函数即可。

这是我能想到的唯一解决方案。 我只是希望我可以将原始类型typedef为word、dword和qword，但是Java既不支持typedef也不支持using，不像C#支持using，这相当于C的typedef。

关于输出：

对于相同的位序列，您可以通过多种方式打印它们：作为二进制、作为十进制（如 C printf 中 %u 的含义）、作为八进制（如 % 的含义） o 在 C printf 中）、十六进制（如 C printf 中 %x 的含义）和整数（如 C printf 中 %d 的含义）。

请注意，C printf 不知道作为参数传递给函数的变量的类型，因此 printf 仅从传递给函数第一个参数的 char* 对象知道每个变量的类型。

因此，在每个类中：Byte、word、dword和qword，您可以实现 print 方法并获取printf 的功能，即使类的原始类型是有符号的，您仍然可以通过遵循一些涉及逻辑和移位操作的算法来将其打印为无符号，以获得要打印到输出的数字。

不幸的是，我给您的链接没有显示如何实现这些打印方法，但我相信您可以通过谷歌搜索实现这些打印方法所需的算法。

这就是我能回答你的问题和建议你的全部。

Answer 15

我可以向你保证，Java 中确实没有必要使用无符号数。

以C为例。 让我们写一些类似的内容：

unsigned int num = -7;
printf("%d", num);

你能猜出打印的是什么吗？

-7

不存在真正的正整数这样的东西。 无符号整数只是一个 n 字节（取决于 C 中的体系结构）值，不分配 MSB 作为符号。 它不会检查分配或读取的数字的实际符号： https://www.gnu.org/s/libc/manual/html_node/Integers.html

Answer 16

我能想到一个不幸的副作用。 在java嵌入式数据库中，32位id字段可以拥有的id数量是2^31，而不是2^32（~20亿，而不是~40亿）。

Answer 17

恕我直言，原因是他们太懒了，无法实施/纠正该错误。
暗示 C/C++ 程序员不理解无符号、结构、联合、位标志......简直是荒谬的。

要么你正在与一个即将开始用 C 语言编程的 basic/bash/java 程序员交谈，但对这种语言没有任何真正的了解，或者你只是在凭自己的想法说话。 ；）

当你每天处理文件或硬件的格式时，你开始质疑，他们到底在想什么。

这里的一个很好的例子是尝试使用无符号字节作为自旋转循环。
对于那些不明白最后一句话的人来说，你到底如何称自己为程序员。

直流