Java：无符号数

Question

Java 中有没有一种方法可以像 (My)SQL 中那样使用无符号数字？

例如：我想使用一个 8 位变量 (byte)，其范围如下：0 ... 256；而不是 -128 ... 127。

Answer 1

不，除了 char（其值实际上为 0-65535）之外，Java 没有任何无符号基元类型。这很痛苦（特别是对于byte），但事实就是如此。

通常，您要么坚持使用相同的大小，并溢出到“高”数字的负数，要么使用更宽的类型（例如 short 表示 byte）并应对额外的情况内存要求。

Answer 2

您可以使用类来模拟无符号数。例如

public class UInt8 implements Comparable<UInt8>,Serializable
   {
   public static final short MAX_VALUE=255;
   public static final short MIN_VALUE=0;
   private short storage;//internal storage in a int 16

   public UInt8(short value)
      {
      if(value<MIN_VALUE || value>MAX_VALUE) throw new IllegalArgumentException();
      this.storage=value;
      }

   public byte toByte()
      {
      //play with the shift operator ! << 
      }
  //etc...
   }

Answer 3

大多数情况下，您可以像使用无符号数字一样使用有符号数字。大多数操作保持不变，有些需要修改。请参阅这篇文章。

Answer 4

在内部，您不应该使用较小的值——只需使用 int。据我了解，使用较小的单位只会减慢速度。它不会节省内存，因为 Java 在内部使用系统的字大小进行所有存储（它不会打包字）。

但是，如果您使用较小尺寸的存储单元，则必须对每个操作进行屏蔽或范围检查或其他操作。

有没有注意到 char （任何操作） char 都会产生 int ？他们只是真的不希望您使用这些其他类型。

例外是数组（我相信它们会被打包）和 I/O，您可能会发现使用较小的类型很有用……但屏蔽也可以工作。

Answer 5

不，你无法改变这一点。如果您需要大于 127 的值，请选择大于字节的值。

Answer 6

如果您需要优化存储（例如大矩阵），您可以用负数编码更大的正数，以节省空间。然后，您必须在需要时移动数值才能获得实际值。例如，我只想操纵短正数。这在 Java 中是如何实现的：

        short n = 32767;
        n = (short) (n + 10);
        System.out.println(n);     
        int m = (int) (n>=0?n:n+65536); 
        System.out.println(m);

因此，当短整数超出范围时，它会变为负数。然而，至少你可以将这个数字存储在 16 位中，并通过添加移位值（可以编码的不同值的数量）来恢复其正确值。该值应该以更大的类型（在我们的例子中为 int ）恢复。这可能不是很方便，但我发现对于我来说确实如此。

Answer 7

我对 Java 和编程都很陌生。
然而，我最近遇到了同样的情况，需要无符号值。

我花了大约两周的时间来编写我想到的所有内容，但我完全是个菜鸟，所以你可以花更少的钱。

总体思路是创建接口，我将其命名为：UnsignedNumber 并扩展 Number.class，同时实现抽象 AbstractUnsigned> 类。

所以，Base参数化类型代表基本类型，Shifted代表实际的Java类型。 Impl 是实现这个抽象类的快捷方式。

大部分时间消耗在 Java 8 Lambda 的样板以及内部私有类和安全过程上。重要的是当减法或负加等数学运算产生零限制时，实现无符号的行为：向后溢出有符号上限。

最后，又花了几天时间来编写工厂和实现子类的代码。

到目前为止我已经知道：
UByte 和 MUByte
UShort 和 MUshort
UInt 和 MUInt
...等等。

他们是 AbstractUnsigned 的后代：
UByte 或 MUByte 扩展 AbstractUnsigned 或 AbstractUnsigned
UShort 或 MUShort 扩展 AbstractUnsigned 或 AbstractUnsigned
...ETC。

总体思想是将无符号上限作为移位（强制转换）类型和负值的代码转置，因为它们不是来自零，而是来自无符号上限。

更新：
（感谢 Ajeans 友善而礼貌的指示）

/**
* Adds value to the current number and returns either
* new or this {@linkplain UnsignedNumber} instance based on
* {@linkplain #isImmutable()}
*
* @param value value to add to the current value
* @return new or same instance
* @see #isImmutable()
*/
public Impl plus(N value) {
    return updater(number.plus(convert(value)));
}

这是 AbstractUnsigned 的外部可访问方法;（或者正如之前所说的AbstractUnsigned）；
现在，进行底层工作：

private Impl updater(Shifted invalidated){
    if(mutable){
        number.setShifted(invalidated);
        return caster.apply(this);
    } else {
        return shiftedConstructor.apply(invalidated);
    }
}

在上面的私有方法中，mutable 是一个AbstractUnsigned 的私有最终布尔值。 number 是内部私有类之一，负责将 Base 转换为 Shifted，反之亦然。
与之前的“我去年夏天做了什么”相对应的重要内容
是两个内部对象：caster 和 shiftedConstructor：

final private Function<UnsignedNumber<N, Shifted>, Impl> caster;
final private Function<Shifted, Impl> shiftedConstructor;

这些是将 N（或 Base）转换为的参数化函数Shifted 或创建新的 Impl 实例（如果 AbstractUnsigned<> 的当前实现实例是不可变的）。

Shifted plus(Shifted value){
    return spawnBelowZero.apply(summing.apply(shifted, value));
}

在此片段中显示了 number 对象的添加方法。这个想法是始终在内部使用 Shifted，因为不确定何时产生“原始”类型的正限制。 shifted 是一个内部参数化字段，它承载整个 AbstractUnsigned<> 的值。下面给出了另外两个 Function>> 派生对象：

final private BinaryOperator<Shifted> summing;
final private UnaryOperator<Shifted> spawnBelowZero;

前者执行两个 Shifted 值的加法。后者在零转位以下进行产卵。

现在是来自 AbstractUnsigned 的工厂样板“地狱”之一的示例，专门针对之前提到的 spawnBelowZero UnaryOperator >：

...,
         v-> v >= 0
         ? v
         : (short) (Math.abs(Byte.MIN_VALUE) + Byte.MAX_VALUE + 2 + v),
...

如果 Shifted v 为正，则不会发生任何事情，并且会返回原始值。否则：需要计算 Base 类型的上限（即 Byte），并将该值加起来为负值 v。假设，v == -8 则 Math.abs(Byte.MIN_VALUE) 将生成 128 和 Byte.MAX_VALUE 将产生 127 ，它给出 255 + 1 以获得原始上限，该上限被符号位切断，正如我所得到的那样，如此理想256 就在这个地方。但第一个负值实际上是256，这就是为什么再次+1或总共+2的原因。最后，255 + 2 + v（即-8）给出255 + 2 + (-8)和249

或者以更直观的方式：

0 1 2 3 ... 245 246 247 248 249 250 251 252 253 254 255 256
                             -8  -7  -6  -5  -4  -3  -2  -1

最后确定所有这些：这绝对不会减轻您的工作或节省内存字节，但在需要时您会获得非常理想的行为。您几乎可以将这种行为与任何其他 Number.class 子类一起使用。 AbstractUnsigned 是 Number.class 的子类，它本身提供了所有方便的方法和常量
与其他“原生”Number.class 子类类似，包括 MIN_VALUE 和 MAX_VALUE 等等，例如，我为可变代码编写了便捷方法名为 makeDivisibileBy(Number n) 的子类执行最简单的 value - (value % n) 操作。

我最初的努力是为了证明即使像我这样的菜鸟也可以编写代码。当我编写该类代码时，我最初的努力是获得方便的多功能工具以供持续使用。