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

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

Ответ 1

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

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

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

HOWEVER, int, значение которого равно 0, фактически составляет 32 бита всех нулей! ~ инвертирует все 32 нуля до 32.

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

Это два дополнительных представления -1.

Аналогично:

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

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

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

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

Ответ 2

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

Ответ 3

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

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

-128 64 32 16 8 4 2 1

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

    -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!

Ответ 4

~ является побитовым оператором.

~0 = 1 which is -1 in 2 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

Ответ 5

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

Ответ 6

В стандартном двоичном кодировании 0 - все 0s, ~ побитовое NOT. Все 1s (чаще всего) -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

Ответ 7

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

Ответ 8

0 здесь немного. Это байт (по крайней мере, или больше) - 00000000. С помощью побитового или 11111111. Он равен -1 в виде целого числа со знаком...

Ответ 9

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

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

Ответ 10

Я думаю, что настоящая причина в том, что ~ есть Twos Complement.

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