blocks|key|207014|text|根据this+document的说法，所有的整数都是有符号的，并以java的二进制补码格式存储。不能确定它的可靠性。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|207015|entityMap|0|LINK|mutability|MUTABLE|url|http://duke.csc.villanova.edu/jss/webBonuses/primitiveStorage/primitiveStorage.pdf^0|2|D|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]]]]

According to <a href="http://duke.csc.villanova.edu/jss/webBonuses/primitiveStorage/primitiveStorage.pdf" rel="nofollow">this document</a>, all integers are signed and stored in two's complement format for java. Not certain of its reliability..

blocks|key|209155|text|Oracle提供了一些关于Java+Datatypes的文档，您可能会感兴趣。具体地说：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|209156|209157|+int:+int数据类型是32位有符号二进制补码整数。它的最小值为-2,147,483,648，最大值为2,147,483,647+(含)。|blockquote|209158|209159|209160|顺便说一句，short也存储为二的补码。|209161|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html^0|I|9|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|-4|5|6|7|X|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|Y|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]]]

Oracle provides some documentation regarding Java <a href="http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html" rel="noreferrer">Datatypes</a> that you may find interesting. Specifically:

<blockquote>
 int: The int data type is a 32-bit signed two's complement integer. It has a minimum value of -2,147,483,648 and a maximum value of 2,147,483,647 (inclusive).
</blockquote>

Btw, short is also stored as two's complement.

blocks|key|3057067|text|我已经运行了下面的程序来了解它|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3057068|public+class+Negative+{
++++public+static+void+main(String[]+args)+{
++++++++int+i+=10;
++++++++int+j+=+-10;

++++++++System.out.println(Integer.toBinaryString(i));
++++++++System.out.println(Integer.toBinaryString(j));
++++}
}|code-block|syntax|javascript|3057069|输出为|3057070|1010
11111111111111111111111111110110|3057071|从输出来看，它似乎一直在使用2的补码。|3057072|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I have ran the following program to know it 

<pre><code>public class Negative {
 public static void main(String[] args) {
 int i =10;
 int j = -10;

 System.out.println(Integer.toBinaryString(i));
 System.out.println(Integer.toBinaryString(j));
 }
}
</code></pre>

Output is 

<pre><code>1010
11111111111111111111111111110110
</code></pre>

From the output it seems that it has been using two's complement.

