为什么~2等于-3?~操作符是如何工作的?
~翻转值中的位。
为什么~2等于-3与数字的位表示方式有关。数字用二的补数表示。
2是二进制值
00000010
和~2翻转位，所以现在的值是:
11111101
它是-3的二进制表示。
记住，负数被存储为正数的补数。作为一个例子，这里是-2在2的补码中的表示:(8位)
1111 1110
得到它的方法是取一个数字的二进制表示，取它的补位(所有位的倒数)，然后加1。Two从0000 0010开始，通过反转位，我们得到1111 1101。加1得到上面的结果。第一个位是符号位，表示负号。
那么让我们看看如何得到~2 = -3:
这里还有两个:
0000 0010
简单地翻转所有的位，我们得到:
1111 1101
那么-3在2的补中是什么样的呢?从正3,0000 0011开始，将所有位翻转到1111 1100，并添加1位成为负值(-3)，1111 1101。
所以如果你简单地将2中的位反转，你就得到了2的-3的补表示。
补运算符(~)只是翻转位。由机器来解释这些比特。
正如其他人所提到的~只是翻转位(将1变为0，将0变为1)，由于使用了2的补码，您就得到了您所看到的结果。
需要补充的一点是为什么使用2的补数，这是为了对负数的运算和对正数的运算是一样的。把-3看成是要加3才能得到0的数字，你会看到这个数字是1101，记住二进制加法就像小学(十进制)加法，只是你得到2时进1，而不是10。
1101 +
0011 // 3
=
10000
=
0000 // lose carry bit because integers have a constant number of bits.
因此1101是-3，翻转位就得到0010，也就是2。
这个操作是补语，不是否定语。
考虑~0 = -1，然后从这里开始。
否定的算法是，“补，加”。
你知道吗?还有一种“一的补”，它的逆数是对称的，它有一个0和一个-0。
我知道这个问题的答案很久以前就贴出来了，但我想分享我的答案。
要找到一个数的一补，首先要找到它的二进制等价物。这里，十进制数字2用二进制形式表示为0000 0010。现在通过将其二进制表示的所有数字逆(将所有1都翻转为0，将所有0都翻转为1)来求其1的补数，这将得到:
0000 0010 → 1111 1101
这是十进制数2的1补。由于二进制数的第一个位，即符号位为1，这意味着它存储的数字的符号为负。(这里所指的数字不是2，而是2的1的补数)。
现在，由于数字存储为2的补数(取1的补数加1)，所以要将这个二进制数1111 1101显示为十进制，首先我们需要找到它的2的补数，即:
1111 1101 → 0000 0010 + 1 → 0000 0011
这是2的补。二进制数0000 0011的十进制表示是3。并且，因为符号位是1，所以结果是-3。
提示:如果你仔细阅读这个过程，你会发现1的补码操作符的结果实际上是，数字(操作数-，这个操作符被应用)加1，带一个负号。你也可以用其他数字试试。
简单的 ...........
作为任何数字的2的补，我们可以通过将所有1逆为0来计算，反之亦然，然后再加上1。
这里N= ~N产生的结果总是-(N+1)。因为系统以2的补码的形式存储数据，这意味着它像这样存储~N。
~N = -(~(~N)+1) =-(N+1).
例如::
N = 10 = 1010
Than ~N = 0101
so ~(~N) = 1010
so ~(~N) +1 = 1011
点就是负的原点。我的观点是假设我们有32位寄存器，这意味着2^31 -1位涉及到操作，剩下的一位在早期计算(补码)中被存储为符号位，通常为1。结果是~10 = -11。
~(-11) =10;
如果printf("%d"，~0);结果是-1;
但printf(“%u”，~0)比结果:4294967295在32位机器上。
首先，我们必须把给定的数字分成它的二进制数，然后把它颠倒过来，把最后一个二进制数相加。执行完后，我们必须给我们正在寻找补数的前一位数字赋相反的符号 ~ 2 = 3 解释: 2的二进制形式是00000010变成11111101，这是1的补码，然后补码为00000010+1=00000011，这是3的二进制形式，带-符号，即-3
位补操作符(~)是一个一元操作符。
它的工作原理如下
首先，它将给定的十进制数转换为相应的二进制数 价值。这是在2的情况下，它首先将2转换为0000 0010(到8位二进制数)。
然后它将数字中的所有1都转换为0，所有0都转换为1，然后数字将变成11111101。
这是-3的2的补表示。
为了找到无符号的值使用补，即。要简单地将1111 1101转换为十进制(=4294967293)，只需在打印时使用%u。
位操作符是一个一元操作符，根据我的经验和知识，它的工作原理是符号和幅度方法。
例如~2的结果是-3。
这是因为逐位操作符将首先以符号和幅度表示数字，即0000 0010(8位操作符)，其中MSB是符号位。
然后取2的负数，也就是-2。
-2用符号和幅度表示为1000 0010(8位运算符)。
之后，它将1添加到LSB(1000 0010 + 1)，得到1000 0011。
也就是-3。
我认为对于大多数人来说，困惑的部分来自于十进制数和有符号二进制数的区别，所以让我们先澄清一下:
对于人类十进制世界: 01表示1， -01表示-1， 对于计算机的二进制世界: 101是无符号的，表示5。 101的意思是(-4 + 1)，如果是有符号的数字在x位置。 | x
所以2的翻转位= ~2 = ~(010)= 101 = -4 + 1 = -3 这种混淆是由于混淆了有符号的结果(101=-3)和没有符号的结果(101=5)
Javascript波浪号(~)将给定值强制转换为1的补位——所有位都是反向的。 这就是波浪的作用。这不是固执己见。它既不加也不减任何量。
0 -> 1
1 -> 0
...in every bit position [0...integer nbr of bits - 1]
On standard desktop processors using high-level languages like JavaScript, BASE10 signed arithmetic is the most common, but keep in mind, it's not the only kind. Bits at the CPU level are subject to interpretation based on a number of factors. At the 'code' level, in this case JavaScript, they are interpreted as a 32-bit signed integer by definition (let's leave floats out of this). Think of it as quantum, those 32-bits represent many possible values all at once. It depends entirely on the converting lens you view them through.
JavaScript Tilde operation (1's complement)
BASE2 lens
~0001 -> 1110 - end result of ~ bitwise operation
BASE10 Signed lens (typical JS implementation)
~1 -> -2
BASE10 Unsigned lens
~1 -> 14
以上所有观点同时都是正确的。
int = 4; System.out.println (~); 结果是:-5
Java中任意整数的“~”表示1对no的补。 例如，我取~4，这意味着用二进制表示0100。 首先, 整数长度为4字节，i。e4 *8(8位1字节)=32。 在系统内存中，4表示为 0000 0000 0000 0000 0000 0000 0000 0100 现在~操作符将对上面的二进制no执行1的补
i.e 1111 1111 1111 1111 1111 1111 1111 1011->1's complement the most significant bit represents sign of the no(either - or +) if it is 1 then sign is '-' if it is 0 then sign is '+' as per this our result is a negative number, in java the negative numbers are stored in 2's complement form, the acquired result we have to convert into 2's complement( first perform 1's complement and just add 1 to 1's complement). all the one will become zeros,except most significant bit 1(which is our sign representation of the number,that means for remaining 31 bits 1111 1111 1111 1111 1111 1111 1111 1011 (acquired result of ~ operator) 1000 0000 0000 0000 0000 0000 0000 0100 (1's complement)
1(2的补数)
1000000 0000 0000 0000 0000 0000 0000 0101 现在结果是-5 查看视频<[java中的位运算符]https://youtu.be/w4pJ4cGWe9Y的链接
Tl;dr ~翻转比特。结果符号就改变了。~2是负数(0b..101)。要输出一个负数红宝石打印-，则2的~2的补:-(~~2 + 1)== -(2 + 1)== 3。正数按原样输出。
有一个内部值，和它的字符串表示。对于正整数，它们基本重合:
irb(main):001:0> '%i' % 2
=> "2"
irb(main):002:0> 2
=> 2
后者相当于:
irb(main):003:0> 2.to_s
"2"
~翻转内部值的位。2 = 0b010。~2是0b..101。两个点(..)代表无限个1。由于结果的最高有效位(MSB)为1，因此结果为负数((~2)。= = true)。要输出一个负数的红宝石印-，则是二的内部补值。2的补位是通过翻转位，然后加1来计算的。0b的2的补。101等于3。是这样的:
irb(main):005:0> '%b' % 2
=> "10"
irb(main):006:0> '%b' % ~2
=> "..101"
irb(main):007:0> ~2
=> -3
总的来说，它翻转了位，从而改变了符号。为了输出一个负数，它输出-，然后~~2 + 1(~~2 == 2)。
ruby像这样输出负数的原因是，它将存储的值视为绝对值的2的补。换句话说，存储的是0b..101。它是一个负数，因此它是x的2的补，为了找到x，它是2的补0b..101。它是2的x的补，也就是x(例如~(~2 + 1)+ 1 == 2)。
如果你将~应用于一个负数，它只是翻转位(尽管如此，这改变了符号):
irb(main):008:0> '%b' % -3
=> "..101"
irb(main):009:0> '%b' % ~-3
=> "10"
irb(main):010:0> ~-3
=> 2
更令人困惑的是~0xffffff00 != 0xff(或MSB等于1的任何其他值)。让我们稍微简化一下:~0xf0 != 0x0f。这是因为它将0xf0视为正数。这是有道理的。因此，~0xf0 == 0x..f0f。结果是一个负数。0x的2的补。F0f是0xf1。所以:
irb(main):011:0> '%x' % ~0xf0
=> "..f0f"
irb(main):012:0> (~0xf0).to_s(16)
=> "-f1"
如果你不打算对结果应用位操作符，你可以考虑~作为-x - 1操作符:
irb(main):018:0> -2 - 1
=> -3
irb(main):019:0> --3 - 1
=> 2
但可以说，这并没有多大用处。
举个例子，假设你有一个8位的网络掩码(为了简单起见)，你想计算0的个数。您可以通过翻转位并调用bit_length (0x0f. bit_length)来计算它们。bit_length == 4). But ~0xf0 == 0x..F0f，所以我们要去掉不需要的部分
irb(main):014:0> '%x' % (~0xf0 & 0xff)
=> "f"
irb(main):015:0> (~0xf0 & 0xff).bit_length
=> 4
或者你可以使用XOR运算符(^):
irb(main):016:0> i = 0xf0
irb(main):017:0> '%x' % i ^ ((1 << i.bit_length) - 1)
=> "f"
这里，二进制(8位)中的2是00000010，它的1的补码是11111101， 1的补数减去1得到1111110 -1 = 11111100， 这里的符号是-作为第8个字符(从R到L)是1 求1的补，no。即00000011 = 3 符号是负的所以这里是-3。
很简单:
Before starting please remember that
1 Positive numbers are represented directly into the memory.
2. Whereas, negative numbers are stored in the form of 2's compliment.
3. If MSB(Most Significant bit) is 1 then the number is negative otherwise number is
positive.
你会发现~2:
Step:1 Represent 2 in a binary format
We will get, 0000 0010
Step:2 Now we have to find ~2(means 1's compliment of 2)
1's compliment
0000 0010 =================> 1111 1101
So, ~2 === 1111 1101, Here MSB(Most significant Bit) is 1(means negative value). So,
In memory it will be represented as 2's compliment(To find 2's compliment first we
have to find 1's compliment and then add 1 to it.)
Step3: Finding 2's compliment of ~2 i.e 1111 1101
1's compliment Adding 1 to it
1111 1101 =====================> 0000 0010 =================> 0000 0010
+ 1
---------
0000 0011
So, 2's compliment of 1111 1101, is 0000 0011
Step4: Converting back to decimal format.
binary format
0000 0011 ==============> 3
In step2: we have seen that the number is negative number so the final answer would
be -3
So, ~2 === -3
简单地说，~就是找到对称值(到-0.5)。
~a和a应该与0和-1中间的镜像对称。
- 5, 4, 3, 2, 1 | 0, 1, 2, 3, 4
~0 == -1
~1 == -2
~2 == -3
~3 == -4
这是因为计算机是如何表示负数的。
比如说，如果正值用1来计数，负值就用0。
1111 1111 == -1
1111 1110 == -2; // add one more '0' to '1111 1111'
1111 1101 == -3; // add one more '0' to '1111 1110'
最后，~i == -(i+1)。
下面是一种解释:
让我们以~2 = -3为例(为了简单起见，使用8位系统进行解释)
1)我们有2——> 00000010
2)我们可以得到~2—> 11111101 #通过简单地交换位。
[但常见的错误是，有些人试图将~2的二进制值直接转换为十进制(以10为基数)数字，在这种情况下，它是253。这不是我们寻找互补的方式。
3)现在我们找到一个二进制数，将其与二进制值2~相加得到0(00000000)作为结果。 在这种情况下，它是00000011(即3)，因为如果我们将00000011加到我们已有的11111101，我们得到100000000，但由于我们使用的是8位系统，1在第9位，它被完全忽略，所以我们最终得到00000000。
4)从点(3)我们可以说~2+3 = 0，因此我们可以说~2 = -3
注意:-3的值是简单的11111101，可以用同样的方式解释。
