entityMap|blocks|key|8sb0k|text|在java中没有这样的类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

entityMap|blocks|key|6v4pu|text|Java没有无符号类型。你需要它做什么？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|dd0b|然而，Java确实有'byte‘数据类型。^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

You can't, really. Java doesn't have any unsigned data types, except <code>char</code>.

Admittedly you could use <code>char</code> - it's a 16-bit unsigned type - but that would be horrible in my view, as <code>char</code> is clearly meant to be for text: when code uses <code>char</code>, I expect it to be using it for UTF-16 code units representing text that's interesting to the program, not arbitrary unsigned 16-bit integers with no relationship to text.

entityMap|blocks|key|4s5pp|text|你不能，真的。Java没有任何无符号数据类型，除了char。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4q7c4|无可否认，你可能使用char-它是一个16位的无符号类型--但在我看来这太可怕了，因为char显然是针对文本的:当代码使用char，我希望它用于表示程序感兴趣的文本的UTF-16代码单元，而不是与文本无关的任意无符号16位整数。^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

entityMap|blocks|key|cumoi|text|是的，如果你想在代码与位的运算中使用值，就没有这样的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

Yep no such thing if you want to use the value in code vs. bit operations.

entityMap|blocks|key|85epe|text|您可以使用char，因为它是一个无符号的16位值(尽管从技术上讲，它是一个unicode字符，因此将来可能会完全更改为24位值)……另一种选择是使用int，并确保它在范围内。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|261iv|不要使用char+-使用int+:-)|dsoab|这是一个链接讨论Java和unsigned的缺失。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|G|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|H|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|I|9|@]|A|@]|B|$]]]]

You can use a char, as it is an unsigned 16 bit value (though technically it is a unicode character so could potnetially change to be a 24 bit value in the future)... the other alternative is to use an int and make sure it is within range.

Don't use a char - use an int :-)

And here is a <a href="http://darksleep.com/player/JavaAndUnsignedTypes.html" rel="noreferrer">link discussing Java and the lack of unsigned</a>.

entityMap|blocks|key|d6gi9|text|您可以将自己的代码编写为ShortUnsigned类并为所需的运算符定义方法。你不能过载%2B和-以及它们上的其他类型，也没有与其他原始或数值对象类型的隐式类型转换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|e9duu|像其他一些回答者一样，我想知道为什么您对unsigned+short有如此迫切的需求，而其他数据类型无法满足这种需求。^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

You can code yourself up a <code>ShortUnsigned</code> class and define methods for those operators you want. You won't be able to overload <code>+</code> and <code>-</code> and the others on them, nor have implicit type conversion with other primitive or numeric object types, alas.

Like some of the other answerers, I wonder why you have this pressing need for unsigned short that no other data type will fill.

entityMap|blocks|key|74orb|text|如果您确实需要一个恰好为16位的值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|10lqr|解决方案1：使用可用的有符号短码，不要担心符号，除非您需要进行比较(<，<=，>，>=)或除法(/，%25，>>)操作。请参见这个答案了解如何处理带符号的数字，就好像它们是无符号的一样。|ffvcd|解决方案2(解决方案1不适用)：使用int的低16位，并在必要时使用&+0xffff删除高位。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|G|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|H|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|I|9|@]|A|@]|B|$]]]]

If you really need a value with exactly 16 bits:

Solution 1: Use the available signed short and stop worrying about the sign, unless you need to do comparison (&lt;, &lt;=, >, >=) or division (/, %, >>) operations. See <a href="https://stackoverflow.com/questions/397867/port-of-random-generator-from-c-to-java#397997">this answer</a> for how to handle signed numbers as if they were unsigned.

