Rheinwerk Computing < openbook > Rheinwerk Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.
 
Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Imperative Sprachkonzepte
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Eigene Klassen schreiben
6 Objektorientierte Beziehungsfragen
7 Ausnahmen müssen sein
8 Äußere.innere Klassen
9 Besondere Typen der Java SE
10 Generics<T>
11 Lambda-Ausdrücke und funktionale Programmierung
12 Architektur, Design und angewandte Objektorientierung
13 Die Klassenbibliothek
14 Einführung in die nebenläufige Programmierung
15 Einführung in Datenstrukturen und Algorithmen
16 Einführung in grafische Oberflächen
17 Einführung in Dateien und Datenströme
18 Einführung ins Datenbankmanagement mit JDBC
19 Einführung in <XML>
20 Testen mit JUnit
21 Bits und Bytes und Mathematisches
22 Die Werkzeuge des JDK
A Java SE Paketübersicht
Stichwortverzeichnis

Download:
- Beispielprogramme, ca. 20,0 MB
- Übungsaufgaben, ca. 1,8 MB
- Musterlösungen, ca. 0,8 MB

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Java ist auch eine Insel von Christian Ullenbloom
Das umfassende Handbuch
Buch: Java ist auch eine Insel

Java ist auch eine Insel
Rheinwerk Computing
1306 Seiten, gebunden, 11. Auflage
49,90 Euro, ISBN 978-3-8362-2873-2
Pfeil 21 Bits und Bytes und Mathematisches
Pfeil 21.1 Bits und Bytes *
Pfeil 21.1.1 Die Bit-Operatoren Komplement, Und, Oder und XOR
Pfeil 21.1.2 Repräsentation ganzer Zahlen in Java – das Zweierkomplement
Pfeil 21.1.3 Das binäre (Basis 2), oktale (Basis 8), hexadezimale (Basis 16) Stellenwertsystem
Pfeil 21.1.4 Auswirkung der Typanpassung auf die Bitmuster
Pfeil 21.1.5 Vorzeichenlos arbeiten
Pfeil 21.1.6 Die Verschiebeoperatoren
Pfeil 21.1.7 Ein Bit setzen, löschen, umdrehen und testen
Pfeil 21.1.8 Bit-Methoden der Integer- und Long-Klasse
Pfeil 21.2 Fließkomma-Arithmetik in Java
Pfeil 21.2.1 Spezialwerte für Unendlich, Null, NaN
Pfeil 21.2.2 Standardnotation und wissenschaftliche Notation bei Fließkommazahlen *
Pfeil 21.2.3 Mantisse und Exponent *
Pfeil 21.3 Die Eigenschaften der Klasse Math
Pfeil 21.3.1 Attribute
Pfeil 21.3.2 Absolutwerte und Vorzeichen
Pfeil 21.3.3 Maximum/Minimum
Pfeil 21.3.4 Runden von Werten
Pfeil 21.3.5 Rest der ganzzahligen Division *
Pfeil 21.3.6 Division mit Rundung Richtung negativ unendlich, alternativer Restwert *
Pfeil 21.3.7 Wurzel- und Exponentialmethoden
Pfeil 21.3.8 Der Logarithmus *
Pfeil 21.3.9 Winkelmethoden *
Pfeil 21.3.10 Zufallszahlen
Pfeil 21.4 Genauigkeit, Wertebereich eines Typs und Überlaufkontrolle *
Pfeil 21.4.1 Der größte und der kleinste Wert
Pfeil 21.4.2 Überlauf
Pfeil 21.4.3 Was bitte macht ein ulp?
Pfeil 21.5 Zufallszahlen: Random, SecureRandom, SplittableRandom
Pfeil 21.5.1 Die Klasse Random
Pfeil 21.5.2 Random-Objekte mit dem Samen aufbauen
Pfeil 21.5.3 Einzelne Zufallszahlen erzeugen
Pfeil 21.5.4 Pseudo-Zufallszahlen in der Normalverteilung *
Pfeil 21.5.5 Strom von Zufallszahlen generieren *
Pfeil 21.5.6 Die Klasse SecureRandom *
Pfeil 21.5.7 SplittableRandom *
Pfeil 21.6 Große Zahlen *
Pfeil 21.6.1 Die Klasse BigInteger
Pfeil 21.6.2 Beispiel: Ganz lange Fakultäten mit BigInteger
Pfeil 21.6.3 Große Fließkommazahlen mit BigDecimal
Pfeil 21.6.4 Mit MathContext komfortabel die Rechengenauigkeit setzen
Pfeil 21.7 Mathe bitte strikt *
Pfeil 21.7.1 Strikte Fließkommaberechnungen mit strictfp
Pfeil 21.7.2 Die Klassen Math und StrictMath
Pfeil 21.8 Zum Weiterlesen
 
