我正在尝试将有符号字节转换为无符号字节。问题是我收到的数据是无符号的，Java 不支持无符号字节，所以当它读取数据时，它会将其视为有符号的。
我尝试通过从 * 获得的以下解决方案对其进行转换。
public static int unsignedToBytes(byte a)
{
int b = a & 0xFF;
return b;
}
但是当它再次转换为字节时，我得到了相同的签名数据。我正在尝试将此数据用作 Java 函数的参数，该函数仅接受一个字节作为参数，因此我不能使用任何其他数据类型。我该如何解决这个问题？
【问题讨论】：
在 Java 中对原语进行签名这一事实与它们在内存/传输中的表示方式无关 - 一个字节仅为 8 位，您是否将其解释为有符号范围取决于您。没有神奇的标志可以说“这是签名的”或“这是未签名的”。
由于对原语进行了签名，Java 编译器将阻止您将高于 +127 的值分配给一个字节（或低于 -128）。但是，没有什么可以阻止您向下转换 int（或 short）以实现此目的：
int i = 200; // 0000 0000 0000 0000 0000 0000 1100 1000 (200)
byte b = (byte) 200; // 1100 1000 (-56 by Java specification, 200 by convention)
/*
* Will print a negative int -56 because upcasting byte to int does
* so called "sign extension" which yields those bits:
* 1111 1111 1111 1111 1111 1111 1100 1000 (-56)
*
* But you could still choose to interpret this as +200.
*/
System.out.println(b); // "-56"
/*
* Will print a positive int 200 because bitwise AND with 0xFF will
* zero all the 24 most significant bits that:
* a) were added during upcasting to int which took place silently
* just before evaluating the bitwise AND operator.
* So the `b & 0xFF` is equivalent with `((int) b) & 0xFF`.
* b) were set to 1s because of "sign extension" during the upcasting
*
* 1111 1111 1111 1111 1111 1111 1100 1000 (the int)
* &
* 0000 0000 0000 0000 0000 0000 1111 1111 (the 0xFF)
* =======================================
* 0000 0000 0000 0000 0000 0000 1100 1000 (200)
*/
System.out.println(b & 0xFF); // "200"
/*
* You would typically do this *within* the method that expected an
* unsigned byte and the advantage is you apply `0xFF` only once
* and than you use the `unsignedByte` variable in all your bitwise
* operations.
*
* You could use any integer type longer than `byte` for the `unsignedByte` variable,
* i.e. `short`, `int`, `long` and even `char`, but during bitwise operations
* it would get casted to `int` anyway.
*/
void printUnsignedByte(byte b) {
int unsignedByte = b & 0xFF;
System.out.println(unsignedByte); // "200"
}
【讨论】：
我不确定我是否理解你的问题。
我刚刚尝试过，对于字节 -12（有符号值），它返回整数 244（相当于无符号字节值，但键入为 int）：
public static int unsignedToBytes(byte b) {
return b & 0xFF;
}
public static void main(String[] args) {
System.out.println(unsignedToBytes((byte) -12));
}
这是你想做的吗？
Java 不允许像 C 一样将 244 表示为 byte 值。要表示高于 Byte.MAX_VALUE (127) 的正整数，您必须使用不同的整数类型，例如 short、int 或long.
【讨论】：
byte b = (byte)unsignedToBytes((byte) -12); 现在尝试打印 b
在 Java 中使用无符号字节的完整指南：
（此答案的来源。）
Java 语言不提供类似unsigned 关键字的内容。根据语言规范，byte 表示介于 -128 - 127 之间的值。例如，如果将 byte 强制转换为 int，Java 会将第一位解释为符号并使用 sign extension。
话虽如此，没有什么可以阻止您将 byte 简单地视为 8 位并将这些位解释为 0 到 255 之间的值。请记住，您无法将自己的解释强加于其他人的方法.如果一个方法接受 byte，那么除非另有明确说明，否则该方法接受介于 -128 和 127 之间的值。
为了您的方便，这里有几个有用的转换/操作：
// From int to unsigned byte
int i = 200; // some value between 0 and 255
byte b = (byte) i; // 8 bits representing that value
// From unsigned byte to int
byte b = 123; // 8 bits representing a value between 0 and 255
int i = b & 0xFF; // an int representing the same value
（或者，如果您使用的是 Java 8+，请使用 Byte.toUnsignedInt。）
最好的方法是使用上面的转换：
// Parse an unsigned byte
byte b = (byte) Integer.parseInt("200");
// Print an unsigned byte
System.out.println("Value of my unsigned byte: " + (b & 0xFF));
2-补码表示“正好适用于”加法、减法和乘法：
// two unsigned bytes
byte b1 = (byte) 200;
byte b2 = (byte) 15;
byte sum = (byte) (b1 + b2); // 215
byte diff = (byte) (b1 - b2); // 185
byte prod = (byte) (b2 * b2); // 225
除法需要手动转换操作数：
byte ratio = (byte) ((b1 & 0xFF) / (b2 & 0xFF));
【讨论】：
Java 中没有原始的无符号字节。通常的做法是将其转换为更大的类型：
int anUnsignedByte = (int) aSignedByte & 0xff;
【讨论】：
您还可以：
public static int unsignedToBytes(byte a)
{
return (int) ( ( a << 24) >>> 24);
}
说明：
假设a = (byte) 133;
在内存中存储为：“1000 0101”（0x85 in hex）
所以它的表示转换为 unsigned=133, signed=-123（作为 2 的补码）
一个
当向左移动 24 位时，结果现在是一个 4 字节整数，表示为：
“10000101 00000000 00000000 00000000”（或十六进制的“0x85000000”）
那么我们有
(a >>> 24
它再次向右移动 24 位，但用前导零填充。所以结果是：
“00000000 00000000 00000000 10000101”（或十六进制的“0x00000085”）
那是等于 133 的无符号表示。
如果您尝试投射 a = (int) a;
那么会发生什么是它保留字节的 2 的补码表示并将其存储为 int 也作为 2 的补码：
(int) "10000101" ---> "11111111 11111111 11111111 10000101"
翻译为：-123
【讨论】：
java.lang.Byte.toUnsignedInt(byte value)。如果您还没有使用 Java 8，请尽快升级。 Java 7 及更早版本的生命周期结束。
我认为其他答案已经涵盖了内存表示，您如何处理这些取决于您计划如何使用它的上下文。我将添加Java 8 added some support for dealing with unsigned types。在这种情况下，您可以使用Byte.toUnsignedInt
int unsignedInt = Byte.toUnsignedInt(myByte);
【讨论】：
附注，如果你想打印出来，你可以说
byte b = 255;
System.out.println((b < 0 ? 256 + b : b));
【讨论】：
println(b & 0xff)就够了
尽管 Java 没有在语言中包含无符号字节可能看起来很烦人（来自 C），但它确实没什么大不了的，因为一个简单的“b & 0xFF”操作会产生（有符号）字节 b 的无符号值（罕见的）实际需要的情况。这些位实际上并没有改变——只是解释（仅在对值进行一些数学运算时才重要）。
【讨论】：
x & 0xFF，要么在任何地方重复behaveLikeAnUnsignedByte(x)之类的东西。这对于您使用需要无符号的字节值或字节数组的每个地方都是必需的，没有可以想象的避免这种重复的方法。您不能编写一个协议的实现，该协议仅通过对字节变量的单个引用来读取和写入字节值。你的简单化观点或许可以解释为什么他们从不关心修复它。
是和不是。我一直在研究这个问题。 就像我理解的那样：
事实上，java 已经签署了整数 -128 到 127.. 可以在 java 中显示一个未签名的：
public static int toUnsignedInt(byte x) {
return ((int) x) & 0xff;
}
例如，如果您将 -12 有符号数字添加为无符号数字，您将得到 244。但是您可以再次使用该数字符号，它必须移回有符号数字，它将再次变为 -12。
如果你尝试将 244 添加到 java 字节，你会得到 outOfIndexException。
干杯..
【讨论】：
java.lang.Byte.toUnsignedInt(byte value); 存在于此。
Adamski 提供了最佳答案，但并不完整，因此请阅读他的回复，因为它解释了我没有回答的细节。
如果您有一个系统函数需要将无符号字节传递给它，您可以传递一个有符号字节，因为它会自动将其视为无符号字节。
因此，如果系统函数需要四个字节，例如，192 168 0 1 作为无符号字节，您可以传递 -64 -88 0 1，该函数仍然可以工作，因为将它们传递给函数的行为将取消- 给他们签名。
但是，您不太可能遇到此问题，因为系统函数隐藏在类后面以实现跨平台兼容性，尽管一些 java.io 读取方法将 unsighed 字节作为 int 返回。
如果您想看到这个工作，请尝试将有符号字节写入文件并将它们作为无符号字节读回。
【讨论】：
Java中没有无符号字节，但是如果你想显示一个字节，你可以这样做，
int myInt = 144;
byte myByte = (byte) myInt;
char myChar = (char) (myByte & 0xFF);
System.out.println("myChar :" + Integer.toHexString(myChar));
输出：
myChar : 90
欲了解更多信息，请查看，How to display a hex/byte value in Java。
【讨论】：
java.lang.Byte.toUnsignedInt(byte value); 存在于此。
如果您想要 Java 中的无符号字节，只需从您感兴趣的数字中减去 256。它会产生带有负值的 two's complement，这是所需的无符号字节数。
例子：
int speed = 255; //Integer with the desired byte value
byte speed_unsigned = (byte)(speed-256);
//This will be represented in two's complement so its binary value will be 1111 1111
//which is the unsigned byte we desire.
【讨论】：
speed_unsigned 中的值已签名。打印出来看看。 （而- 256 在这里一无所获。）
根据 Java 的限制，在当前数据类型格式中几乎不可能使用无符号字节。您可以使用其他语言的其他库来实现您正在实现的功能，然后您可以使用JNI 调用它们。
【讨论】：
如果你有一个函数必须传递一个有符号字节，如果你传递一个无符号字节，你期望它做什么？
为什么不能使用其他数据类型？
通常您可以将一个字节用作无符号字节，只需简单翻译或不翻译。这一切都取决于它是如何使用的。你需要澄清你打算用它做什么。
【讨论】：
如果你认为你正在寻找这样的东西。
public static char toUnsigned(byte b) {
return (char) (b >= 0 ? b : 256 + b);
}
【讨论】：
我正在尝试将此数据用作 Java 函数的参数，该函数只接受一个字节作为参数
这与接受整数的函数没有本质区别，您希望将大于 2^32-1 的值传递给该函数。
这听起来取决于函数是如何定义和记录的；我可以看到三种可能性：
它可能会明确记录该函数将字节视为无符号值，在这种情况下，该函数可能应该执行您期望的操作，但似乎实现错误。对于整数情况，函数可能会将参数声明为无符号整数，但对于字节情况，这是不可能的。
它可能会记录该参数的值必须大于（或可能等于）零，在这种情况下，您正在滥用函数（传递超出范围的参数），期望它这样做超过它的设计目的。借助一定程度的调试支持，您可能希望该函数抛出异常或使断言失败。
文档可能什么也没说，在这种情况下，负参数就是负参数，它是否有任何意义取决于函数的作用。如果这是没有意义的，那么也许该功能应该真正定义/记录为（2）。如果这以非显而易见的方式有意义（例如，非负值用于索引数组，负值用于从数组末尾索引，所以 -1 表示最后一个元素）文档应该说明它是什么意思是，我希望它无论如何都不是你想要的。
【讨论】：
在想知道 netty ByteBuf writeInt 和 readUnsignedInt 方法的明显不对称性后，我偶然发现了这个页面。
在阅读了有趣且具有教育意义的答案后，我仍然想知道您说的是什么函数：
我正在尝试将此数据用作 Java 函数的参数 只接受一个字节作为参数。
这么多年后它值多少钱，这是我的 50 美分：
让我们假设您调用的方法正在使用微量金额更新一些余额，并且它的行为符合一些明确定义的要求。即，它被认为对其预期行为有正确的实现：
long processMicroPayment(byte amount) {
this.balance += amount;
return balance;
}
基本上，如果您提供正数，它将被添加到余额中，而负数将有效地从余额中减去。现在因为它接受一个字节作为其参数，所以隐含的假设是它在功能上只接受 -128 和 +127 之间的数量。因此，如果您想使用此方法将 130 添加到余额中，它根本不会产生您想要的结果，因为在此方法的实现中无法表示高于 127 的金额。所以传递它130不会导致你想要的 行为。请注意，该方法无法实现（例如）AmountOutOfBoundsException，因为 130 将被“解释”为仍遵守方法约定的负值。
所以我有以下问题：
【讨论】：