blocks|key|2844057|text|让我们首先总结一下Java基本数据类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2844058|+Byte+：Byte数据类型是一个8位有符号二进制补码整数。|offset|length|style|BOLD|2844059|+Short+：Short数据类型是16位有符号的二进制补码整数。|2844060|+Int+:+Int数据类型是32位有符号二进制补码整数。|2844061|+Long+:+Long数据类型是64位有符号二进制补码整数。|2844062|浮点：浮点数据类型是单精度32位IEEE754浮点。|2844063|+double+：double+data+type是一种双精度64位IEEE754浮点。|2844064|布尔值：布尔值数据类型表示一位信息。|2844065|Unicode+char+:Unicode+char数据类型是一个单16位字符。|2844066|Source|2844067|2的补码|2844068|wiki中的一个很好的例子是，通过注意256+=+255+%2B+1，并且(255−x)是x的1的补码，实现了与2的补码的关系|2844069|0000+0111=7的二进制补码是1111+1001=+-7|2844070|它的工作方式是MSB(最高有效位)接收负值，因此在上面的情况下|2844071|2844072|+-7+=+1001=+-8+%2B+0%2B+0%2B+1|blockquote|2844073|2844074|2844075|正整数通常存储为简单二进制数(1表示1，10表示2，11表示3，依此类推)。|2844076|负整数存储为2的绝对值的补码。当使用这种记法时，两个正数的补码就是负数。|2844077|2844078|因为这个答案我得到了几分，所以我决定给它添加更多的信息。|2844079|更详细的答案：|2844080|在其他方法中，有四种主要方法来表示二进制中的正数和负数，即：|2844081|签名Magnitude|2844082|One's+Complement|unordered-list-item|2844083|
|2844084|Two's+Complement|2844085|2844086|Bias|2844087|
的|2844088|ordered-list-item|2844089|2844090|1.带符号幅度|2844091|使用最高有效位表示符号，其余位表示绝对值。其中表示正数，1表示负数，例如：|2844092|1011+=+-3
0011+=+%2B3|code-block|syntax|javascript|2844093|这种表示更简单。但是，您不能以添加十进制数的相同方式添加二进制数，这使得在硬件级别上实现变得更加困难。此外，该方法使用两种二进制模式来表示0，即-0+(1000)和%2B0+(0000)。|2844094|2.一个人的互补|2844095|在这个表示中，我们反转给定数字的所有位，以找出其互补性。例如：|2844096|010+=+2,+so+-2+=+101+(inverting+all+bits).|2844097|这种表示的问题在于仍然存在两个位模式来表示0，负0+(1111)和正0+(0000)|2844098|3.二进制补码|2844099|为了找到一个数字的负数，在这个表示中，我们反转所有的位，然后添加一位。添加一个比特解决了具有表示0的两个比特模式的问题。在此表示法中，我们只有一个用于0+(0000)的模式。|2844100|例如，我们想要找出使用4位的4(十进制)的二进制负数表示。首先，我们将4转换为二进制：|2844101|4+=+0100|2844102|然后我们反转所有的比特|2844103|0100+->+1011|2844104|最后，我们添加一位|2844105|1011+%2B+1+=+1100.|2844106|因此，如果我们使用具有4位的二进制补码表示法，1100相当于十进制中的-4。|2844107|找到互补的一种更快的方法是将第一位固定为值1，并反转剩余的位。在上面的示例中，它类似于：|2844108|0100+->+1100
%5E%5E+
%7C%7C-(fixing+this+value)
%7C--(inverting+this+one)|2844109|二的补码表示法，除了0只有一个表示法外，它还以与十进制相同的方式将两个二进制值相加，即具有不同符号的偶数。尽管如此，还是有必要检查溢出情况。|2844110|4.偏置|2844111|此表示法用于表示浮点的IEEE754规范中的指数。它的优点是，所有位都为零的二进制值表示最小值。并且所有位都为1的二进制值表示最大值。顾名思义，该值以带有偏置的n位(通常为2%5E(n-1)或2%5E(n-1)-1)的二进制形式进行编码(正或负)。|2844112|因此，如果我们使用8位，十进制值1用二进制表示，偏置为2%5E(n-1)，值为：|2844113|%2B1+%2B+bias+=+%2B1+%2B+2%5E(8-1)+=+1+%2B+128+=+129
converting+to+binary
1000+0001|2844114|entityMap|0|LINK|mutability|MUTABLE|url|http://www.tutorialspoint.com/java/java_basic_datatypes.htm|1|http://en.wikipedia.org/wiki/Two%2527s_complement|2|https://stackoverflow.com/questions/794062/is-twos-complement-notation-of-a-positive-number-the-same-number^0|0|0|6|N|7|0|0|7|P|7|0|0|6|L|7|0|0|7|N|7|0|0|3|D|C|0|0|8|V|C|0|0|4|D|4|0|X|7|0|0|6|0|6|0|0|0|4|0|0|1P|0|4|1|0|0|V|0|0|V|0|0|0|O|0|0|0|0|12|0|0|10|0|0|6|0|6|2|0|0|S|0|0|7|0|0|U|0|0|B|0|0|G|0|0|0|G|0|0|0|4|0|1|1|0|0|0|0|7|0|0|11|0|0|0|2K|0|0|8|0|0|V|0|0|0|16|0|0|7|0|0|2F|0|0|17|0|0|0|B|0|0|0|9|0|0|0|12|0|0|18|0|0|0|1Y|0|0|4|0|0|3C|0|0|12|0|0^^$0|@$1|2|3|4|5|6|7|3U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|3V|8|@$D|3W|E|3X|F|G]|$D|3Y|E|3Z|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|40|8|@$D|41|E|42|F|G]|$D|43|E|44|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|45|8|@$D|46|E|47|F|G]|$D|48|E|49|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|4A|8|@$D|4B|E|4C|F|G]|$D|4D|E|4E|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|4F|8|@$D|4G|E|4H|F|G]|$D|4I|E|4J|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|4K|8|@$D|4L|E|4M|F|G]|$D|4N|E|4O|F|G]]|9|@]|A|$]]|$1|R|3|S|5|6|7|4P|8|@$D|4Q|E|4R|F|G]|$D|4S|E|4T|F|G]]|9|@]|A|$]]|$1|T|3|U|5|6|7|4U|8|@$D|4V|E|4W|F|G]]|9|@]|A|$]]|$1|V|3|W|5|6|7|4X|8|@$D|4Y|E|4Z|F|G]]|9|@$D|50|E|51|1|52]]|A|$]]|$1|X|3|Y|5|6|7|53|8|@$D|54|E|55|F|G]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|56|8|@$D|57|E|58|F|G]]|9|@$D|59|E|5A|1|5B]]|A|$]]|$1|11|3|12|5|6|7|5C|8|@$D|5D|E|5E|F|G]]|9|@]|A|$]]|$1|13|3|14|5|6|7|5F|8|@$D|5G|E|5H|F|G]]|9|@]|A|$]]|$1|15|3|-4|5|6|7|5I|8|@]|9|@]|A|$]]|$1|16|3|17|5|18|7|5J|8|@$D|5K|E|5L|F|G]]|9|@]|A|$]]|$1|19|3|-4|5|6|7|5M|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|5N|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|5O|8|@$D|5P|E|5Q|F|G]]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|5R|8|@$D|5S|E|5T|F|G]]|9|@]|A|$]]|$1|1F|3|W|5|6|7|5U|8|@$D|5V|E|5W|F|G]]|9|@$D|5X|E|5Y|1|5Z]]|A|$]]|$1|1G|3|1H|5|6|7|60|8|@$D|61|E|62|F|G]]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|63|8|@$D|64|E|65|F|G]]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|66|8|@$D|67|E|68|F|G]]|9|@]|A|$]]|$1|1M|3|1N|5|6|7|69|8|@$D|6A|E|6B|F|G]]|9|@]|A|$]]|$1|1O|3|1P|5|1Q|7|6C|8|@$D|6D|E|6E|F|G]]|9|@]|A|$]]|$1|1R|3|1S|5|6|7|6F|8|@]|9|@]|A|$]]|$1|1T|3|1U|5|1Q|7|6G|8|@$D|6H|E|6I|F|G]]|9|@]|A|$]]|$1|1V|3|1S|5|6|7|6J|8|@]|9|@]|A|$]]|$1|1W|3|1X|5|1Q|7|6K|8|@$D|6L|E|6M|F|G]]|9|@]|A|$]]|$1|1Y|3|1Z|5|6|7|6N|8|@$D|6O|E|6P|F|G]]|9|@]|A|$]]|$1|20|3|-4|5|21|7|6Q|8|@]|9|@]|A|$]]|$1|22|3|-4|5|6|7|6R|8|@]|9|@]|A|$]]|$1|23|3|24|5|6|7|6S|8|@$D|6T|E|6U|F|G]]|9|@]|A|$]]|$1|25|3|26|5|6|7|6V|8|@$D|6W|E|6X|F|G]]|9|@]|A|$]]|$1|27|3|28|5|29|7|6Y|8|@]|9|@]|A|$2A|2B]]|$1|2C|3|2D|5|6|7|6Z|8|@$D|70|E|71|F|G]]|9|@]|A|$]]|$1|2E|3|2F|5|6|7|72|8|@$D|73|E|74|F|G]]|9|@]|A|$]]|$1|2G|3|2H|5|6|7|75|8|@$D|76|E|77|F|G]]|9|@]|A|$]]|$1|2I|3|2J|5|29|7|78|8|@]|9|@]|A|$2A|2B]]|$1|2K|3|2L|5|6|7|79|8|@$D|7A|E|7B|F|G]]|9|@]|A|$]]|$1|2M|3|2N|5|6|7|7C|8|@$D|7D|E|7E|F|G]]|9|@]|A|$]]|$1|2O|3|2P|5|6|7|7F|8|@$D|7G|E|7H|F|G]]|9|@]|A|$]]|$1|2Q|3|2R|5|6|7|7I|8|@$D|7J|E|7K|F|G]]|9|@]|A|$]]|$1|2S|3|2T|5|29|7|7L|8|@]|9|@]|A|$2A|2B]]|$1|2U|3|2V|5|6|7|7M|8|@$D|7N|E|7O|F|G]]|9|@]|A|$]]|$1|2W|3|2X|5|29|7|7P|8|@]|9|@]|A|$2A|2B]]|$1|2Y|3|2Z|5|6|7|7Q|8|@$D|7R|E|7S|F|G]]|9|@]|A|$]]|$1|30|3|31|5|29|7|7T|8|@]|9|@]|A|$2A|2B]]|$1|32|3|33|5|6|7|7U|8|@$D|7V|E|7W|F|G]]|9|@]|A|$]]|$1|34|3|35|5|6|7|7X|8|@$D|7Y|E|7Z|F|G]]|9|@]|A|$]]|$1|36|3|37|5|29|7|80|8|@]|9|@]|A|$2A|2B]]|$1|38|3|39|5|6|7|81|8|@$D|82|E|83|F|G]]|9|@]|A|$]]|$1|3A|3|3B|5|6|7|84|8|@$D|85|E|86|F|G]]|9|@]|A|$]]|$1|3C|3|3D|5|6|7|87|8|@$D|88|E|89|F|G]]|9|@]|A|$]]|$1|3E|3|3F|5|6|7|8A|8|@$D|8B|E|8C|F|G]]|9|@]|A|$]]|$1|3G|3|3H|5|29|7|8D|8|@]|9|@]|A|$2A|2B]]|$1|3I|3|-4|5|6|7|8E|8|@]|9|@]|A|$]]]|3J|$3K|$5|3L|3M|3N|A|$3O|3P]]|3Q|$5|3L|3M|3N|A|$3O|3R]]|3S|$5|3L|3M|3N|A|$3O|3T]]]]

