blocks|key|867505|text|如果你有一个必须传递有符号字节的函数，如果你传递一个无符号字节，你希望它做什么？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|867506|为什么不能使用其他数据类型呢？|867507|通常情况下，您可以使用一个字节作为无符号字节，只需进行简单的转换或无需转换。这完全取决于它是如何使用的。你需要弄清楚你想用它做什么。|867508|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

If you have a function which must be passed a signed byte, what do you expect it to do if you pass an unsigned byte? 

Why can't you use any other data type?

Unsually you can use a byte as an unsigned byte with simple or no translations. It all depends on how it is used. You would need to clarify what you indend to do with it.

blocks|key|1082281|text|在Java中，原语是带符号的，这与它们在内存/传输中的表示方式无关--一个字节只有8位，您是否将其解释为带符号的范围取决于您。没有神奇的旗帜来表示“这是已签名的”或“这是未签名的”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1082282|由于对原语进行了签名，Java编译器将阻止您为一个字节分配高于%2B127的值(或小于-128的值)。然而，为了实现这一点，没有什么可以阻止您向下转换int+(或short)：|1082283|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+%2B200.
+*/
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"
}|code-block|syntax|javascript|1082284|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The fact that primitives are signed in Java is irrelevant to how they're represented in memory / transit - a byte is merely 8 bits and whether you interpret that as a signed range or not is up to you. There is no magic flag to say "this is signed" or "this is unsigned".

As primitives are signed the Java compiler will prevent you from assigning a value higher than +127 to a byte (or lower than -128). However, there's nothing to stop you downcasting an int (or short) in order to achieve this:

