21    Bits und Bytes, Mathematisches und Geld 

»Es gibt nur 10 Typen von Menschen auf der Welt.

Die, die Binärcode verstehen, und die, die ihn nicht verstehen.«

Dieses Kapitel betrachtet die Repräsentationen der Zahlen genauer und erläutert, wie binäre Operatoren auf diesen Werten arbeiten. Nachdem die Ganzzahlen genauer beleuchtet wurden, folgen eine detaillierte Darstellung der Fließkommazahlen und anschließend mathematische Grundfunktionen wie max(…), sin(…), abs(…), die in Java durch die Klasse Math realisiert werden.

 

21.1    Bits und Bytes 

Ein Bit ist ein Informationsträger für die Aussage »wahr oder falsch«, also mit zwei Zuständen. Durch das Zusammensetzen von einzelnen Bits entstehen größere Folgen wie das Byte, das aus 8 Bit besteht, zum Beispiel 00010011_bin. Da die genannte Zahl durch die Ziffern 0 und 1 durchaus eine Dezimalzahl sein könnte, stellen wir hinter die Zahl ein kleines _bin, wenn es zu Missverständnissen kommen kann.

Werden 8 Bit = 1 Byte zugrunde gelegt, lassen sich durch unterschiedliche Belegungen 256 unterschiedliche Zahlen bilden. Ist kein Bit des Bytes gesetzt, so ist die Zahl 0; ist jedes Bit gesetzt, ist die Zahl 255. Jedes Bit an einer Position im Byte kann 0 oder 1 sein, und daraus ergibt sich eine Wertigkeit, an welcher Stelle 0 oder 1 in der Folge steht. Wir sprechen von einem Stellenwertsystem, bei dem die Position einer Ziffer entscheidend ist, denn 12 ist nicht gleich 21, und 10_bin ist nicht gleich 01_bin. Jetzt stellt sich nur noch die Frage, wie die Bitnummerierung erfolgt, denn das Bit mit dem niedrigsten Stellenwert könnte links oder rechts stehen – üblicherweise steht es rechts, und das Bit mit dem höchsten Stellenwert steht links.

Beim Dualsystem haben wir die Ziffern 0 und 1. Der Wert einer Dualzahl ergibt sich durch Addition der Ziffern 0 oder 1, die vorher jeweils mit ihrem Stellenwert 2^i multipliziert werden. Die Wertebelegung für die Zahl 19 berechnet sich aus 16 + 2 + 1, da sie aus einer Anzahl von Summanden der Form 2ⁱ  zusammengesetzt ist: 19_dez = 16 + 2 + 1 = 1 × 2⁴ + 0 × 2³ + 0 × 2² + 1 × 2¹ + 1 × 2⁰ = 10011_bin.

Tabelle 21.1    Wertebelegung

Java bietet zum Modifizieren von Bits

• bitweise Operatoren und

• bitweise Verschiebungen (Schiebeoperationen).

Diese schauen wir uns jetzt an.

 

21.1.1    Die Bit-Operatoren Komplement, Und, Oder und XOR 

Mit Bit-Operatoren lassen sich Binäroperationen auf Operanden durchführen, um beispielsweise ein Bit eines Bytes zu setzen. Zu den Bit-Operationen zählen das Komplement eines Operanden und Verknüpfungen mit anderen Werten. Durch die bitweisen Operatoren können einzelne Bits abgefragt und manipuliert werden.

Tabelle 21.2    Bit-Operatoren in Java

Das Komplement ist ein unärer Operator, die anderen sind binäre Operatoren. Betrachten wir allgemein die binäre Verknüpfung a # b. Bei der binären bitweisen Und-Verknüpfung mit & gilt für jedes Bit: Ist im Operand a irgendein Bit gesetzt und an gleicher Stelle auch im Operand b, so ist auch das Bit an der Stelle im Ergebnis gesetzt. Bei der Oder-Verknüpfung mit | muss nur einer der Operanden gesetzt sein, damit das Bit im Ergebnis gesetzt ist. Bei einem exklusiven Oder (XOR) ist das Ergebnis 1, wenn nur genau einer der Operanden 1 ist. Sind beide gemeinsam 0 oder 1, ist das Ergebnis 0. Dies entspricht einer binären Addition oder Subtraktion.[ 267 ](Auf XOR können wir im Grunde verzichten, weil es sich durch die anderen Operatoren ausdrücken lässt: a^b ist wie (a & ~b) | (~a & b). )