Let's start by summarizing Java primitive data types:
byte: Byte data type is an 8-bit signed two's complement integer.
Short: Short data type is a 16-bit signed two's complement integer.
int: Int data type is a 32-bit signed two's complement integer.
long: Long data type is a 64-bit signed two's complement integer.
float: Float data type is a single-precision 32-bit IEEE 754 floating point.
double: double data type is a double-precision 64-bit IEEE 754 floating point.
boolean: boolean data type represents one bit of information.
char: char data type is a single 16-bit Unicode character.
<a href="http://www.tutorialspoint.com/java/java_basic_datatypes.htm" rel="nofollow noreferrer">Source</a>
Two's complement
&quot;The good example is from <a href="http://en.wikipedia.org/wiki/Two%27s_complement" rel="nofollow noreferrer">wiki</a> that the relationship to two's complement is realized by noting that 256 = 255 + 1, and (255 − x) is the ones' complement of x
0000 0111=7 two's complement is 1111 1001= -7
the way it works is the MSB(the most significant bit) receives a negative value so in the case above
<blockquote>
-7 = 1001= -8 + 0+ 0+ 1
</blockquote>
Positive integers are generally stored as simple binary numbers (1 is 1, 10 is 2, 11 is 3, and so on).
Negative integers are stored as the two's complement of their absolute value. The two's complement of a positive number is when using this notation a negative number.
<a href="https://stackoverflow.com/questions/794062/is-twos-complement-notation-of-a-positive-number-the-same-number">Source</a>
Since I received a few points for this answer, I decided to add more information to it.
<h2>A more detailed answer:</h2>
Among others there are four main approaches to represent positive and negative numbers in binary, namely:
<ol>
<li>Signed Magnitude</li>
<li>One's Complement</li>
<li>Two's Complement</li>
<li>Bias</li>
</ol>
1. Signed Magnitude
Uses the most significant bit to represent the sign, the remaining bits are used to represent the absolute value. Where 0 represents a positive number and 1 represents a negative number, example:
<pre><code>1011 = -3
0011 = +3
</code></pre>
This representation is simpler. However, you cannot add binary numbers in the same way that you add decimal numbers, making it harder to be implemented at the hardware level. Moreover, this approach uses two binary patterns to represent the 0, -0 (1000) and +0 (0000).
2. One's Complement
In this representation, we invert all the bits of a given number to find out its complementary. For example:
<pre><code>010 = 2, so -2 = 101 (inverting all bits).
</code></pre>
The problem with this representation is that there still exist two bits patterns to represent the 0, negative 0 (1111) and positive 0 (0000)
3. Two's Complement
To find the negative of a number, in this representation, we invert all the bits and then add one bit. Adding one bit solves the problem of having two bits patterns representing 0. In this representation, we only have one pattern for
0 (0000).
For example, we want to find the binary negative representation of 4 (decimal) using 4 bits. First, we convert 4 to binary:
<pre><code>4 = 0100
</code></pre>
then we invert all the bits
<pre><code>0100 -&gt; 1011
</code></pre>
finally, we add one bit
<pre><code>1011 + 1 = 1100.
</code></pre>
So 1100 is equivalent to -4 in decimal if we are using a Two's Complement binary representation with 4 bits.
A faster way to find the complementary is by fixing the first bit that as value 1 and inverting the remaining bits. In the above example it would be something like:
<pre><code>0100 -&gt; 1100
^^ 
||-(fixing this value)
|--(inverting this one)
</code></pre>
Two's Complement representation, besides having only one representation for 0, it also adds two binary values in the same way that in decimal, even numbers with different signs. Nevertheless, it is necessary to check for overflow cases.
4. Bias
This representation is used to represent the exponent in the IEEE 754 norm for floating points. It has the advantage that the binary value with all bits to zero represents the smallest value. And the binary value with all bits to 1 represents the biggest value. As the name indicates, the value is encoded (positive or negative) in binary with n bits with a bias (normally 2^(n-1) or 2^(n-1)-1).
So if we are using 8 bits, the value 1 in decimal is represented in binary using a bias of 2^(n-1), by the value:
<pre><code>+1 + bias = +1 + 2^(8-1) = 1 + 128 = 129
converting to binary
1000 0001
</code></pre>

