Java中的无符号短

Unsigned short in Java

提问by maiky

How can I declare an unsigned shortvalue in Java?

如何unsigned short在 Java 中声明一个值？

采纳答案by Jon Skeet

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

你不能，真的。Java 没有任何无符号数据类型，除了char.

Admittedly you coulduse char- it's a 16-bit unsigned type - but that would be horrible in my view, as charis clearly meant to be for text: when code uses char, 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.

诚然，您可以使用char- 它是一个 16 位无符号类型 - 但在我看来这会很糟糕，因为char这显然是用于文本：当代码使用 时char，我希望它将它用于表示文本的 UTF-16 代码单元这对程序很有趣，而不是与文本无关的任意无符号 16 位整数。

回答by paweloque

No such type in java

java中没有这种类型

回答by CBFraser

Java does not have unsigned types. What do you need it for?

Java 没有无符号类型。你需要它做什么？

Java does have the 'byte' data type, however.

但是，Java 确实具有“字节”数据类型。

回答by Jé Queue

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

是的，如果您想在代码与位操作中使用该值，则没有这样的事情。

回答by TofuBeer

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.

您可以使用 char，因为它是一个无符号的 16 位值（尽管从技术上讲它是一个 unicode 字符，因此将来可能会更改为 24 位值）……另一种选择是使用 int 并确保它在范围内。

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

不要使用字符 - 使用 int :-)

And here is a link discussing Java and the lack of unsigned.

这是一个讨论 Java 和缺少 unsigned的链接。

回答by Carl Smotricz

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

您可以自己编写一个ShortUnsigned类并为您想要的那些运算符定义方法。您将无法重载+and-和它们上的其他内容，也无法与其他原始或数字对象类型进行隐式类型转换，唉。

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

像其他一些回答者一样，我想知道为什么您迫切需要 unsigned short 没有其他数据类型可以填充。

回答by starblue

If you really need a value with exactly 16 bits:

如果您确实需要一个正好为 16 位的值：

Solution 1:Use the available signed short and stop worrying about the sign, unless you need to do comparison (<, <=, >, >=) or division (/, %, >>) operations. See this answerfor how to handle signed numbers as if they were unsigned.

解决方案1：使用可用的signed short 并且不用担心符号，除非您需要进行比较（<、<=、>、>=）或除法（/、%、>>）操作。请参阅此答案以了解如何处理有符号数字，就好像它们是无符号的一样。

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

解决方案 2（解决方案 1 不适用）：使用 int 的低 16 位，并在必要时使用 & 0xffff 删除高位。

回答by joel garringer

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.

这是一个非常陈旧的线程，但为了任何人的利益。char 是数字类型。它支持所有的数学运算符、位运算等。它是一个无符号的 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.

我们处理由定制嵌入式硬件记录的信号，因此我们处理来自 A-D 的大量无符号 16。多年来，我们一直在各地使用字符，从未遇到任何问题。

回答by Patrick Ireland

Simple program to show why unsigned numbers are needed:

显示为什么需要无符号数的简单程序：

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>>1, test>>2, test>>3, test>>4);
    }
}

results:

结果：

0xC568 0xFFFFE2B4 0xFFFFF15A 0xFFFFF8AD 0xFFFFFC56

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.

JAVA 进行算术移位，因为操作数是有符号的，但是，在某些情况下，逻辑移位是合适的，但 JAVA（特别是 Sun）认为没有必要，因为他们的短视对我们来说太糟糕了。Shift、And、Or 和 Exclusive Or 是有限的工具，当您拥有的所有数字都签名更长的数字时。当连接到使用 16 位或更多位的“真实”计算机位的硬件设备时，这是一个特殊的问题。"char" 不能保证工作（现在是两个字节宽），但在一些基于东方 gif 的语言中，例如中文、韩语和日语，至少需要 3 个字节。我不熟悉 Sandscript 风格语言的需求数量。字节数不取决于程序员，而是取决于 JAVA 标准委员会。因此，将 char 设为 16 位存在下游风险。为了安全地实现 unsigned short JAVA，作为特殊类是基于上述歧义的最佳解决方案。该类的缺点是无法重载这个特殊类的数学运算。该线程的许多贡献者准确地指出了这些问题，但我的贡献是一个有效的代码示例以及我在 Linux 下使用 C++ 使用 3 字节 gif 语言的经验。

回答by Jeremy Trifilo

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?

他说他想创建一个多维短数组。然而没有人建议按位运算符？从我读到的你想使用 16 位整数而不是 32 位整数来节省内存？

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.

所以首先开始 10,000 x 10,000 短值是 1,600,000,000 位、200,000,000 字节、200,000 KB、200 兆字节。

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.

如果您需要消耗 200MB 内存的东西，您可能需要重新设计这个想法。我也不相信连编译都不会，更别说运行了。如果任何东西都利用了称为按需加载和数据缓存的 2 个功能，则永远不应该像这样初始化大型数组。本质上，按需加载是指仅在需要时加载数据的想法。然后数据缓存做同样的事情，但利用自定义框架删除旧内存并根据需要添加新信息。这个很难有良好的速度性能。你还可以做其他事情，但如果做得好，这两个是我最喜欢的。

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.

所以是 32 位整数或 Java 中的“int”。您可以将所谓的“位”存储到这里，假设您有 32 个布尔值，在 Java 中，所有值都占用 32 位（长除外），或者对于数组，它们占用 8 个字节，16 个短字节和 32 个整数. 因此，除非您有数组，否则使用字节或短字节不会获得任何内存优势。这并不意味着您不应该使用它来确保您和其他人知道该值应具有的数据范围。

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

现在正如我所说，您可以通过执行以下操作有效地将 32 个布尔值存储为一个整数：

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;

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.

所以现在一个 short 由 16 位组成，所以 16 + 16 = 32 完全适合 32 位整数。所以每个 int 值都可以由 2 个短值组成。

int two_shorts = value | (value2 << 16);

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.

所以上面所做的是值介于 -32768 和 32767 之间，或者作为无符号值 0 - 65535。所以假设值等于 -1，因此作为无符号值它是 65535。这意味着第 1 位到第 16 位被打开，但在实际进行数学运算时，请考虑范围 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 "<< 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.

所以我们需要然后激活位 17 - 32。所以我们必须从大于 15 位的东西开始。所以我们从 16 位开始。因此，通过取 value2 并将其乘以 65536，这就是 "<< 16" 所做的。我们现在假设 value2 等于 3，它会被 OR'd 3x65536 = 196608。所以我们的整数值将等于 262143。

int assumed_value = 262143;

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

所以假设我们要检索两个 16 位整数值。

short value1 = (short)(assumed_value & 0xFFFF); //-1
short value2 = (short)(assumed_value >> 16); //=3

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.

也基本上将按位运算符视为 2 的幂。这就是它们的全部内容。永远不要看 0 和 1 的术语。我发布这篇文章主要是为了帮助任何可能遇到这种搜索无符号短数组甚至可能是多维数组的人。如果有任何错字，我很快就写下了道歉。