Zum Seitenanfang

21Bits und Bytes und Mathematisches Zur vorigen ÜberschriftZur nächsten Überschrift

»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 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 die Klasse Math realisiert.

 
Zum Seitenanfang

21.1Bits und Bytes * Zur vorigen ÜberschriftZur nächsten Überschrift

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. Da jedes Bit anders belegt sein kann, bildet es in der Summe unterschiedliche Werte. Werden 8 Bit zugrunde gelegt, lassen. sich durch unterschiedliche Belegungen 256 unterschiedliche Zahlen bilden. Ist kein Bit des Bytes gesetzt, so ist die Zahl 0. Jede Stelle im Byte bekommt dabei eine Wertigkeit zugeordnet. Die Wertebelegung für die Zahl 19 berechnet sich aus 16 + 2 + 1, da sie aus einer Anzahl von Summanden der Form 2^n zusammengesetzt ist: 19dez = 16 + 2 + 1 = 1 × 2^4 + 0 × 2^3 + 0 × 2^2 + 1 × 2^1 + 1 × 2^0 = 10011bin.

Bit

7

6

5

4

3

2

1

0

Wertigkeit

27=128

26=64

25=32

24=16

23=8

22=4

21=2

20=1

Belegung für 19

0

0

0

1

0

0

1

1

Tabelle 21.1Wertebelegung

 
Zum Seitenanfang

21.1.1Die Bit-Operatoren Komplement, Und, Oder und XOR Zur vorigen ÜberschriftZur nächsten Überschrift

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 Verknüpfungen, Schiebeoperationen und das Komplement. Durch die bitweisen Operatoren können einzelne Bits abgefragt und manipuliert werden. Als Verknüpfungen bietet Java die folgenden Bit-Operatoren an:

Operator

Bezeichnung

Aufgabe

~

Komplement

Invertiert jedes Bit.

|

bitweises Oder

Bei a | b wird jedes Bit von a und b einzeln Oder-verknüpft.

&

bitweises Und

Bei a & b wird jedes Bit von a und b einzeln
Und-verknüpft.

^

bitweises exklusives Oder (XOR)

Bei a ^ b wird jedes Bit von a und b einzeln
XOR-verknüpft; es ist kein a hoch b.

Tabelle 21.2Bit-Operatoren in Java

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. Fassen wir das Ergebnis noch einmal in einer Tabelle zusammen:

Bit 1

Bit 2

~Bit 1

Bit 1 & Bit 2

Bit 1 | Bit 2

Bit 1 ^ Bit 2

0

0

1

0

0

0

0

1

1

0

1

1

1

0

0

0

1

1

1

1

0

1

1

0

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

Nehmen wir zum Beispiel zwei Ganzahlen:

Binär

dezimal

Zahl 1

010011

16 + 2 + 1 = 19

Zahl 2

100010

32 + 2 = 34

Zahl 1 & Zahl 2

000010

19 & 34 = 2

Zahl 1 | Zahl 2

110011

19 | 34 = 51

Zahl 1 ^ Zahl 2

110001

19 ^ 34 = 49

Tabelle 21.4Binäre Verknüpfung zweier Ganzzahlen

 
Zum Seitenanfang

21.1.2Repräsentation ganzer Zahlen in Java – das Zweierkomplement Zur vorigen ÜberschriftZur nächsten Überschrift

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.

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 Bitmaske 0000…0000.

dezimal

binär