blocks|key|2844144|text|Java整数是32位的，并且总是有符号的。这意味着，最高有效位(MSB)用作符号位。由int表示的整数只不过是位的加权和。按如下方式指定权重：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2844145|Bit#++++Weight
31++++++-2%5E31
30+++++++2%5E30
29+++++++2%5E29
...++++++...
2++++++++2%5E2
1++++++++2%5E1
0++++++++2%5E0|code-block|syntax|javascript|2844146|请注意，MSB的权重为负数(实际上可能是最大的负数)，因此此位为on时，整数(加权和)为负数。|2844147|让我们用4位数字来模拟它：|2844148|Binary++++Weighted+sum++++++++++++Integer+value
0000+++++++0+%2B+0+%2B+0+%2B+0+++++++++++0
0001+++++++0+%2B+0+%2B+0+%2B+2%5E0+++++++++1
0010+++++++0+%2B+0+%2B+2%5E1+%2B+0+++++++++2
0011+++++++0+%2B+0+%2B+2%5E1+%2B+2%5E0+++++++3
0100+++++++0+%2B+2%5E2+%2B+0+%2B+0+++++++++4
0101+++++++0+%2B+2%5E2+%2B+0+%2B+2%5E0+++++++5
0110+++++++0+%2B+2%5E2+%2B+2%5E1+%2B+0+++++++6
0111+++++++0+%2B+2%5E2+%2B+2%5E1+%2B+2%5E0+++++7+->+the+most+positive+value
1000++++++-2%5E3+%2B+0+%2B+0+%2B+0++++++++-8+->+the+most+negative+value
1001++++++-2%5E3+%2B+0+%2B+0+%2B+2%5E0++++++-7
1010++++++-2%5E3+%2B+0+%2B+2%5E1+%2B+0++++++-6
1011++++++-2%5E3+%2B+0+%2B+2%5E1+%2B+2%5E0++++-5
1100++++++-2%5E3+%2B+2%5E2+%2B+0+%2B+0++++++-4
1101++++++-2%5E3+%2B+2%5E2+%2B+0+%2B+2%5E0++++-3
1110++++++-2%5E3+%2B+2%5E2+%2B+2%5E1+%2B+0++++-2
1111++++++-2%5E3+%2B+2%5E2+%2B+2%5E1+%2B+2%5E0++-1|2844149|因此，二进制补码并不是表示负整数的排他性方案，相反，我们可以说整数的二进制表示总是相同的，我们只是否定了最高有效位的权重。该位决定了整数的符号。|2844150|在C中，有一个关键字unsigned+(在java中不可用)，可以用来声明unsigned+int+x;。在无符号整数中，MSB的权重是正的(2%5E31)，而不是负的。在这种情况下，unsigned+int的范围是0到2%5E32+-+1，而int的范围是-2%5E31到2%5E31+-+1。|2844151|从另一个角度来看，如果您认为x的两个补码是~x+%2B+1+(而不是x加1)，那么可以这样解释：|2844152|对于任何x，~x只是x的逐位逆，所以无论x在哪里有1-bit，~x都会在那里有一个0-bit+(反之亦然)。所以，如果你把这些加起来，在加法中不会有进位，和只是一个整数，它的每一位都是1。|2844153|对于32位整数：|2844154|x+%2B+~x+=+1111+1111+1111+1111+1111+1111+1111+1111
x+%2B+~x+%2B+1+=+++1111+1111+1111+1111+1111+1111+1111+1111+%2B+1
+++++++++++=+1+0000+0000+0000+0000+0000+0000+0000+0000|2844155|最左边的1-bit将被简单地丢弃，因为它不适合32位(整数溢出)。所以,|2844156|x+%2B+~x+%2B+1+=+0
-x+=+~x+%2B+1|2844157|所以你可以看到负的x可以用~x+%2B+1来表示，我们称之为x的2的补码。|2844158|entityMap^0|17|3|0|0|0|0|0|0|A|8|11|F|1Z|4|2I|C|2Y|1|30|8|3A|3|3H|5|3N|8|0|E|1|L|6|0|4|1|6|2|A|1|K|1|P|1|V|2|15|1|2K|1|0|0|0|4|1|0|0|9|1|D|6|S|1|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1E|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1F|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1H|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|21|8|@$9|22|A|23|B|C]|$9|24|A|25|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|26|8|@$9|27|A|28|B|C]|$9|29|A|2A|B|C]|$9|2B|A|2C|B|C]|$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]|$9|2J|A|2K|B|C]|$9|2L|A|2M|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2N|8|@]|D|@]|E|$]]|$1|10|3|11|5|H|7|2O|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|2P|8|@$9|2Q|A|2R|B|C]]|D|@]|E|$]]|$1|14|3|15|5|H|7|2S|8|@]|D|@]|E|$I|J]]|$1|16|3|17|5|6|7|2T|8|@$9|2U|A|2V|B|C]|$9|2W|A|2X|B|C]|$9|2Y|A|2Z|B|C]]|D|@]|E|$]]|$1|18|3|-4|5|6|7|30|8|@]|D|@]|E|$]]]|19|$]]

