побитовый не оператор

Question

Почему побитовая операция (~0); печатает -1? В двоичном коде не 0 должно быть 1. почему?

Answer 1

Вы на самом деле довольно близко.

В двоичном коде не 0 должно быть 1

Да, это абсолютно правильно, когда мы говорим об одном бите.

ОДНАКО, int, значение которого равно 0, на самом деле составляет 32 бита всех нулей! ~ инвертирует все 32 нуля в 32.

System.out.println(Integer.toBinaryString(~0));
// prints "11111111111111111111111111111111"

Это дополняющее представление двух -1.

* * 1016 Аналогично:

System.out.println(Integer.toBinaryString(~1));
// prints "11111111111111111111111111111110"

То есть для 32-разрядного без знака int в представлении дополнения до двух ~1 == -2.

---

Дальнейшее чтение:

• Два дополнения
  • Это система, используемая Java (среди прочих) для представления числового значения со знаком в битах
• JLS 15.15.5 Оператор побитового дополнения ~
  • "обратите внимание, что во всех случаях ~x равно (-x)-1"

Answer 2

То, что вы на самом деле говорите, ~ 0x00000000, и в результате получается 0xFFFFFFFF. Для (подписанного) int в Java это означает -1.

Answer 3

Вы можете представить, что первый бит в числовом знаке будет - (2 ^{x -1} ), где x - это количество бит.

Итак, учитывая 8-битное число, значение каждого бита (в порядке слева направо) равно:

-128 64 32 16 8 4 2 1

Теперь в двоичном формате 0 - это, очевидно, все 0:

    -128 64 32 16 8 4 2 1
0      0  0  0  0 0 0 0 0 = 0

И когда вы выполняете битовое не ~, каждый из этих 0 становится 1:

     -128 64 32 16 8 4 2 1
~0      1  1  1  1 1 1 1 1
 =   -128+64+32+16+8+4+2+1 == -1

Это также полезно для понимания переполнения:

     -128 64 32 16 8 4 2 1
126     0  1  1  1 1 1 1 0  =  126
 +1     0  1  1  1 1 1 1 1  =  127
 +1     1  0  0  0 0 0 0 0  = -128  overflow!

Answer 4

~ - побитовый оператор.

~0 = 1 which is -1 in 2's complement form  

http://en.wikipedia.org/wiki/Two's_complement

Некоторые числа в форме дополнения до двух и их побитовое обозначение не ~ (чуть ниже):

0 1 1 1 1 1 1 1 = 127
1 0 0 0 0 0 0 0 = −128

0 1 1 1 1 1 1 0 = 126
1 0 0 0 0 0 0 1 = −127

1 1 1 1 1 1 1 1 = −1
0 0 0 0 0 0 0 0 = 0

1 1 1 1 1 1 1 0 = −2
0 0 0 0 0 0 0 1 = 1

1 0 0 0 0 0 0 1 = −127
0 1 1 1 1 1 1 0 = 126

1 0 0 0 0 0 0 0 = −128
0 1 1 1 1 1 1 1 = 127

Answer 5

Поскольку ~ - это не двоичная инверсия, это побитовая инверсия. Двоичная инверсия будет ! и может (в Java) применяться только к логическим значениям.

Answer 6

В стандартном двоичном кодировании 0 - это все 0, ~ - поразрядное НЕ. Все 1 - это (чаще всего) -1 для целых типов со знаком. Так для подписанного типа байта:

0xFF = -1    // 1111 1111
0xFE = -2    // 1111 1110
...
0xF0 = -128  // 1000 0000
0x7F = 127   // 0111 1111
0x7E = 126   // 0111 1110
...
0x01 = 1     // 0000 0001
0x00 = 0     // 0000 0000

Answer 7

Я думаю, что настоящая причина в том, что ~ это дополнение к двум.

Javascript обозначает тильду символа, ~, для дополнения к двум, хотя в большинстве языков программирования тильда представляет собой немного переключателя для дополнения к одному.

Answer 8

Для 32-разрядного целого числа со знаком

~00000000000000000000000000000000=11111111111111111111111111111111 (что равно -1)

Answer 9

0 здесь не мало. Это байт (по крайней мере; или больше) - 00000000. Используя побитовый, или мы получим 11111111. Это -1 как целое число со знаком ...

Answer 10

Это двоичная инверсия, а во втором дополнении -1 - двоичная инверсия 0.