hexadezimal

–32.768

1000 0000 0000 0000

80 00

–32.767

1000 0000 0000 0001

80 01

–32.766

1000 0000 0000 0010

80 02

–2

1111 1111 1111 1110

FF FE

–1

1111 1111 1111 1111

FF FF

0

0000 0000 0000 0000

00 00

1

0000 0000 0000 0001

00 01

2

0000 0000 0000 0010

00 02

32.766

0111 1111 1111 1110

7F FE

32.767

0111 1111 1111 1111

7F FF

Tabelle 21.5Darstellungen des Zweierkomplements im Datentyp short

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

 
Zum Seitenanfang

21.1.3Das binäre (Basis 2), oktale (Basis 8), hexadezimale (Basis 16) Stellenwertsystem Zur vorigen ÜberschriftZur nächsten Überschrift

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.

Präfix

Stellenwertsystem

Basis

Darstellung von 1

0b oder 0B

binär

2

0b1 oder 0B1

0

oktal

8

01

kein

dezimal

10

1

0x oder 0X

hexadezimal

16

0x1 oder 0X1

Tabelle 21.6Die 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.[ 254 ]

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«, was auf Deutsch »acht« heißt. Das Oktalsystem war früher eine verbreitete Darstellung, da nicht mehr einzelne Bits solo betrachtet werden mussten, sondern 3 Bits 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) ist das Präfix »0b« oder »0B«. Es sind nur die Ziffern »0« und »1« erlaubt, ein klassischer Fall für 2.

[zB]Beispiel

Gib Dezimal-, Binär, Oktal- und Hexadezimalzahlen aus:

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

In Java-Programmen sollten Oktalzahlen mit Bedacht eingesetzt werden. Wer aus optischen Gründen mit der 0 eine Zahl linksbündig auffüllt, erlebt eine Überraschung:

int i = 118;
int j = 012; // Oktal 012 ist dezimal 10
 
Zum Seitenanfang

21.1.4Auswirkung der Typanpassung auf die Bitmuster Zur vorigen ÜberschriftZur nächsten Überschrift

Die Typanpassung 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.1TypecastDemo.java, main()

int ii = 123456789; // 00000111010110111100110100010101
int ij = –123456; // 11111111111111100001110111000000

short si = (short) ii; // 1100110100010101
short sj = (short) ij; // 0001110111000000

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 Vorzeichenbit weichen muss.

Typanpassungen 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 doublelong 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 ein 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 an ein double und auch an 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, 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^15 – 1 und die Umwandlung nicht gesichert, da die Programmierer diesen Zahlenbereich nicht angenommen hatten. 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.

 
Zum Seitenanfang

21.1.5Vorzeichenlos arbeiten Zur vorigen ÜberschriftZur nächsten Überschrift

Bis auf char sind in Java alle integralen Datentypen vorzeichenbehaftet und kodiert im Zweierkomplement. 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 Typanpassung bei Ganzzahltypen ist es, dass die überschüssigen Bytes einfach abgeschnitten werden. Betrachten wir die Typanpassung 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 diese durch seine 8 Bit grundsätzlich speichern. Java muss jedoch mit der expliziten Typanpassung 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 Bitmuster 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, welches 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 auf 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

Bibliotheksmethoden für vorzeichenlose Behandlung

Immer ein & 0xff an einen Ausdruck zu setzen, um die oberen Bytes auszublenden, ist zwar nicht sonderlich aufwändig, aber schön ist das auch nicht. Hübscher sind Methoden wie toUnsignedInt(byte), die mit dem Namen deutlich dokumentieren, was hier eigentlich passiert. In Java 8 gibt es daher einige Neuerungen:

Neue 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 einem String bzw. 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 Integer-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 zu einem 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.

 
Zum Seitenanfang

21.1.6Die Verschiebeoperatoren Zur vorigen ÜberschriftZur nächsten Überschrift

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 Bitmuster) 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 verschiebt sich mit) 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 (mit 2 multipliziert). Der rechts frei werdende Bit-Platz wird immer mit 0 aufgefüllt. Das Vorzeichen ändert sich jedoch, sobald eine 1 von der Position MSB1 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).