Java integers are of 32 bits, and always signed. This means, the most significant bit (MSB) works as the sign bit. The integer represented by an <code>int</code> is nothing but the weighted sum of the bits. The weights are assigned as follows:

<pre><code>Bit# Weight
31 -2^31
30 2^30
29 2^29
... ...
2 2^2
1 2^1
0 2^0
</code></pre>

Note that the weight of the MSB is negative (the largest possible negative actually), so when this bit is on, the whole number (the weighted sum) becomes negative.

Let's simulate it with 4-bit numbers:

<pre><code>Binary Weighted sum Integer value
0000 0 + 0 + 0 + 0 0
0001 0 + 0 + 0 + 2^0 1
0010 0 + 0 + 2^1 + 0 2
0011 0 + 0 + 2^1 + 2^0 3
0100 0 + 2^2 + 0 + 0 4
0101 0 + 2^2 + 0 + 2^0 5
0110 0 + 2^2 + 2^1 + 0 6
0111 0 + 2^2 + 2^1 + 2^0 7 -&gt; the most positive value
1000 -2^3 + 0 + 0 + 0 -8 -&gt; the most negative value
1001 -2^3 + 0 + 0 + 2^0 -7
1010 -2^3 + 0 + 2^1 + 0 -6
1011 -2^3 + 0 + 2^1 + 2^0 -5
1100 -2^3 + 2^2 + 0 + 0 -4
1101 -2^3 + 2^2 + 0 + 2^0 -3
1110 -2^3 + 2^2 + 2^1 + 0 -2
1111 -2^3 + 2^2 + 2^1 + 2^0 -1
</code></pre>

So, the two's complement thing is not an exclusive scheme for representing negative integers, rather we can say that the binary representation of integers are always the same, we just negate the weight of the most significant bit. And that bit determines the sign of the integer.

In C, there is a keyword <code>unsigned</code> (not available in java), which can be used for declaring <code>unsigned int x;</code>. In the unsigned integers, the weight of the MSB is positive (<code>2^31</code>) rather than being negative. In that case the range of an <code>unsigned int</code> is <code>0</code> to <code>2^32 - 1</code>, while an <code>int</code> has range <code>-2^31</code> to <code>2^31 - 1</code>.

From another point of view, if you consider the two's complement of <code>x</code> as <code>~x + 1</code> (NOT x plus one), here's the explanation:

For any <code>x</code>, <code>~x</code> is just the bitwise inverse of <code>x</code>, so wherever <code>x</code> has a <code>1</code>-bit, <code>~x</code> will have a <code>0</code>-bit there (and vice versa). So, if you add these up, there will be no carry in the addition and the sum will be just an integer every bit of which is <code>1</code>.

For 32-bit integers:

<pre><code>x + ~x = 1111 1111 1111 1111 1111 1111 1111 1111
x + ~x + 1 = 1111 1111 1111 1111 1111 1111 1111 1111 + 1
 = 1 0000 0000 0000 0000 0000 0000 0000 0000
</code></pre>

The leftmost <code>1</code>-bit will simply be discarded, because it doesn't fit in 32-bits (integer overflow). So,

<pre><code>x + ~x + 1 = 0
-x = ~x + 1
</code></pre>

So you can see that the negative <code>x</code> can be represented by <code>~x + 1</code>, which we call the two's complement of <code>x</code>.

blocks|key|3057147|text|最高有效位(32)表示该数字是正数还是负数。如果它是0，则表示该数字为正，并且以其实际的二进制表示形式存储。但是如果它是1，这意味着这个数字是负数，并且存储在它的2的补码表示中。因此，当我们给第32位赋权重-2%5E32，同时从它的二进制表示中恢复整数值时，我们得到了实际的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3057148|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|$]]

