bitweiser Nicht-Operator

Warum bitweise Operation (~0); druckt -1 ? Im Binärformat sollte nicht 0 1 sein. warum ?

Du bist eigentlich ganz in der Nähe.

In binär sollte nicht 0 1 sein

Ja, das ist absolut richtig, wenn wir von einem Bit sprechen.

ABER, ein int dessen Wert 0 ist, sind eigentlich 32 Bits aller Nullen! ~ invertiert alle 32 Nullen in 32 Einsen.

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

Dies ist die Zweierkomplementdarstellung von -1.

Ähnlich:

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

Das heißt, für ein 32-Bit unsigned int in Zweierkomplementdarstellung, ~1 == -2.

Weiterlesen:

• Zweierkomplement
  • Dies ist das System, das (unter anderem) von Java verwendet wird, um vorzeichenbehaftete numerische Werte in Bits darzustellen
• JLS 15.15.5 Bitweiser Komplementoperator ~
  • „Beachten Sie, dass in allen Fällen ~x gleich (-x)-1“

Was Sie eigentlich sagen, ist ~0x00000000 und das ergibt 0xFFFFFFFF. Für ein (signed) int in Java bedeutet das -1.

Sie können sich vorstellen, dass das erste Bit in einer vorzeichenbehafteten Zahl -(2 ist^x-1), wobei x die Anzahl der Bits ist.

Bei einer gegebenen 8-Bit-Zahl ist der Wert jedes Bits (in der Reihenfolge von links nach rechts):

-128 64 32 16 8 4 2 1

Nun, in Binärform ist 0 offensichtlich nur 0:

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

Und wenn du das bitweise machst nicht ~ jede dieser Nullen wird zu einer 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

Dies ist auch hilfreich, um den Überlauf zu verstehen:

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

~ ist ein bitweiser Operator.

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

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

Einige Zahlen in Zweierkomplementform und ihre bitweise nicht ~ (direkt darunter):

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

Da ~ ist keine binäre Inversion, sondern eine bitweise Inversion. Binäre Umkehrung wäre ! und kann (in Java) nur auf boolesche Werte angewendet werden.

In der Standard-Binärcodierung ist 0 alles Nullen, ~ ist bitweise NICHT. Alle 1s sind (meistens) -1 für vorzeichenbehaftete Integer-Typen. Also für einen signierten Byte-Typ:

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

Es ist eine binäre Inversion, und im zweiten Komplement ist -1 eine binäre Inversion von 0.