顺便说一句，如果你想打印出来，你可以说

byte b = 255;
System.out.println((b < 0 ? 256 + b : b));

在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"
}

虽然Java语言中没有包含无符号字节看起来很烦人(来自C)，但这真的不是什么大问题，因为一个简单的“b & 0xFF”操作在(很少)实际需要的情况下为(有符号)字节b产生无符号值。比特实际上并没有改变——只是解释(这只在例如对值进行一些数学运算时很重要)。

如果你有一个函数必须传递一个有符号字节，如果你传递一个无符号字节，你期望它做什么?

为什么不能使用其他数据类型?

通常情况下，您可以使用一个字节作为一个无符号字节简单或不翻译。这完全取决于如何使用。你需要澄清你打算用它做什么。

在Java中使用unsigned字节的完整指南:

Java中的无符号字节

(答案来源)

Java语言不提供任何类似unsigned关键字的东西。根据语言规范，一个字节表示−128 - 127之间的值。例如，如果将一个字节转换为int类型，Java将把第一位解释为符号并使用符号扩展。

也就是说，没有什么可以阻止您将一个字节简单地视为8位，并将这些位解释为0到255之间的值。只要记住，你不能把你的解释强加给别人的方法。如果一个方法接受一个字节，那么该方法接受−128到127之间的值，除非另有明确说明。

下面是一些有用的转换/操作，方便您使用:

从int到int的转换

// 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));

你还可以:

public static int unsignedToBytes(byte a)
{
    return (int) ( ( a << 24) >>> 24);
}    

解释:

假设a = (byte) 133;

在内存中，它被存储为:"1000 0101"(十六进制中的0x85)

所以它的表示可以转换为unsigned=133, signed=-123(作为2的补码)

A << 24

当向左移动24位时，结果现在是一个4字节的整数，表示为:

"10000101 00000000 00000000 00000000"(或十六进制中的"0x85000000")

然后我们有

(a << 24) >>>

它又向右移动了24位，但前导都是0。结果是:

"00000000 00000000 00000000 10000101"(或十六进制中的"0x00000085")

这就是无符号表达式它等于133。

如果你试图强制转换a = (int) a; 然后会发生的是，它保留了字节的2补表示，并将其存储为int，同时也存储为2的补:

(int)“10000101”——>“11111111 11111111 11111111 10000101”

翻译过来就是-123