Solution 2 (where solution 1 doesn't apply): Use the lower 16 bits of int and remove the higher bits with &amp; 0xffff where necessary.

entityMap|blocks|key|1vcsa|text|这是一个非常陈旧的帖子，但对后来的任何人来说都是有益的。字符是数值类型。它支持所有的数学运算符，位运算等。它是一个无符号16。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5nvgf|我们处理由自定义嵌入式硬件记录的信号，因此我们处理大量来自A-D的未签名16。多年来，我们一直在到处使用字符，从未遇到过任何问题。^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

This is a really stale thread, but for the benefit of anyone coming after. The char is a numeric type. It supports all of the mathematical operators, bit operations, etc. It is an unsigned 16.

We process signals recorded by custom embedded hardware so we handle a lot of unsigned 16 from the A-D's. We have been using chars all over the place for years and have never had any problems.

entityMap|blocks|key|c1epi|text|显示为什么需要无符号数字的简单程序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|fpu79|package+shifttest;
public+class+ShiftTest{
++++public+static+void+main(String[]+args){
++++++++short+test+=+-15000;
++++++++System.out.format+("0x%2504X+0x%2504X+0x%2504X+0x%2504X+0x%2504X\n",
++++++++++++test,+test>>1,+test>>2,+test>>3,+test>>4);
++++}
}|code-block|syntax|javascript|1jiec|结果：|6uttm|0xC568+0xFFFFE2B4+0xFFFFF15A+0xFFFFF8AD+0xFFFFFC56|10d0c|现在，对于那些不是系统类型的类型：|sv8e|JAVA做算术移位是因为操作数是有符号的，然而，在某些情况下，逻辑移位是合适的，但JAVA+(特别是Sun)认为这是不必要的，这对我们来说太糟糕了，因为他们的短视。当你所拥有的都是有符号的较长数字时，Shift，And，Or，and+Exclusive+Or是有限的工具。当连接到与16位或更多的“真实”计算机位通信的硬件设备时，这是一个特别的问题。"char“不能保证工作(它现在是两个字节宽)，但在几种基于东方gif的语言中，如中文、韩语和日语，至少需要3个字节。我不熟悉需要多少沙脚本风格的语言。字节数并不取决于程序员，而是取决于JAVA标准委员会。因此，将char设置为16位有下行风险。要安全地实现unsigned+shorts，作为特殊类是基于上述歧义的最佳解决方案。这个类的缺点是不能重载这个特殊类的数学运算。这个帖子的许多贡献者都准确地指出了这些问题，但我的贡献是一个工作代码示例，以及我在Linux下的C%2B%2B中使用3字节gifs语言的经验。^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|P|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|Q|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|R|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|S|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|T|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|U|9|@]|A|@]|B|$]]]]

Simple program to show why unsigned numbers are needed:

<pre><code>package shifttest;
public class ShiftTest{
 public static void main(String[] args){
 short test = -15000;
 System.out.format ("0x%04X 0x%04X 0x%04X 0x%04X 0x%04X\n",
 test, test&gt;&gt;1, test&gt;&gt;2, test&gt;&gt;3, test&gt;&gt;4);
 }
}
</code></pre>

results:

<pre><code>0xC568 0xFFFFE2B4 0xFFFFF15A 0xFFFFF8AD 0xFFFFFC56
</code></pre>

Now for those that are not system types:

JAVA does an arithmetic shift because the operand is signed, however, there are cases where a logical shift would be appropriate but JAVA (Sun in particular), deemed it unnecessary, too bad for us on their short sightedness. Shift, And, Or, and Exclusive Or are limited tools when all you have are signed longer numbers. This is a particular problem when interfacing to hardware devices that talk "REAL" computer bits that are 16 bits or more. "char" is not guaranteed to work (it is two bytes wide now) but in several eastern gif based languages such as Chinese, Korean, and Japanese, require at least 3 bytes. I am not acquainted with the number need for sandscript style languages. The number of bytes does not depend on the programmer rather the standards committee for JAVA. So basing char as 16 bits has a downstream risk. To safely implement unsigned shorts JAVA, as special class is the best solution based on the aforementioned ambiguities. The downside of the class is the inability of overloading the mathematical operations for this special class. Many of the contributors for this thread of accurately pointed out these issues but my contribution is a working code example and my experience with 3 byte gifs languages in C++ under Linux.

entityMap|blocks|key|esfh2|text|他说他想创建一个多维短阵列。然而，没有人建议使用按位运算符？据我所知，你想使用16位整数而不是32位整数来节省内存？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|9k1pq|首先，10,000+x+10,000短值是1,600,000,000比特，200,000,000字节，200,000千字节，200兆字节。|vbce|如果你需要200MB内存消耗的东西，你可能需要重新设计这个想法。我也不相信会编译，更不用说运行了。你永远不应该初始化像那样的大型数组，如果有的话，那就是利用了两个称为按需加载和数据缓存的特性。本质上，按需加载指的是只在需要时加载数据的想法。然后数据缓存做同样的事情，但利用一个自定义的框架来删除旧的内存并根据需要添加新的信息。这是一个具有良好的速度性能的技巧。你还可以做其他的事情，但如果做得好的话，这两件事是我最喜欢的。|c6d9n|好了，回到我刚才所说的按位运算符。|cr6i6|因此32位整数或Java中的"int“。你可以将所谓的“位”存储到这里，所以假设你有32个布尔值，在Java中，所有的值都占用32位(除了long)，或者对于数组，它们占用8个字节，16个缩写，32个整数。因此，除非您有数组，否则使用byte或short不会获得任何内存优势。这并不意味着您不应该使用它，因为它是确保您和其他人知道该值应该具有的数据范围的一种方式。|62c5b|现在，正如我所说的，通过执行以下操作，您可以有效地将32个布尔值存储到一个整数中：|5ahle|int+many_booleans+=+-1;+//All+are+true;
int+many_booleans+=+0;+//All+are+false;
int+many_booleans+=+1+%7C+2+%7C+8;+//Bits+1,+2,+and+4+are+true+the+rest+are+false;|code-block|syntax|javascript|5ueq2|因此，现在短整型由16位组成，因此16+%2B+16+=+32非常适合32位整数。所以每个int值可以由两个短值组成。|2dip4|int+two_shorts+=+value+%7C+(value2+<<+16);|7bph6|所以上面的值是介于-32768和32767之间的值，或者是一个无符号值0-+65535。假设值等于-1，那么作为无符号值，它是65535。这意味着位1到16是打开的，但在实际执行数学运算时，请考虑范围0-+15。|8d9of|所以我们需要激活17+-+32位。因此，我们必须从大于15位的内容开始。所以我们从16位开始。因此，将value2乘以65536，这就是"<<+16“所做的事情。我们现在假设value2等于3，它将是OR'd+3x65536+=+196608。所以我们的整数值等于262143。|d9kko|int+assumed_value+=+262143;|1ohdb|因此，假设我们想要检索两个16位整数值。|cqsot|short+value1+=+(short)(assumed_value+&+0xFFFF);+//-1
short+value2+=+(short)(assumed_value+>>+16);+//=3|e75kf|基本上，按位运算符是2的幂，这就是它们的全部。不要只看0和1，我发这篇文章主要是为了帮助那些在寻找无符号数组、短数组甚至可能的多维数组时遇到这种情况的人。如果有任何打字错误，我很抱歉，很快就把它写出来。^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|17|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|18|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|19|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|1A|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|1B|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|1C|9|@]|A|@]|B|$]]|$2|M|4|N|6|O|8|1D|9|@]|A|@]|B|$P|Q]]|$2|R|4|S|6|7|8|1E|9|@]|A|@]|B|$]]|$2|T|4|U|6|O|8|1F|9|@]|A|@]|B|$P|Q]]|$2|V|4|W|6|7|8|1G|9|@]|A|@]|B|$]]|$2|X|4|Y|6|7|8|1H|9|@]|A|@]|B|$]]|$2|Z|4|10|6|O|8|1I|9|@]|A|@]|B|$P|Q]]|$2|11|4|12|6|7|8|1J|9|@]|A|@]|B|$]]|$2|13|4|14|6|O|8|1K|9|@]|A|@]|B|$P|Q]]|$2|15|4|16|6|7|8|1L|9|@]|A|@]|B|$]]]]

He said he wanted to create a multi-dimensional short array. Yet no one suggested bitwise operators? From what I read you want to use 16 bit integers over 32 bit integers to save memory? 

So firstly to begin 10,000 x 10,000 short values is 1,600,000,000 bits, 200,000,000 bytes, 200,000 kilobytes, 200 megabytes.

If you need something with 200MB of memory consumption you may want to redesign this idea. I also do not believe that will even compile let alone run. You should never initialize large arrays like that if anything utilize 2 features called On Demand Loading and Data Caching. Essentially on demand loading refers to the idea to only load data as it is needed. Then data caching does the same thing, but utilizes a custom frame work for delete old memory and adding new information as needed. This one is tricky to have GOOD speed performance. There are other things you can do, but those two are my favorite when done right.

Alright back to what I was saying about bitwise operators.

So a 32bit integer or in Java "int". You can store what are called "bits" to this so let's say you had 32 Boolean values which in Java all values take up 32 bits (except long) or for arrays they take up 8 for byte, 16 for short, and 32 for int. So unless you have arrays you don't get any memory benefits from using a byte or short. This does not mean you shouldn't use it as its a way to ensure you and others know the data range this value should have.

Now as I was saying you could effectively store 32 Booleans into a single integer by doing the following:

<pre><code>int many_booleans = -1; //All are true;
int many_booleans = 0; //All are false;
int many_booleans = 1 | 2 | 8; //Bits 1, 2, and 4 are true the rest are false;
</code></pre>

So now a short consists of 16 bits so 16 + 16 = 32 which fits PERFECTLY within a 32bit integer. So every int value can consist of 2 short values.

<pre><code>int two_shorts = value | (value2 &lt;&lt; 16);
</code></pre>

So what the above is doing is value is something between -32768 and 32767 or as an unsigned value 0 - 65535. So let's say value equaled -1 so as an unsigned value it was 65535. This would mean bits 1 through 16 are turned on, but when actually performing the math consider the range 0 - 15. 

So we need to then activate bits 17 - 32. So we must begin at something larger than 15 bits. So we begin at 16 bits. So by taking value2 and multiplying it by 65536 which is what "&lt;&lt; 16" does. We now would have let's say value2 equaled 3 it would be OR'd 3x65536 = 196608. So our integer value would equal 262143.

<pre><code>int assumed_value = 262143;
</code></pre>

so let's say we want to retrieve the two 16bit integer values.

<pre><code>short value1 = (short)(assumed_value &amp; 0xFFFF); //-1
short value2 = (short)(assumed_value &gt;&gt; 16); //=3
</code></pre>

Also basically think of bitwise operators as powers of 2. That is all they really are. Never look at it terms of 0's and 1's. I mostly posted this to assist anyone who may come across this searching for unsigned short or even possibly multi-dimensional arrays. If there are any typo's I apologize quickly wrote this up.

entityMap|blocks|key|6e8l6|text|来自DataInputStream.java|type|unstyled|depth|inlineStyleRanges|entityRanges|data|8c14p|public+final+int+readUnsignedShort()+throws+IOException+{
++++int+ch1+=+in.read();
++++int+ch2+=+in.read();
++++if+((ch1+%7C+ch2)+<+0)
++++++++throw+new+EOFException();
++++return+(ch1+<<+8)+%2B+(ch2+<<+0);
}|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

From DataInputStream.java

<pre><code>public final int readUnsignedShort() throws IOException {
 int ch1 = in.read();
 int ch2 = in.read();
 if ((ch1 | ch2) &lt; 0)
 throw new EOFException();
 return (ch1 &lt;&lt; 8) + (ch2 &lt;&lt; 0);
}
</code></pre>

entityMap|blocks|key|171qj|text|在Java+SE+8和更高版本中，您可以使用int数据类型来表示无符号32位整数，该整数的最小值为0，最大值为232-1。然而，这只适用于int和long，而不适用于short+:(|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

<a href="http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html" rel="nofollow">"In Java SE 8 and later, you can use the int data type to represent an unsigned 32-bit integer, which has a minimum value of 0 and a maximum value of 232-1."</a> However this only applies to int and long but not short :(

entityMap|blocks|key|7lbmh|text|如果可以选择使用第三方库，则可以jOOU(从jOOQ)，它为Java中的无符号整数提供了包装器类型。这与原始类型(以及字节码)对无符号类型的支持并不完全相同，但也许对于您的用例来说，它仍然足够好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1sarv|import+static+org.joou.Unsigned.*;

//+and+then...
UShort+s+=+ushort(1);|code-block|syntax|javascript|8fuf2|(免责声明:我为这些库背后的公司工作)^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|K|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$]]]]