The most significant bit (32nd) indicates that the number is positive or negative. If it is 0, it means the number is positive and it is stored in its actual binary representation. but if it is 1, it means the number is negative and is stored in its two's complement representation. So when we give weight -2^32 to the 32nd bit while restoring the integer value from its binary representation, We get the actual answer.

blocks|key|3057259|text|正数直接存储为二进制。对于负数，需要2的恭维。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3057260|例如：|3057261|15+:+00000000+00000000+00000000+00001111|3057262|-15:+11111111+11111111+11111111+11110001|3057263|这是有符号位的区别。|3057264|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|$]]

positive numbers are stored directly as binary. 2's compliment is required for negative numbers.

for example: 

15 : 00000000 00000000 00000000 00001111 
-15: 11111111 11111111 11111111 11110001

here is the difference in signed bit.

blocks|key|209326|text|感谢您，dreamcrash为您提供答案https://stackoverflow.com/a/13422442/1065835；在the+wiki+page上，他们给出了一个示例，帮助我了解如何找出正数的负数对应项的二进制表示。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|209327|209328|例如，使用1字节(=+2个半字节=8位)，十进制数5由下式表示|blockquote|209329|209330|00000+01012最高有效位为0，因此该模式表示非负值。要转换为二进制补码表示法中的−5，位被反转；0变为1，1变为0：|209331|11111010在这一点上，数字是十进制值−5的1的补码。为了获得二的补码，将1加到结果中，给出：|209332|结果是有符号二进制数，表示二进制补码形式的十进制值−5。最高有效位是1，所以表示的值是负数。|209333|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/13422442/1065835|1|http://en.wikipedia.org/wiki/Two%2527s_complement#Converting_to_two.27s_complement_representation^0|K|18|0|1U|D|1|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]|$A|12|B|13|1|14]]|C|$]]|$1|D|3|-4|5|6|7|15|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|16|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|17|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|18|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|19|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

Thank you, dreamcrash for the answer <a href="https://stackoverflow.com/a/13422442/1065835">https://stackoverflow.com/a/13422442/1065835</a>; on <a href="http://en.wikipedia.org/wiki/Two%27s_complement#Converting_to_two.27s_complement_representation" rel="nofollow noreferrer">the wiki page</a> they give an example which helped me understand how to find out the binary representation of the negative counterpart of a positive number.

<blockquote>
 For example, using 1 byte (= 2 nibbles = 8 bits), the decimal number 5
 is represented by
 
 0000 01012 The most significant bit is 0, so the pattern represents a
 non-negative value. To convert to −5 in two's-complement notation, the
 bits are inverted; 0 becomes 1, and 1 becomes 0:
 
 1111 1010 At this point, the numeral is the ones' complement of the
 decimal value −5. To obtain the two's complement, 1 is added to the
 result, giving:
 
 1111 1011 The result is a signed binary number representing the
 decimal value −5 in two's-complement form. The most significant bit is
 1, so the value represented is negative.
</blockquote>