Fassen wir das Ergebnis noch einmal in einer Tabelle zusammen:

Tabelle 21.3    Die Bit-Operatoren Komplement, Und, Oder und XOR in einer Wahrheitstafel

Nehmen wir zum Beispiel zwei Ganzahlen:

Tabelle 21.4    Binäre Verknüpfung zweier Ganzzahlen

 

21.1.2    Repräsentation ganzer Zahlen in Java – das Zweierkomplement 

Der Rechner speichert Daten in den Zuständen 0 und 1 und muss positive sowie negative Zahlen darstellen können. Dazu gibt es unterschiedliche Kodierungen, wie das Einer- oder Zweierkomplement, wobei Letzteres für moderne Programme üblich ist, auch weil die internen Schaltungen im Prozessor einfacher sind.

Das Zweierkomplement definiert für positive und negative Ganzzahlen folgende Kodierung:

• Das Vorzeichen einer Zahl bestimmt ein Bit, das 1 bei negativen und 0 bei positiven Zahlen ist.

• Um eine 0 darzustellen, ist kein Bit gesetzt.

• Bei negativen Zahlen: Wir nehmen den Absolutwert der Zahl, invertieren das Bitmuster und addieren 1 zu dem Ergebnis.

Java-Ganzzahldatentypen im Zweierkomplement

Java kodiert die Ganzzahldatentypen byte, short, int und long immer im Zweierkomplement (der Datentyp char definiert keine negativen Zahlen). Mit dieser Kodierung gibt es eine negative Zahl mehr als positive, da es im Zweierkomplement keine positive und negative 0 gibt, sondern nur eine »positive« mit der Bit-Maske 0000…0000.

Tabelle 21.5    Darstellungen des Zweierkomplements im Datentyp »short«

Bei allen negativen Ganzzahlen ist also das oberste Bit mit 1 gesetzt.

 

21.1.3    Das binäre (Basis 2), oktale (Basis 8), hexadezimale (Basis 16) Stellenwertsystem 

Die Literale für Ganzzahlen lassen sich in vier unterschiedlichen Stellenwertsystemen angeben. Das natürlichste ist das Dezimalsystem (auch Zehnersystem genannt), bei dem die Literale aus den Ziffern 0 bis 9 bestehen. Zusätzlich existieren die Binär-, Oktal- und Hexadezimalsysteme, die die Zahlen zur Basis 2, 8 und 16 schreiben. Bis auf Dezimalzahlen beginnen die Zahlen in anderen Formaten mit einem besonderen Präfix.

Tabelle 21.6    Die Stellenwertsysteme und ihre Schreibweise