If using a third party library is an option, there is <a href="https://github.com/jOOQ/jOOU" rel="nofollow noreferrer">jOOU</a> (a spin off library from <a href="http://www.jooq.org" rel="nofollow noreferrer">jOOQ</a>), which offers wrapper types for unsigned integer numbers in Java. That's not exactly the same thing as having primitive type (and thus byte code) support for unsigned types, but perhaps it's still good enough for your use-case.

<pre><code>import static org.joou.Unsigned.*;

// and then...
UShort s = ushort(1);
</code></pre>

(Disclaimer: I work for the company behind these libraries)

entityMap|blocks|key|2oghc|text|不，确实没有这样的方法，java是一种高级语言。这就是Java没有任何无符号数据类型的原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

No, really there is no such method, java is a high-level language. That's why Java doesn't have any unsigned data types.

entityMap|blocks|key|5imki|text|//вот+метод+для+получения+аналога+unsigned+short
++++public+static+int+getShortU(byte+[]+arr,+int+i+)++throws+Exception+
++++{
+++++++try
+++++++{
+++++++++++byte+[]+b+=+new+byte[2];+
+++++++++++b[1]+=+arr[i];
+++++++++++b[0]+=+arr[i%2B1];
+++++++++++int+k+=+ByteBuffer.wrap(b).getShort();
++++++++++++//if+this:+
+++++++++++//int+k+=+((int)b[0]+<<+8)+%2B+((int)b[1]+<<+0);+
+++++++++++//65536+=+2**16
+++++++++++if+(+k+<0)+k+=+65536%2B+k;+
++++++++return+k;
++++++}++
+++++++catch(Throwable+t)
++++++{
++++++++++throw++new+Exception+("from+getShort:+i="+%2B+i);
++++++}
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript^0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$C|D]]]]