blocks|key|209344|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|209345|正数按原样存储/检索。|blockquote|209346|209347|209348|e.g)+For+%2Bve+number+10;+byte+representation+will+be+like+0-000+0010+
+++++++++++++++++++++++++++++++++++++++++++++++(0+-+MSB+will+represent+that+it+is+%2Bve).
So+while+retrieving+based+on+MSB;+it+says+it+is+%2Bve,+
so+the+value+will+be+taken+as+it+is.+|code-block|syntax|javascript|209349|209350|，但负数将被存储在2的补码之后(除MSB位)，并且MSB位将被设置为1。|209351|209352|209353|例如)当存储-10时|209354|++0-000+0010++->+(1's+complement)+->+0-111+1101+
++++++++++++++->+(2's+complement)+0-111+1101+%2B+1+->+0-111+1110
++Now+MSB+will+be+set+to+one,+since+it+is+negative+no+->+1-111+1110|209355|检索时，发现MSB设置为1，因此为负否。和2的补码将被执行而不是MSB。|209356|++1-111+1110++-->+1-000+0001+%2B+1+-->+1-000+0010
++Since+MSB+representing+this+is+negative+10+-->+hence++-10+will+be+retrived.|209357|209358|铸造|209359|209360|209361|另请注意，当您将int/short转换为byte时，将只考虑最后一个字节和最后一个字节MSB，|209362|以"-130“短文为例，其存储方式可能如下|209363|(MSB)1-(2's+complement+of)130(1000+0010)+-->+1-111+1111+0111+1110|209364|现在字节转换取最后一个字节，即0111110。(0-+MSB+)由于MSB表示它是%2Bve值，因此将按原样进行处理。这是126。(%2Bve)。|209365|再以"130“为例，它的存储方式可能如下所示|209366|++0-000+000+1000+0010+++++(MSB+=+0)|209367|现在字节转换取最后一个字节，它是1000+0010。(1=MSB)由于MSB表示它是-ve值，所以将执行2的补码，并返回负数。因此，在本例中，将返回-126。|209368|+1-000+0010++->+(1's+complement)+->+1-111+1101+
+++++++++++++->+(2's+complement)+1-111+1101+%2B+1+->+1-111+1110+->+(-)111+1110
+++++++++++++++=+-126|209369|209370|+(整型)(字符)(字节)+-1与(整型)(短整型)(字节)+-1之间的差异|209371|209372|209373|(byte)-1+++++++->+0-000+0001+(2's+Comp)+->+0-111+1111+(add+sign)+->+1-111+1111
(char)(byte)-1+->+1-111+1111+1111+1111++(sign+bit+is+carry+forwarded+on+left)+|209374|类似的|209375|(short)(byte)-1->+1-111+1111+1111+1111++(sign+bit+is+carry+forwarded+on+left)+|209376|但|209377|(int)(char)(byte)-1+->+0-0000000+00000000+11111111+11111111++=+65535
since+char+is+unsigned;+MSB+won't+be+carry+forwarded.+|209378|和|209379|(int)(Short)(byte)-1+->+1-1111111+11111111+11111111+11111111+=+-1
since+short+is+signed;+MSB+is+be+carry+forwarded.+|209380|209381|参考|209382|209383|209384|Why+is+two's+complement+used+to+represent+negative+numbers?|offset|length|209385|What+is+“2's+Complement”?|209386|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1125304/why-is-twos-complement-used-to-represent-negative-numbers|1|https://stackoverflow.com/questions/1049722/what-is-2s-complement^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1N|0|0|0|P|1|0^^$0|@$1|2|3|-4|4|5|6|2M|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|2N|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|2O|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|2P|7|@]|8|@]|9|$]]|$1|F|3|G|4|H|6|2Q|7|@]|8|@]|9|$I|J]]|$1|K|3|-4|4|5|6|2R|7|@]|8|@]|9|$]]|$1|L|3|M|4|C|6|2S|7|@]|8|@]|9|$]]|$1|N|3|-4|4|5|6|2T|7|@]|8|@]|9|$]]|$1|O|3|-4|4|5|6|2U|7|@]|8|@]|9|$]]|$1|P|3|Q|4|5|6|2V|7|@]|8|@]|9|$]]|$1|R|3|S|4|H|6|2W|7|@]|8|@]|9|$I|J]]|$1|T|3|U|4|5|6|2X|7|@]|8|@]|9|$]]|$1|V|3|W|4|H|6|2Y|7|@]|8|@]|9|$I|J]]|$1|X|3|-4|4|5|6|2Z|7|@]|8|@]|9|$]]|$1|Y|3|Z|4|C|6|30|7|@]|8|@]|9|$]]|$1|10|3|-4|4|5|6|31|7|@]|8|@]|9|$]]|$1|11|3|-4|4|5|6|32|7|@]|8|@]|9|$]]|$1|12|3|13|4|5|6|33|7|@]|8|@]|9|$]]|$1|14|3|15|4|5|6|34|7|@]|8|@]|9|$]]|$1|16|3|17|4|H|6|35|7|@]|8|@]|9|$I|J]]|$1|18|3|19|4|5|6|36|7|@]|8|@]|9|$]]|$1|1A|3|1B|4|5|6|37|7|@]|8|@]|9|$]]|$1|1C|3|1D|4|H|6|38|7|@]|8|@]|9|$I|J]]|$1|1E|3|1F|4|5|6|39|7|@]|8|@]|9|$]]|$1|1G|3|1H|4|H|6|3A|7|@]|8|@]|9|$I|J]]|$1|1I|3|-4|4|5|6|3B|7|@]|8|@]|9|$]]|$1|1J|3|1K|4|C|6|3C|7|@]|8|@]|9|$]]|$1|1L|3|-4|4|5|6|3D|7|@]|8|@]|9|$]]|$1|1M|3|-4|4|5|6|3E|7|@]|8|@]|9|$]]|$1|1N|3|1O|4|H|6|3F|7|@]|8|@]|9|$I|J]]|$1|1P|3|1Q|4|5|6|3G|7|@]|8|@]|9|$]]|$1|1R|3|1S|4|H|6|3H|7|@]|8|@]|9|$I|J]]|$1|1T|3|1U|4|5|6|3I|7|@]|8|@]|9|$]]|$1|1V|3|1W|4|H|6|3J|7|@]|8|@]|9|$I|J]]|$1|1X|3|1Y|4|5|6|3K|7|@]|8|@]|9|$]]|$1|1Z|3|20|4|H|6|3L|7|@]|8|@]|9|$I|J]]|$1|21|3|-4|4|5|6|3M|7|@]|8|@]|9|$]]|$1|22|3|23|4|C|6|3N|7|@]|8|@]|9|$]]|$1|24|3|-4|4|5|6|3O|7|@]|8|@]|9|$]]|$1|25|3|-4|4|5|6|3P|7|@]|8|@]|9|$]]|$1|26|3|27|4|5|6|3Q|7|@]|8|@$28|3R|29|3S|1|3T]]|9|$]]|$1|2A|3|2B|4|5|6|3U|7|@]|8|@$28|3V|29|3W|1|3X]]|9|$]]|$1|2C|3|-4|4|5|6|3Y|7|@]|8|@]|9|$]]]|2D|$2E|$4|2F|2G|2H|9|$2I|2J]]|2K|$4|2F|2G|2H|9|$2I|2L]]]]

<blockquote>
 Positive numbers are stored/retrived as it is.
</blockquote>

<pre><code>e.g) For +ve number 10; byte representation will be like 0-000 0010 
 (0 - MSB will represent that it is +ve).
So while retrieving based on MSB; it says it is +ve, 
so the value will be taken as it is. 
</code></pre>

<blockquote>
 But negative numbers will be stored after 2's complement (other than
 MSB bit), and MSB bit will be set to 1.
</blockquote>

e.g) when storing -10 then 

<pre><code> 0-000 0010 -&gt; (1's complement) -&gt; 0-111 1101 
 -&gt; (2's complement) 0-111 1101 + 1 -&gt; 0-111 1110
 Now MSB will be set to one, since it is negative no -&gt; 1-111 1110
</code></pre>

when retrieving, it found that MSB is set to 1. So it is negative no.
And 2's complement will be performed other than MSB.

<pre><code> 1-111 1110 --&gt; 1-000 0001 + 1 --&gt; 1-000 0010
 Since MSB representing this is negative 10 --&gt; hence -10 will be retrived.
</code></pre>

<blockquote>
 Casting
</blockquote>

Also note that when you are casting int/short to byte, only last byte will be considered along with last byte MSB,

Take example "-130" short, it might be stored like below

<pre><code>(MSB)1-(2's complement of)130(1000 0010) --&gt; 1-111 1111 0111 1110
</code></pre>

Now byte casting took last byte which is 0111 1110. (0-MSB)
 Since MSB says it is +ve value, so it will be taken as it is. 
 Which is 126. (+ve).

Take another example "130" short, it might be stored like below

<pre><code> 0-000 000 1000 0010 (MSB = 0)
</code></pre>

Now byte casting took last byte which is 1000 0010 . (1=MSB)
 Since MSB says it is -ve value, 2's complement will be performed and negative number will be returned. So in this case -126 will be returned.

<pre><code> 1-000 0010 -&gt; (1's complement) -&gt; 1-111 1101 
 -&gt; (2's complement) 1-111 1101 + 1 -&gt; 1-111 1110 -&gt; (-)111 1110
 = -126
</code></pre>

<blockquote>
 Diff between (int)(char)(byte) -1 AND (int)(short)(byte) -1
</blockquote>

<pre><code>(byte)-1 -&gt; 0-000 0001 (2's Comp) -&gt; 0-111 1111 (add sign) -&gt; 1-111 1111
(char)(byte)-1 -&gt; 1-111 1111 1111 1111 (sign bit is carry forwarded on left) 
</code></pre>

similarly

<pre><code>(short)(byte)-1-&gt; 1-111 1111 1111 1111 (sign bit is carry forwarded on left) 
</code></pre>

But 

<pre><code>(int)(char)(byte)-1 -&gt; 0-0000000 00000000 11111111 11111111 = 65535
since char is unsigned; MSB won't be carry forwarded. 
</code></pre>

AND

<pre><code>(int)(Short)(byte)-1 -&gt; 1-1111111 11111111 11111111 11111111 = -1
since short is signed; MSB is be carry forwarded. 
</code></pre>

<blockquote>
 References
</blockquote>

<a href="https://stackoverflow.com/questions/1125304/why-is-twos-complement-used-to-represent-negative-numbers">Why is two&#39;s complement used to represent negative numbers?</a>

<a href="https://stackoverflow.com/questions/1049722/what-is-2s-complement">What is “2&#39;s Complement”?</a>

blocks|key|205111|text|对于正整数，2‘补码的值与MSB位0的(like+%2B14+2'complement+is+01110)相同。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|205112|仅对于负整数，我们正在计算2‘补值(-14=+10001%2B1+++++=+10010)。|205113|所以最后的答案是，两个值(%2Bve+and+-ve)都只以2‘补码的形式存储。|205114|entityMap^0|J|W|0|H|Q|0|C|D|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|K|$]]

For positive integer 2'complement value is same with MSB bit 0 <code>(like +14 2'complement is 01110)</code>.

For only negative integer only we are calculating 2'complement value <code>(-14= 10001+1 = 10010)</code>.

So final answer is both the values<code>(+ve and -ve)</code> are stored in 2'complement form only.

I am trying to understand how Java stores integer internally. I know all java primitive integers are signed, (except short?). That means one less bit available in a byte for the number.

My question is, are all integers (positive and negative) stored as two's complement or are only negative numbers in two's complement?

I see that the specs says <code>x bit two's complement number</code>. But I often get confused.

For instance:

<pre><code> int x = 15; // Stored as binary as is? 00000000 00000000 00000000 00001111?
 int y = -22; // Stored as two complemented value? 11111111 11111111 11111111 11101010
</code></pre>

Edit

To be clear, <code>x = 15</code> 

<pre><code> In binary as is: `00000000 00000000 00000000 00001111'
 Two's complement: `11111111 11111111 11111111 11110001`
</code></pre>

So if your answer is <code>all</code> numbers are stored as two's complement then:

<pre><code> int x = 15; // 11111111 11111111 11111111 11110001
 int y = -22 // 11111111 11111111 11111111 11101010
</code></pre>

The confusion here again is the sign says, both are negative numbers. May be I am misreading / misunderstanding it?

Edit
Not sure my question is confusing. Forced to isolate the question:

My question precisely: Are positive numbers stored in <code>binary as is</code> while negative numbers are stored as <code>two's complement</code>?

Some said all are stored in two's complement and one answer says only negative numbers are stored as two's complement.

How are integers internally represented at a bit level in Java?

Java

我试图理解Java是如何在内部存储整数的。我知道所有的java基本整数都是有符号的(除了short?)。这意味着在一个字节中该数字少了一位可用。我的问题是，是否所有的整数(正和负)都作为2的补码存储，或者只有负数在2的补码中？我看到说明书上写着x bit two's complement number。但我经常感到困惑...

问在Java中，整数是如何在内部以位级别表示的？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中，整数是如何在内部以位级别表示的？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中，整数是如何在内部以位级别表示的？
EN