Ein hexadezimaler Wert beginnt mit 0x oder 0X. Da zehn Ziffern für 16 hexadezimale Zahlen nicht ausreichen, besteht eine Zahl zur Basis 16 zusätzlich aus den Buchstaben a bis f (bzw. A bis F). Das Hexadezimalsystem heißt auch Sedezimalsystem.[ 268 ](Das Präfix »octo« bei »Oktalsystem« stammt aus dem Lateinischen. Das Wort »hexadezimal« enthält zwei Bestandteile aus zwei verschiedenen Sprachen: »hexa« stammt aus dem Griechischen und »decem« (zehn) aus dem Lateinischen. Die alternative Bezeichnung Sedezimalzahl bzw. sedezimal (engl. sexadecimal – nicht sexagesimal, das ist Basis 60) ist rein aus dem Lateinischen abgeleitet, aber im Deutschen unüblich. Über den Ursprung des Wortes »Hexadezimal« finden Sie mehr auf der englischen Wikipedia-Seite http://en.wikipedia.org/wiki/Hexadecimal#Etymology. )

Ein oktaler Wert beginnt mit dem Präfix 0. Mit der Basis 8 werden nur die Ziffern 0 bis 7 für oktale Werte benötigt. Der Name stammt von dem lateinischen »octo«, das auf Deutsch »acht« heißt. Das Oktalsystem war früher eine verbreitete Darstellung, da nicht mehr einzelne Bits solo betrachtet werden mussten, sondern 3 Bit zu einer Gruppe zusammengefasst wurden. In der Kommunikationselektronik ist das Oktalsystem noch weiterhin beliebt, spielt aber sonst keine Rolle.

Für Dualzahlen (also Binärzahlen zur Basis 2) verwenden wir das Präfix 0b oder 0B. Es sind nur die Ziffern 0 und 1 erlaubt, ein klassischer Fall für 2.

System.out.println( 1243 );         // 1243

System.out.println( 0b10111011 );   // 187

System.out.println( 01230 );        // 664

System.out.println( 0xcafebabe );   // -889275714

System.out.println( 0xC0B0L );      // 49328

int i = 118;

int j = 012;                        // Oktal 012 ist dezimal 10

 

21.1.4    Auswirkung der Typumwandlung auf die Bit-Muster 

Die Typumwandlung führt dazu, dass bei Ganzzahlen die oberen Bits einfach abgeschnitten werden. Bei einer Anpassung von Fließkommazahlen auf Ganzzahlen wird gerundet. Was genau passiert, soll dieser Abschnitt zeigen.

Explizite Typumwandlung bei Ganzzahlen

Bei der Konvertierung eines größeren Ganzzahltyps in einen kleineren werden die oberen Bits abgeschnitten. Eine Anpassung des Vorzeichens findet nicht statt. Die Darstellung in Bit zeigt das sehr anschaulich:

Listing 21.1    src/main/java/com/tutego/insel/math/TypecastDemo.java, main()

int   ii = 123456789;     // 0000011101011011_11001101_00010101

int   ij =   -123456;     // 1111111111111110_00011101_11000000



short si = (short) ii;    //                  11001101_00010101

short sj = (short) ij;    //                  00011101_11000000



System.out.println( si ); // -13035

System.out.println( sj ); //   7616

si wird eine negative Zahl, da das 16. Bit beim int ii gesetzt war und nun beim short das negative Vorzeichen anzeigt. Die Zahl hinter ij hat kein 16. Bit gesetzt, und so wird das short sj positiv.

Umwandlung von short und char

Ein short hat wie ein char eine Länge von 16 Bit. Doch diese Umwandlung ist nicht ohne ausdrückliche Konvertierung möglich. Das liegt am Vorzeichen von short. Zeichen sind per Definition immer ohne Vorzeichen. Würde ein char mit einem gesetzten höchstwertigen letzten Bit in ein short konvertiert, käme eine negative Zahl heraus. Ebenso wäre, wenn ein short eine negative Zahl bezeichnet, das oberste Bit im char gesetzt, was unerwünscht ist. Die ausdrückliche Umwandlung erzeugt immer nur positive Zahlen.

Der Verlust bei der Typumwandlung von char nach short tritt etwa bei der Han-Zeichenkodierung für chinesische, japanische oder koreanische Zeichen auf, weil dort im Unicode das erste Bit gesetzt ist, das bei der Umwandlung in ein short dem nicht gesetzten Vorzeichen-Bit weichen muss.

Typumwandlungen von int und char

Die Methode printXXX(…) ist mit den Typen char und int überladen, und eine Typumwandlung führt zur gewünschten Ausgabe:

int  c1 = 65;

char c2 = 'A';

System.out.println( c1 );              // 65

System.out.println( (int)c2 );         // 65

System.out.println( (char)c1 );        // A

System.out.println( c2 );              // A

System.out.println( (char)(c1 + 1) );  // B

System.out.println( c2 + 1 );          // 66

Einen Ganzzahlwert in einem int können wir als Zeichen ausgeben, genauso wie eine char-Variable als Zahlenwert. Wir sollten beachten, dass eine arithmetische Operation auf char-Typen zu einem int führt. Daher funktioniert für ein char c Folgendes nicht:

c = c + 1;

Richtig wäre:

c = (char)(c + 1)

Unterschiedliche Wertebereiche bei Fließ- und Ganzzahlen

Natürlich kann die Konvertierung double ↔ long nicht verlustfrei sein. Wie sollte das auch gehen? Zwar verfügt sowohl ein long als auch ein double über 64 Bit zur Datenspeicherung, aber ein double kann eine Ganzzahl nicht so effizient speichern wie ein long und hat etwas »Overhead« für einen großen Exponenten. Bei der impliziten Konvertierung eines long in einen double können einige Bit als Informationsträger herausfallen, wie das folgende Beispiel illustriert:

long   l = 1111111111111111111L; // 1111111111111111111

double d = l;                    // 1111111111111111170 (1.11111111111111117E18)

long   m = (long) d;             // 1111111111111111168

Java erlaubt ohne explizite Anpassung die Konvertierung eines long in einen double und auch in ein noch kleineres float, was vielleicht noch merkwürdiger ist, da float nur eine Genauigkeit von 6 bis 7 Stellen hat, long hingegen 18 Stellen hat.

long  l = 1000000000000000000L;

float f = l;

System.out.printf( "%f", f );    // 999999984306749440,000000

Materialverlust durch Überläufe *

Überläufe bei Berechnungen können zu schwerwiegenden Fehlern führen, so wie beim Absturz der Ariane 5 am 4. Juni 1996, genau 36,7 Sekunden nach dem Start. Die europäische Raumfahrtbehörde European Space Agency (ESA) hatte die unbemannte Rakete, die vier Satelliten an Bord hatte, von Französisch-Guayana aus gestartet. Glücklicherweise kamen keine Menschen ums Leben, doch der materielle Schaden belief sich auf etwa 500 Millionen US-Dollar. In dem Projekt steckten zusätzlich Entwicklungskosten von etwa 7 Milliarden US-Dollar. Der Grund für den Absturz war ein Rundungsfehler im Ada-Programm, der durch die Umwandlung einer 64-Bit-Fließkommazahl (die horizontale Geschwindigkeit) in eine vorzeichenbehaftete 16-Bit-Ganzzahl auftrat. Die Zahl war leider größer als 2¹⁵ – 1 und die Umwandlung nicht gesichert, da die Programmierer diesen Zahlenbereich nicht angenommen hatten. Das führte zu einer Ausnahme, und als Konsequenz brach das Lenksystem zusammen, und die Selbstzerstörung wurde ausgelöst, da die Triebwerke abzubrechen drohten. Das wirklich Dumme an dieser Geschichte ist, dass die Software nicht unbedingt für den Flug notwendig war und nur den Startvorbereitungen diente. Im Fall einer Unterbrechung während des Countdowns hätte das Programm schnell abgebrochen werden können. Ungünstig war, dass der Programmteil unverändert durch Wiederverwendung per Copy & Paste aus der Ariane-4-Software kopiert worden war, die Ariane 5 aber schneller flog.

 

21.1.5    Vorzeichenlos arbeiten 

Bis auf char sind in Java alle integralen Datentypen vorzeichenbehaftet und im Zweierkomplement kodiert. Bei einem byte stehen 8 Bit für die Kodierung eines Werts zur Verfügung, jedoch sind es eigentlich nur 7 Bit, denn über ein Bit erfolgt die Kodierung des Vorzeichens. Der Wertebereich reicht von –128 bis +127. Über einen Umweg ist es möglich, den vollen Wertebereich auszuschöpfen und so zu tun, als ob Java vorzeichenlose Datentypen hätte.

byte als vorzeichenlosen Datentyp nutzen

Eine wichtige Eigenschaft der expliziten Typumwandlung bei Ganzzahltypen ist, dass die überschüssigen Bytes einfach abgeschnitten werden. Betrachten wir die Typumwandlung an einem Beispiel:

int  l =        0xABCD6F;

byte b = (byte) 0xABCD6F;

System.out.println( Integer.toBinaryString( l ) ); // 101010111100110101101111

System.out.println( Integer.toBinaryString( b ) ); //                  1101111

Liegt eine Zahl im Bereich von 0 bis 255, so kann ein byte sie durch seine 8 Bit grundsätzlich speichern. Java muss jedoch mit der expliziten Typumwandlung gezwungen werden, das Vorzeichen-Bit zu ignorieren. Erst dann entspricht die Zahl 255 acht gesetzten Bits, denn sie mit byte b = 255; zu belegen, funktioniert nicht.

Damit die Weiterverarbeitung gelingt, muss noch eine andere Eigenschaft berücksichtigt werden. Sehen wir uns dazu folgende Ausgabe an:

byte b1 = (byte) 255;

byte b2 = -1;

System.out.println( b1 );  // -1

System.out.println( b2 );  // -1

Das Bit-Muster ist in beiden Fällen gleich, alle Bits sind gesetzt. Dass die Konsolenausgabe aber negativ ist, hat mit einer anderen Java-Eigenschaft zu tun: Java konvertiert das Byte, das vorzeichenbehaftet ist, bei der Weiterverarbeitung in ein int (der Parametertyp bei der Methode ist toBinaryString(int)), und bei dieser Konvertierung wandert das Vorzeichen vom byte zum int weiter. Das folgende Beispiel zeigt das bei der Binärausgabe:

byte b = (byte) 255;

int  i = 255;

System.out.printf( "%d %s%n", b, Integer.toBinaryString(b) );

// -1  11111111111111111111111111111111

System.out.printf( "%d %s%n", i, Integer.toBinaryString(i) );

// 255                         11111111

Die Belegung der unteren 8 Bit vom byte b und int i ist identisch. Aber während beim int die oberen 3 Byte wirklich null sind, füllt Java durch die automatische Anpassung des Vorzeichens bei der Konvertierung von byte nach int im Zweierkomplement auch die oberen 3 Byte mit 255 auf. Soll ohne Vorzeichen weitergerechnet werden, stört das. Diese automatische Anpassung nimmt Java immer vor, wenn mit byte/short gerechnet wird, und nicht nur wie in unserem Beispiel, wenn eine Methode den Datentyp int fordert.

Um bei der Weiterverarbeitung einen Datenwert zwischen 0 und 255 zu bekommen, also das Byte eines int vorzeichenlos zu sehen, schneiden wir mit der Und-Verknüpfung die unteren 8 Bit heraus – alle anderen Bits bleiben also ausgenommen:

byte b = (byte) 255;

System.out.println( b );          // -1

System.out.println( b & 0xff );   // 255

Es bleibt zu bemerken, dass die Und-Verknüpfung zu dem Zieltyp int führt.

Bibliotheksmethoden für vorzeichenlose Behandlung

Immer ein & 0xff an einen Ausdruck zu setzen, um die oberen Bytes auszublenden, ist zwar nicht sonderlich aufwendig, aber schön ist das auch nicht. Hübscher sind Methoden wie toUnsignedInt(byte), die mit dem Namen deutlich dokumentieren, was hier eigentlich passiert:

Methoden in Byte:

• static int toUnsignedInt(byte x)

• static long toUnsignedLong(byte x)

In Integer:

• static long toUnsignedLong(int x)

• static String toUnsignedString(int i, int radix)

• static String toUnsignedString(int i)

• static int parseUnsignedInt(String s, int radix)

• static int compareUnsigned(int x, int y)

• static int divideUnsigned(int dividend, int divisor)

• static int remainderUnsigned(int dividend, int divisor)

In Long:

• String toUnsignedString(long i, int radix)

• static String toUnsignedString(long i)

• static long parseUnsignedLong(String s, int radix)

• static int compareUnsigned(long x, long y)

• static long divideUnsigned(long dividend, long divisor)

• static long remainderUnsigned(long dividend, long divisor)

In Short:

• static int toUnsignedInt(short x)

• static long toUnsignedLong(short x)

Neben den einfachen toUnsignedXXX(…)-Methoden in den Wrapper-Klassen gesellen sich Methoden hinzu, die auch die Konvertierung in einen String und das Parsen eines Strings ermöglichen. Bei Integer und Long lassen sich ebenfalls neue Methoden ablesen, die Vergleiche, Division und Restwertbildung vorzeichenlos durchführen.

Konvertierungen von byte in ein char

Mit einer ähnlichen Arbeitsweise können wir auch die Frage lösen, wie sich ein Byte, dessen int-Wert im Minusbereich liegt, in ein char konvertieren lässt. Der erste Ansatz über eine Typumwandlung (char) byte ist falsch, und auf der Ausgabe dürfte nur ein rechteckiges Kästchen oder ein Fragezeichen erscheinen:

byte b = (byte) 'ß';

System.out.println( (char) b );         // Ausgabe ist  ?

Das Dilemma ist wieder die fehlerhafte Vorzeichenanpassung. Bei der Benutzung des Bytes wird es zuerst in ein int konvertiert. Das 'ß' wird dann zu –33. Im nächsten Schritt wird diese –33 dann in ein char umgesetzt. Das ergibt 65.503, was einen Unicode-Bereich trifft, der zurzeit kein Zeichen definiert. Es wird wohl auch noch etwas dauern, bis die ersten Außerirdischen uns neue Zeichensätze schenken. Gelöst wird der Fall wie oben, indem von b nur die unteren 8 Bit betrachtet werden. Das geschieht wieder durch ein Ausblenden über den Und-Operator. Damit ergibt sich korrekt:

char c = (char) (b & 0x00ff);

System.out.println( c );                // Ausgabe ist ß

In der Regel wird so eine explizite Anpassung selten im Code stehen, denn zur Konvertierung von Zeichenkodierungen bietet Java extra Klassen.

 

21.1.6    Die Verschiebeoperatoren 

Unter Java gibt es drei Verschiebeoperatoren (engl. shift-operators), die die Bits eines Werts um eine gewisse Anzahl an Positionen verschieben können:

• n << s: Linksverschieben der Bits von n um s Positionen

• n >> s: Arithmetisches Rechtsverschieben um s Positionen mit Vorzeichen

• n >>> s: Logisches Rechtsverschieben um s Positionen ohne Vorzeichen

Die binären Verschiebeoperatoren bewegen alle Bits eines Datenwortes (das Bit-Muster) nach rechts oder links. Bei der Verschiebung steht nach dem binären Operator, also im rechten Operanden, die Anzahl an Positionen, um die verschoben wird. Obwohl es nur zwei Richtungen gibt, muss noch der Fall betrachtet werden, ob das Vorzeichen bei der Rechtsverschiebung beachtet wird oder nicht. Das wird dann arithmetisches Verschieben (Vorzeichen bleibt erhalten) oder logisches Verschieben (Vorzeichen wird mit 0 aufgefüllt) genannt.

n << s

Die Bits des Operanden n werden unter Berücksichtigung des Vorzeichens s-mal nach links geschoben (bei jedem Schritt mit 2 multipliziert), was 2 hoch s ergibt. Der rechts frei werdende Bit-Platz wird immer mit 0 aufgefüllt. Das Vorzeichen ändert sich jedoch, sobald eine 1 von der Position MSB – 1 nach MSB geschoben wird. (MSB steht hier für Most Significant Bit, also das Bit mit der höchsten Wertigkeit in der binären Darstellung.)

System.out.println( 1 << 30 );  // 1073741824

System.out.println( 1 << 31 );  // -2147483648

System.out.println( 1 << 32 );  // 1

n >> s (arithmetisches Rechtsschieben)

Beim Verschieben nach rechts wird, je nachdem, ob das Vorzeichen-Bit gesetzt ist oder nicht, eine 1 oder eine 0 von links eingeschoben. Das linke Vorzeichen-Bit bleibt also unberührt.

Consumer<Integer> printBinary = value -> {

  String s = String.format( "%32s", Integer.toBinaryString( value ) );

  System.out.println( s.replace( ' ', '0' ) );

};

printBinary.accept( 0b10000000_00000000__00000000_00000000 >> 0 );

printBinary.accept( 0b10000000_00000000__00000000_00000000 >> 1);

printBinary.accept( 0b10000000_00000000__00000000_00000000 >> 2 );



printBinary.accept( 0b10000000_00000000__00000000_00000000 >>> 0 );

printBinary.accept( 0b10000000_00000000__00000000_00000000 >>> 1);

printBinary.accept( 0b10000000_00000000__00000000_00000000 >>> 2 );

10000000000000000000000000000000

11000000000000000000000000000000

11100000000000000000000000000000

10000000000000000000000000000000

01000000000000000000000000000000

00100000000000000000000000000000

System.out.println( 65535 >> 8 );  // 255

System.out.println(   255 << 8 );  // 65280

Bei den Ganzzahldatentypen folgt unter Berücksichtigung des immer vorhandenen Vorzeichens bei normalen Rechtsverschiebungen eine vorzeichenrichtige Ganzzahldivision durch 2.

n >>> s (logisches Rechtsschieben)

Der Operator >>> berücksichtigt das Vorzeichen der Variablen nicht, sodass eine vorzeichenlose Rechtsverschiebung ausgeführt wird. So werden auf der linken Seite (MSB) nur Nullen eingeschoben; das Vorzeichen wird mitgeschoben.

byte b1 = (byte)(v >>> 24),

     b2 = (byte)(v >>> 16),

     b3 = (byte)(v >>>  8),

     b4 = (byte)(v       );

Bei einer positiven Zahl hat dies keinerlei Auswirkungen, und das Verhalten ist wie beim >>-Operator.

System.out.println(  64 >>> 1 );  // 32

System.out.println( -64 >>> 1 );  // 2147483616

Ein <<<-Operator ergibt keinen Sinn, da die Linksverschiebung ohnehin nur Nullen rechts einfügt.

 

21.1.7    Ein Bit setzen, löschen, umdrehen und testen 

Die Bit-Operatoren lassen sich zusammen mit den Verschiebeoperatoren gut dazu verwenden, ein Bit zu setzen respektive herauszufinden, ob ein Bit gesetzt ist. Betrachten wir die folgenden Methoden, die ein bestimmtes Bit setzen, abfragen, invertieren und löschen:

static int setBit( int n, int pos ) {

  return n | (1 << pos);

}



static int clearBit( int n, int pos ) {

  return n & ~(1 << pos);

}



static int flipBit( int n, int pos ) {

  return n ^ (1 << pos);

}



static boolean testBit( int n, int pos ) {

  int mask = 1 << pos;



  return (n & mask) == mask;

  // alternativ: return (n & 1<<pos) != 0;

}

 

21.1.8    Bit-Methoden der Integer- und Long-Klasse 

Die Klassen Integer und Long bieten eine Reihe von statischen Methoden zur Bit-Manipulation und zur Abfrage diverser Bit-Zustände von ganzen Zahlen. Die Schreibweise int|long kennzeichnet durch int die statischen Methoden der Klasse Integer und durch long die statischen Methoden der Klasse Long.

final class java.lang.Integer | java.lang.Long

extends Number

implements Comparable<Integer> | implements Comparable<Long>

• static int Integer.bitCount(long i)

• static int Long.bitCount(long i)
  
  Liefern die Anzahl gesetzter Bits.

• static int Integer.reverse(int i)

• static long Long.reverse(long i)
  
  Drehen die Reihenfolge der Bits um.

• static int Integer.reverseBytes(int i)

• static long Long.reverseBytes(long i)
  
  Setzen die Bytes in die umgekehrte Reihenfolge, also das erste Byte an die letzte Position, das zweite Byte an die zweitletzte Position usw.

• static int Integer.rotateLeft(int i, int distance)

• static long Long.rotateLeft(long i, int distance)

• static int Integer.rotateRight(int i, int distance)

• static long Long.rotateRight(long i, int distance)
  
  Rotieren die Bits um distance Positionen nach links oder nach rechts.

• static int Integer.highestOneBit(int i)

• static long Long.highestOneBit(long i)

• static int Integer.lowestOneBit(int i)

• static long lowestOneBit(long i)
  
  Das Ergebnis ist i, wobei alle Bits gelöscht sind mit Ausnahme des höchst-/niedrigstwertigen Bits. Anders gesagt: Liefern einen Wert, wobei nur das höchste (links stehende) bzw. niedrigste (rechts stehende) Bit gesetzt ist. Es ist also nur höchstens 1 Bit gesetzt; beim Argument 0 ist natürlich kein Bit gesetzt und das Ergebnis ebenfalls 0.

• static int Integer.numberOfLeadingZeros(int i)

• static long Long.numberOfLeadingZeros(long i)

• static int Integer.numberOfTrailingZeros(int i)

• static long Long.numberOfTrailingZeros(long i)
  
  Liefern die Anzahl der Null-Bits vor dem höchsten bzw. nach dem niedrigsten gesetzten Bit.

Als Beispiel zeigt Tabelle 21.7 Anwendungen der statischen Bit-Methoden der Klasse Long:

Tabelle 21.7    Statische Methoden der Klasse »Long«