<pre><code>//вот метод для получения аналога unsigned short
 public static int getShortU(byte [] arr, int i ) throws Exception 
 {
 try
 {
 byte [] b = new byte[2]; 
 b[1] = arr[i];
 b[0] = arr[i+1];
 int k = ByteBuffer.wrap(b).getShort();
 //if this: 
 //int k = ((int)b[0] &lt;&lt; 8) + ((int)b[1] &lt;&lt; 0); 
 //65536 = 2**16
 if ( k &lt;0) k = 65536+ k; 
 return k;
 } 
 catch(Throwable t)
 {
 throw new Exception ("from getShort: i=" + i);
 }
 }
</code></pre>

entityMap|blocks|key|cb5qj|text|不可能将类型声明为unsigned+short，但在我的例子中，我需要获取无符号数字才能在for循环中使用它。有一种方法toUnsignedInt在班上Short返回“通过无符号转换转换为int的参数"：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|aagpp|short+signedValue+=+-4767;
System.out.println(signedValue+);+//+prints+-4767

int+unsignedValue+=+Short.toUnsignedInt(signedValue);
System.out.println(unsingedValue);+//+prints+60769|code-block|syntax|javascript|7jbp4|Integer和Long也有类似的方法：|6er6a|Integer.toUnsignedLong|5n244|Long.toUnsignedString：在这种情况下，它以String因为没有更大的数值类型。^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|N|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|O|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|P|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|Q|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|R|9|@]|A|@]|B|$]]]]

It is not possible to declare a type unsigned short, but in my case, I needed to get the unsigned number to use it in a for loop. There is the method <code>toUnsignedInt</code> in the class <code>Short</code> that returns &quot;the argument converted to int by an unsigned conversion&quot;:
<pre><code>short signedValue = -4767;
System.out.println(signedValue ); // prints -4767

int unsignedValue = Short.toUnsignedInt(signedValue);
System.out.println(unsingedValue); // prints 60769

</code></pre>
Similar methods exist for Integer and Long:
<code>Integer.toUnsignedLong</code>
<code>Long.toUnsignedString</code> : In this case it ends up in a <code>String</code> because there isn't a bigger numeric type.

How can I declare an <code>unsigned short</code> value in Java?

Unsigned short in Java

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

 如何声明unsigned shortJava中的值？

问Java中的Unsigned short
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的Unsigned shortEN