<pre><code>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 &amp; 0xFF` is equivalent with `((int) b) &amp; 0xFF`.
 * b) were set to 1s because of "sign extension" during the upcasting
 *
 * 1111 1111 1111 1111 1111 1111 1100 1000 (the int)
 * &amp;
 * 0000 0000 0000 0000 0000 0000 1111 1111 (the 0xFF)
 * =======================================
 * 0000 0000 0000 0000 0000 0000 1100 1000 (200)
 */
System.out.println(b &amp; 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 &amp; 0xFF;
 System.out.println(unsignedByte); // "200"
}
</code></pre>

blocks|key|1082346|text|在Java中使用无符号字节的完整指南：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1082347|Unsigned+byte+in+Java|offset|length|1082348|(此答案的来源。)|1082349|1082350|Java语言没有提供任何类似于unsigned关键字的东西。根据语言规范的byte表示介于−128+-+127之间的值。例如，如果将byte转换为int，Java会将第一位解释为符号并使用sign+extension。|style|CODE|1082351|也就是说，没有什么可以阻止您简单地将byte视为8位，并将这些位解释为0到255之间的值。请记住，您无法将您的解释强加于其他人的方法。如果方法接受byte，则该方法接受介于−128和127之间的值，除非另有明确说明。|1082352|为了方便起见，这里有几个有用的转换/操作：|1082353|与int之间的转换|1082354|//+From+int+to+unsigned+byte
int+i+=+200;++++++++++++++++++++//+some+value+between+0+and+255
byte+b+=+(byte)+i;++++++++++++++//+8+bits+representing+that+value|code-block|syntax|javascript|1082355|​|1082356|//+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|1082357|(或者，如果您使用的是Java+8%2B，请使用Byte.toUnsignedInt。)|1082358|解析/格式化|1082359|最好的方法是使用上面的转换：|1082360|//+Parse+an+unsigned+byte
byte+b+=+(byte)+Integer.parseInt("200");|1082361|1082362|//+Print+an+unsigned+byte
System.out.println("Value+of+my+unsigned+byte:+"+%2B+(b+&+0xFF));|1082363|算术|1082364|2-补码表示对加法、减法和乘法“有效”：|1082365|//+two+unsigned+bytes
byte+b1+=+(byte)+200;
byte+b2+=+(byte)+15;

byte+sum++=+(byte)+(b1+%2B+b2);++//+215
byte+diff+=+(byte)+(b1+-+b2);++//+185
byte+prod+=+(byte)+(b2+*+b2);++//+225|1082366|除法需要手动转换操作数：|1082367|byte+ratio+=+(byte)+((b1+&+0xFF)+/+(b2+&+0xFF));|1082368|entityMap|0|LINK|mutability|MUTABLE|url|https://programming.guide/java/unsigned-byte.html|1|https://en.wikipedia.org/wiki/Sign_extension|2|https://docs.oracle.com/javase/8/docs/api/java/lang/Byte.html#toUnsignedInt-byte-^0|0|0|L|0|0|0|0|F|8|11|4|1U|4|21|3|2M|E|1|0|I|4|21|4|0|0|0|0|0|0|M|I|M|I|2|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Z|8|@]|9|@$D|20|E|21|1|22]]|A|$]]|$1|F|3|G|5|6|7|23|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|24|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|25|8|@$D|26|E|27|K|L]|$D|28|E|29|K|L]|$D|2A|E|2B|K|L]|$D|2C|E|2D|K|L]]|9|@$D|2E|E|2F|1|2G]]|A|$]]|$1|M|3|N|5|6|7|2H|8|@$D|2I|E|2J|K|L]|$D|2K|E|2L|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|2M|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|2N|8|@]|9|@]|A|$]]|$1|S|3|T|5|U|7|2O|8|@]|9|@]|A|$V|W]]|$1|X|3|Y|5|6|7|2P|8|@]|9|@]|A|$]]|$1|Z|3|10|5|U|7|2Q|8|@]|9|@]|A|$V|W]]|$1|11|3|12|5|6|7|2R|8|@$D|2S|E|2T|K|L]]|9|@$D|2U|E|2V|1|2W]]|A|$]]|$1|13|3|14|5|6|7|2X|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|17|3|18|5|U|7|2Z|8|@]|9|@]|A|$V|W]]|$1|19|3|Y|5|6|7|30|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|U|7|31|8|@]|9|@]|A|$V|W]]|$1|1C|3|1D|5|6|7|32|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|33|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|U|7|34|8|@]|9|@]|A|$V|W]]|$1|1I|3|1J|5|6|7|35|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|U|7|36|8|@]|9|@]|A|$V|W]]|$1|1M|3|-4|5|6|7|37|8|@]|9|@]|A|$]]]|1N|$1O|$5|1P|1Q|1R|A|$1S|1T]]|1U|$5|1P|1Q|1R|A|$1S|1V]]|1W|$5|1P|1Q|1R|A|$1S|1X]]]]

Complete guide for working with unsigned bytes in Java:
<h2><a href="https://programming.guide/java/unsigned-byte.html" rel="noreferrer">Unsigned byte in Java</a></h2>
(Source for this answer.)
<hr />
The Java Language does not provide anything like the <code>unsigned</code> keyword. A <code>byte</code> according to the language spec represents a value between −128 - 127. For instance, if a <code>byte</code> is cast to an <code>int</code> Java will interpret the first bit as the sign and use <a href="https://en.wikipedia.org/wiki/Sign_extension" rel="noreferrer">sign extension</a>.
That being said, nothing prevents you from viewing a <code>byte</code> simply as 8 bits and interpret those bits as a value between 0 and 255. Just keep in mind that there's nothing you can do to force your interpretation upon someone else's method. If a method accepts a <code>byte</code>, then that method accepts a value between −128 and 127 unless explicitly stated otherwise.
Here are a couple of useful conversions / manipulations for your convenience:
<h2>Conversions to / from int</h2>
<pre><code>// From int to unsigned byte
int i = 200; // some value between 0 and 255
byte b = (byte) i; // 8 bits representing that value
</code></pre>
 
<pre><code>// From unsigned byte to int
byte b = 123; // 8 bits representing a value between 0 and 255
int i = b &amp; 0xFF; // an int representing the same value
</code></pre>
(Or, if you're on Java 8+, use <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Byte.html#toUnsignedInt-byte-" rel="noreferrer"><code>Byte.toUnsignedInt</code></a>.)
<h2>Parsing / formatting</h2>
Best way is to use the above conversions:
<pre><code>// Parse an unsigned byte
byte b = (byte) Integer.parseInt(&quot;200&quot;);
</code></pre>
 
<pre><code>// Print an unsigned byte
System.out.println(&quot;Value of my unsigned byte: &quot; + (b &amp; 0xFF));
</code></pre>
<h2>Arithmetics</h2>
The 2-complement representation &quot;just works&quot; for addition, subtraction and multiplication:
<pre><code>// 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
</code></pre>
Division requires manual conversion of operands:
<pre><code>byte ratio = (byte) ((b1 &amp; 0xFF) / (b2 &amp; 0xFF));
</code></pre>

blocks|key|1082409|text|我不太明白你的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1082410|我刚刚试过了，对于字节12(有符号值)，它返回整数244+(等同于无符号字节值，但类型为int)：|offset|length|style|CODE|1082411|++public+static+int+unsignedToBytes(byte+b)+{
++++return+b+&+0xFF;
++}

++public+static+void+main(String[]+args)+{
++++System.out.println(unsignedToBytes((byte)+-12));
++}|code-block|syntax|javascript|1082412|这是你想做的吗？|1082413|Java不允许将244表示为127值，就像C一样。要表示Byte.MAX_VALUE+(127)以上的正整数，您必须使用不同的整数类型，如short、int或long。|1082414|entityMap^0|0|18|3|0|0|0|S|E|1X|5|23|3|27|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@$D|Z|E|10|F|G]|$D|11|E|12|F|G]|$D|13|E|14|F|G]|$D|15|E|16|F|G]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$]]

I'm not sure I understand your question.
I just tried this and for byte -12 (signed value) it returned integer 244 (equivalent to unsigned byte value but typed as an <code>int</code>):
<pre><code> public static int unsignedToBytes(byte b) {
 return b &amp; 0xFF;
 }

 public static void main(String[] args) {
 System.out.println(unsignedToBytes((byte) -12));
 }
</code></pre>
Is it what you want to do?
Java does not allow to express 244 as a <code>byte</code> value, as would C. To express positive integers above <code>Byte.MAX_VALUE</code> (127) you have to use a different integral type, like <code>short</code>, <code>int</code> or <code>long</code>.

blocks|key|867714|text|Java中没有原始的无符号字节。通常的做法是将其转换为更大的类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|867715|int+anUnsignedByte+=+(int)+aSignedByte+&+0xff;|code-block|syntax|javascript|867716|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There are no primitive unsigned bytes in Java. The usual thing is to cast it to bigger type:

<pre><code>int anUnsignedByte = (int) aSignedByte &amp; 0xff;
</code></pre>

blocks|key|867737|text|根据Java的限制，在当前的数据类型格式中，无符号字节几乎是不可能的。您可以使用其他语言的其他库来实现您正在实现的内容，然后您可以使用JNI调用它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|867738|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Java_Native_Interface^0|1V|3|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

As per limitations in Java, unsigned byte is almost impossible in the current data-type format. You can go for some other libraries of another language for what you are implementing and then you can call them using <a href="http://en.wikipedia.org/wiki/Java_Native_Interface" rel="nofollow">JNI</a>.

blocks|key|867777|text|顺便说一句，如果你想打印出来，你可以说|type|unstyled|depth|inlineStyleRanges|entityRanges|data|867778|byte+b+=+255;
System.out.println((b+<+0+?+256+%2B+b+:+b));|code-block|syntax|javascript|867779|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A side note, if you want to print it out, you can just say

<pre><code>byte b = 255;
System.out.println((b &lt; 0 ? 256 + b : b));
</code></pre>

blocks|key|867806|text|如果想要Java中的无符号字节，只需从感兴趣的数字中减去256即可。它将生成具有负值的two's+complement，这是以无符号字节表示的所需数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|867807|示例：|867808|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.|code-block|syntax|javascript|867809|在使用leJOS对NXT+brick进行编程时，您需要使用这种肮脏的技巧。|867810|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Two%2527s_complement|1|https://en.wikipedia.org/wiki/LeJOS|2|https://en.wikipedia.org/wiki/Lego_Mindstorms_NXT#NXT_Intelligent_Brick^0|17|G|0|0|0|0|3|5|1|9|9|2|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]|$A|18|B|19|1|1A]]|C|$]]|$1|M|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]|W|$5|P|Q|R|C|$S|X]]]]

If you want unsigned bytes in Java, just subtract 256 from the number you're interested in. It will produce <a href="http://en.wikipedia.org/wiki/Two%27s_complement" rel="nofollow">two's complement</a> with a negative value, which is the desired number in unsigned bytes.

Example:

<pre><code>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.
</code></pre>

You need to use such dirty hacks when using <a href="https://en.wikipedia.org/wiki/LeJOS" rel="nofollow">leJOS</a> to program the <a href="https://en.wikipedia.org/wiki/Lego_Mindstorms_NXT#NXT_Intelligent_Brick" rel="nofollow">NXT brick</a>.

blocks|key|1082605|text|虽然Java在语言中没有包含无符号字节看起来很恼人(来自C)，但它实际上没什么大不了的，因为一个简单的"b+&+0xFF“操作在实际需要的情况下会产生(有符号的)字节b的无符号值。位实际上不会改变--只是解释(这只在对值进行一些数学运算时才重要)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1082606|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Although it may seem annoying (coming from C) that Java did not include unsigned byte in the language it really is no big deal since a simple "b &amp; 0xFF" operation yields the unsigned value for (signed) byte b in the (rare) situations that it is actually needed. The bits don't actually change -- just the interpretation (which is important only when doing for example some math operations on the values).

blocks|key|1082643|text|Adamski提供了最好的答案，但它不是很完整，所以请阅读他的回复，因为它解释了我没有的细节。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1082644|如果系统函数需要传递无符号字节，则可以传递有符号字节，因为它会自动将其视为无符号字节。|1082645|因此，如果系统函数需要四个字节，例如，192+168+0+1作为无符号字节，您可以传递-64+-88+0+1，函数仍将工作，因为将它们传递给函数的操作将取消它们的签名。|1082646|但是，您不太可能遇到这个问题，因为为了跨平台兼容性，系统函数被隐藏在类后面，尽管一些java.io读取方法将未标记的字节作为整数返回。|1082647|如果您希望看到这一点，请尝试将有符号字节写入文件，然后将它们作为无符号字节读回。|1082648|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Adamski provided the best answer, but it is not quite complete, so read his reply, as it explains the details I'm not.

If you have a system function that requires an unsigned byte to be passed to it, you can pass a signed byte as it will automatically treat it as an unsigned byte.

So if a system function requires four bytes, for example, 192 168 0 1 as unsigned bytes you can pass -64 -88 0 1, and the function will still work, because the act of passing them to the function will un-sign them.

However you are unlikely to have this problem as system functions are hidden behind classes for cross-platform compatibility, though some of the java.io read methods return unsighed bytes as an int.

If you want to see this working, try writing signed bytes to a file and read them back as unsigned bytes.

blocks|key|867949|text|如果你认为你正在寻找这样的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|867950|public+static+char+toUnsigned(byte+b)+{
++++return+(char)+(b+>=+0+?+b+:+256+%2B+b);
}|code-block|syntax|javascript|867951|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If think you are looking for something like this.

<pre><code>public static char toUnsigned(byte b) {
 return (char) (b &gt;= 0 ? b : 256 + b);
}
</code></pre>

blocks|key|868013|text|我认为其他答案已经涵盖了内存表示，您如何处理这些问题取决于您计划如何使用它的上下文。我将添加该Java+8+added+some+support+for+dealing+with+unsigned+types。在这种情况下，您可以使用Byte.toUnsignedInt|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|868014|int+unsignedInt+=+Byte.toUnsignedInt(myByte);|code-block|syntax|javascript|868015|entityMap|0|LINK|mutability|MUTABLE|url|https://blogs.oracle.com/darcy/entry/unsigned_api|1|https://docs.oracle.com/javase/8/docs/api/java/lang/Byte.html#toUnsignedInt-byte-^0|39|I|1B|1L|0|39|I|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

I think the other answers have covered memory representation and how you handle these depends on the context of how you plan on using it. I'll add that <a href="https://blogs.oracle.com/darcy/entry/unsigned_api" rel="noreferrer">Java 8 added some support for dealing with unsigned types</a>. In this case, you could use <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Byte.html#toUnsignedInt-byte-" rel="noreferrer"><code>Byte.toUnsignedInt</code></a>

<pre class="lang-java prettyprint-override"><code>int unsignedInt = Byte.toUnsignedInt(myByte);
</code></pre>

blocks|key|868067|text|是也不是。我一直在研究这个问题。就像我理解的那样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|868068|事实上，java已经签署了interger+-128到127..在java中，可以使用以下命令呈现未签名的：|868069|public+static+int+toUnsignedInt(byte+x)+{
++++return+((int)+x)+&+0xff;
}|code-block|syntax|javascript|868070|例如，如果您将-12有符号数字添加到unsigned，则会得到244。但是你可以在signed中再次使用这个数字，它必须被移回signed，它将再次变为-12。|868071|如果你尝试将244加到java+byte中，你会得到outOfIndexException。|868072|干杯..|868073|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Yes and no. Ive been digging around with this problem. 
Like i understand this: 

The fact is that java has signed interger -128 to 127..
It is possible to present a unsigned in java with: 

<pre><code>public static int toUnsignedInt(byte x) {
 return ((int) x) &amp; 0xff;
}
</code></pre>

If you for example add -12 signed number to be unsigned you get 244. But you can use that number again in signed, it has to be shifted back to signed and it´ll be again -12. 

If you try to add 244 to java byte you'll get outOfIndexException.

Cheers..

I am trying to convert a signed byte in unsigned. The problem is the data I am receiving is unsigned and Java does not support unsigned byte, so when it reads the data it treats it as signed.

I tried it to convert it by the following solution I got from Stack&nbsp;Overflow.

<pre><code>public static int unsignedToBytes(byte a)
{
 int b = a &amp; 0xFF;
 return b;
}
</code></pre>

But when again it's converted in byte, I get the same signed data. I am trying to use this data as a parameter to a function of Java that accepts only a byte as parameter, so I can't use any other data type. How can I fix this problem?

Can we make unsigned byte in Java

我正在尝试将有符号字节转换为无符号字节。问题是我接收的数据是无符号的，而Java不支持无符号字节，所以当它读取数据时，它会将其视为有符号的。我试着用我从Stack和Overflow得到的解决方案来转换它。public static int unsignedToBytes(byte a){    int b = a & ...

问我们可以在Java中使用无符号字节吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我们可以在Java中使用无符号字节吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我们可以在Java中使用无符号字节吗？
EN