[+]Hinweis

Zwar ist der Datentyp des rechten Operanden erst einmal ein int bzw. long mit vollem Wertebereich, doch als Verschiebepositionen sind bei int nur Werte bis 31 sinnvoll und für ein long Werte bis 63 Bit, da nur die letzten 5 bzw. 6 Bit berücksichtigt werden. Sonst wird immer um den Wert verschoben, der sich durch das Teilen durch 32 bzw. 64 als Rest ergibt, sodass x << 32 und x << 0 auch gleich ist.

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 Vorzeichenbit gesetzt ist oder nicht, eine 1 oder eine 0 von links eingeschoben; das linke Vorzeichenbit bleibt unberührt.

[zB]Beispiel

Ein herausgeschobenes Bit ist für immer verloren!

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

Es ist 65.535 = 0xFFFF, und nach der Rechtsverschiebung 65.535 >> 8 ergibt sich 0x00FF = 255. Schieben wir nun wieder nach links, also 0x00FF << 8, dann ist das Ergebnis 0xFF00 = 65.280.

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 mit geschoben.

[zB]Beispiel

Mit den Verschiebeoperatoren lassen sich die einzelnen Bytes eines größeren Datentyps, etwa eines 4 Byte großen int, einfach extrahieren:

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.

[zB]Beispiel

Die Ausgabe ist für den negativen Operanden besonders spannend:

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.

 
Zum Seitenanfang

21.1.7Ein Bit setzen, löschen, umdrehen und testen Zur vorigen ÜberschriftZur nächsten Überschrift

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;
}
 
Zum Seitenanfang

21.1.8Bit-Methoden der Integer- und Long-Klasse Zur vorigen ÜberschriftZur nächsten Überschrift

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)
    Liefert die Anzahl gesetzter Bits.

  • static int Integer.reverse(int i)

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

  • static int Integer.reverseBytes(int i)

  • static long Long.reverseBytes(long i)
    Setzt 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)
    Rotiert 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)
    Liefert 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 null.

  • static int Integer.numberOfLeadingZeros(int i)

  • static long Long.numberOfLeadingZeros(long i)

  • static int Integer.numberOfTrailingZeros(int i)

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

[zB]Beispiel

Anwendung der statischen Bit-Methoden der Klasse Long.

Statische Methode der Klasse Long

Methodenergebnis

Long.highestOneBit( 81 )

4

Long.lowestOneBit( 2 + 4 )

2

Long.numberOfLeadingZeros( Long.MAX_VALUE )

1

Long.numberOfLeadingZeros( -Long.MAX_VALUE )

0

Long.numberOfTrailingZeros( 16 )

4

Long.numberOfTrailingZeros( 3 )

0

Long.bitCount( 8 + 4 + 1 )

3

Long.rotateLeft( 12, 1 )

24

Long.rotateRight( 12, 1 )

6

Long.reverse( Long.MAX_VALUE )

–2

Long.reverse( 0x0F00000000000000L )

240

Long.reverseBytes( 0x0F00000000000000L )

15

Tabelle 21.7Statische Methoden der Klasse Long

 


Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.

>> Zum Feedback-Formular
<< zurück
 Zum Katalog
Zum Katalog: Java ist auch eine Insel Java ist auch eine Insel
Jetzt bestellen

 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Java SE 8 Standard-Bibliothek
Java SE 8 Standard-Bibliothek


Zum Katalog: Professionell entwickeln mit Java EE 7
Professionell entwickeln mit Java EE 7


Zum Katalog: Schrödinger programmiert Java
Schrödinger programmiert Java


Zum Katalog: Einführung in Java
Einführung in Java


Zum Katalog: Programmieren lernen mit Java
Programmieren lernen mit Java


Zum Katalog: Apps entwickeln für Android 5
Apps entwickeln für Android 5


Zum Katalog: Apps entwickeln mit Android Studio
Apps entwickeln mit Android Studio


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo

 
 


Copyright © Rheinwerk Verlag GmbH 2016
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

 
Nutzungsbestimmungen | Datenschutz | Impressum

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de