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 Komponenten, JavaBeans und Module
14 Die Klassenbibliothek
15 Einführung in die nebenläufige Programmierung
16 Einführung in Datenstrukturen und Algorithmen
17 Einführung in grafische Oberflächen
18 Einführung in Dateien und Datenströme
19 Einführung ins Datenbankmanagement mit JDBC
20 Einführung in <XML>
21 Testen mit JUnit
22 Bits und Bytes und Mathematisches
23 Die Werkzeuge des JDK
A Java SE-Paketübersicht
Stichwortverzeichnis


Download:

- Beispielprogramme, ca. 35,4 MB


Buch bestellen
Ihre Meinung?



Spacer
<< zurück
Java ist auch eine Insel von Christian Ullenboom

Einführung, Ausbildung, Praxis
Buch: Java ist auch eine Insel


Java ist auch eine Insel

Pfeil 22 Bits und Bytes und Mathematisches
Pfeil 22.1 Bits und Bytes *
Pfeil 22.1.1 Die Bit-Operatoren Komplement, Und, Oder und XOR
Pfeil 22.1.2 Repräsentation ganzer Zahlen in Java – das Zweierkomplement
Pfeil 22.1.3 Das binäre (Basis 2), oktale (Basis 8), hexadezimale (Basis 16) Stellenwertsystem
Pfeil 22.1.4 Auswirkung der Typumwandlung auf die Bit-Muster
Pfeil 22.1.5 Vorzeichenlos arbeiten
Pfeil 22.1.6 Die Verschiebeoperatoren
Pfeil 22.1.7 Ein Bit setzen, löschen, umdrehen und testen
Pfeil 22.1.8 Bit-Methoden der Integer- und Long-Klasse
Pfeil 22.2 Fließkomma-Arithmetik in Java
Pfeil 22.2.1 Spezialwerte für Unendlich, Null, NaN
Pfeil 22.2.2 Standardnotation und wissenschaftliche Notation bei Fließkommazahlen *
Pfeil 22.2.3 Mantisse und Exponent *
Pfeil 22.3 Die Eigenschaften der Klasse Math
Pfeil 22.3.1 Attribute
Pfeil 22.3.2 Absolutwerte und Vorzeichen
Pfeil 22.3.3 Maximum/Minimum
Pfeil 22.3.4 Runden von Werten
Pfeil 22.3.5 Rest der ganzzahligen Division *
Pfeil 22.3.6 Division mit Rundung Richtung negativ unendlich, alternativer Restwert *
Pfeil 22.3.7 Wurzel- und Exponentialmethoden
Pfeil 22.3.8 Der Logarithmus *
Pfeil 22.3.9 Winkelmethoden *
Pfeil 22.3.10 Zufallszahlen
Pfeil 22.4 Genauigkeit, Wertebereich eines Typs und Überlaufkontrolle *
Pfeil 22.4.1 Der größte und der kleinste Wert
Pfeil 22.4.2 Überlauf
Pfeil 22.4.3 Was bitte macht eine ulp?
Pfeil 22.5 Zufallszahlen: Random, SecureRandom, SplittableRandom
Pfeil 22.5.1 Die Klasse Random
Pfeil 22.5.2 Random-Objekte mit dem Samen aufbauen
Pfeil 22.5.3 Einzelne Zufallszahlen erzeugen
Pfeil 22.5.4 Pseudo-Zufallszahlen in der Normalverteilung *
Pfeil 22.5.5 Strom von Zufallszahlen generieren *
Pfeil 22.5.6 Die Klasse SecureRandom *
Pfeil 22.5.7 SplittableRandom *
Pfeil 22.6 Große Zahlen *
Pfeil 22.6.1 Die Klasse BigInteger
Pfeil 22.6.2 Beispiel: ganz lange Fakultäten mit BigInteger
Pfeil 22.6.3 Große Fließkommazahlen mit BigDecimal
Pfeil 22.6.4 Mit MathContext komfortabel die Rechengenauigkeit setzen
Pfeil 22.7 Mathe bitte strikt *
Pfeil 22.7.1 Strikte Fließkommaberechnungen mit strictfp
Pfeil 22.7.2 Die Klassen Math und StrictMath
Pfeil 22.8 Zum Weiterlesen
 

Zum Seitenanfang

22.3Die Eigenschaften der Klasse Math Zur vorigen ÜberschriftZur nächsten Überschrift

Die Klasse java.lang.Math ist eine typische Utility-Klasse, die nur statische Methoden (bzw. Attribute als Konstanten) deklariert. Mit dem privaten Konstruktor lassen sich (so leicht) keine Exemplare von Math erzeugen.

 

Zum Seitenanfang

22.3.1Attribute Zur vorigen ÜberschriftZur nächsten Überschrift

Die Math-Klasse besitzt zwei statische Attribute:

class java.lang.Math
 

Zum Seitenanfang

22.3.2Absolutwerte und Vorzeichen Zur vorigen ÜberschriftZur nächsten Überschrift

Die zwei statischen abs(…)-Methoden liefern den Betrag des Arguments (mathematische Betragsfunktion: y = |x|). Sollte ein negativer Wert als Argument übergeben werden, wandelt ihn abs(…) in einen positiven Wert um.

Eine spezielle Methode ist auch copySign(double, double). Sie ermittelt das Vorzeichen einer Fließkommazahl und setzt dieses Vorzeichen bei einer anderen.

class java.lang.Math
  • static int abs(int x)

  • static long abs(long x)

  • static float abs(float x)

  • static double abs(double x)

  • static double copySign(double magnitude, double sign)

  • static float copySign(float magnitude, float sign)

    Liefert magnitude als Rückgabe, aber mit dem Vorzeichen von sign.

[»]Hinweis

Es gibt genau einen Wert, auf den Math.abs(int) keine positive Rückgabe liefern kann:

–2.147.483.648. Dies ist die kleinste darstellbare int-Zahl (Integer.MIN_VALUE), während +2.147.483.648 gar nicht in ein int passt! Die größte darstellbare int-Zahl ist 2.147.483.647 (Integer.MAX_VALUE). Was sollte abs(-2147483648) auch ergeben?

Vorzeichen erfragen

Die statische Methode signum(value) liefert eine numerische Rückgabe für das Vorzeichen von value, und zwar +1 für positive, –1 für negative Zahlen und 0 für 0. Die Methode ist nicht ganz logisch auf die Klassen Math für Fließkommazahlen und Integer/Long für Ganzzahlen verteilt:

  • java.lang.Integer.signum(int i)

  • java.lang.Long.signum(long i)

  • java.lang.Math.signum(double d)

  • java.lang.Math.signum(float f)

 

Zum Seitenanfang

22.3.3Maximum/Minimum Zur vorigen ÜberschriftZur nächsten Überschrift

Die statischen max(…)-Methoden liefern den größeren der übergebenen Werte. Die statischen min(…)-Methoden liefern den kleineren von zwei Werten als Rückgabewert.

class java.lang.Math
  • static int max(int x, int y)

  • static long max(long x, long y)

  • static float max( float x, float y )

  • static double max(double x, double y)

  • static int min(int x, int y)

  • static long min(long x, long y)

  • static float min(float x, float y)

  • static double min(double x, double y)

 

Zum Seitenanfang

22.3.4Runden von Werten Zur vorigen ÜberschriftZur nächsten Überschrift

Für die Rundung von Werten bietet die Klasse Math fünf statische Methoden:

class java.lang.Math
  • static double ceil(double a)

  • static double floor(double a)

  • static int round(float a)

  • static long round(double a)

  • static double rint(double a)

Auf- und Abrunden mit ceil(double) und floor(double)

Die statische Methode ceil(double) dient dem Aufrunden und liefert die nächsthöhere Ganzzahl (jedoch als double, nicht als long), wenn die Zahl nicht schon eine ganze Zahl ist; die statische Methode floor(double) rundet auf die nächstniedrigere Ganzzahl ab:

Listing 22.2Rounding1Demo.java, main()

System.out.println( Math.ceil(-99.1) ); // –99.0

System.out.println( Math.floor(-99.1) ); // –100.0

System.out.println( Math.ceil(-99) ); // –99.0

System.out.println( Math.floor(-99) ); // –99.0

System.out.println( Math.ceil(-.5) ); // –0.0

System.out.println( Math.floor(-.5) ); // –1.0

System.out.println( Math.ceil(-.01) ); // –0.0

System.out.println( Math.floor(-.01) ); // –1.0

System.out.println( Math.ceil(0.1) ); // 1.0

System.out.println( Math.floor(0.1) ); // 0.0

System.out.println( Math.ceil(.5) ); // 1.0

System.out.println( Math.floor(.5) ); // 0.0

System.out.println( Math.ceil(99) ); // 99.0

System.out.println( Math.floor(99) ); // 99.0

Die genannten statischen Methoden haben auf ganze Zahlen keine Auswirkung.

Kaufmännisches Runden mit round(…)

Die statischen Methoden round(double) und round(float) runden kaufmännisch auf die nächste Ganzzahl vom Typ long bzw. int. Ganze Zahlen werden nicht aufgerundet. Wir können round(…) als Gegenstück zur Typumwandlung (long) doublevalue einsetzen:

Listing 22.3Rounding2Demo.java, main()

System.out.println( Math.round(1.01) ); // 1

System.out.println( Math.round(1.4) ); // 1

System.out.println( Math.round(1.5) ); // 2

System.out.println( Math.round(1.6) ); // 2

System.out.println( (int) 1.6 ); // 1

System.out.println( Math.round(30) ); // 30

System.out.println( Math.round(-2.1) ); // –2

System.out.println( Math.round(-2.9) ); // –3

System.out.println( (int) –2.9 ); // –2

Interna

Die Methoden Math.round(int) und Math.round(long) sind in Java ausprogrammiert. Sie addieren zum aktuellen Parameter 0,5 und übergeben das Ergebnis der statischen floor(double)-Methode.

Listing 22.4java.lang.Math, round(double), etwas gekürzt

public static long round( double a ) {

return (long) floor( a + 0.5 );

}

Gerechtes Runden rint(double)

rint(double) ist mit round(…) vergleichbar, nur ist es im Gegensatz zu round(…) gerecht, was bedeutet, dass rint(double) bei 0,5 in Abhängigkeit davon, ob die benachbarte Zahl ungerade oder gerade ist, auf- oder abrundet:

Listing 22.5Rounding3Demo.java, main()

System.out.println( Math.round(-1.5) ); // –1

System.out.println( Math.rint( –1.5) ); // –2.0

System.out.println( Math.round(-2.5) ); // –2

System.out.println( Math.rint( –2.5) ); // –2.0

System.out.println( Math.round( 1.5) ); // 2

System.out.println( Math.rint( 1.5) ); // 2.0

System.out.println( Math.round( 2.5) ); // 3

System.out.println( Math.rint( 2.5) ); // 2.0

Mit einem konsequenten Auf- oder Abrunden pflanzen sich natürlich auch Fehler ungeschickter fort als mit dieser 50/50-Strategie.

[zB]Beispiel

Die statische rint(double)-Methode lässt sich auch einsetzen, wenn Zahlen auf zwei Nachkommastellen gerundet werden sollen. Ist d vom Typ double, so ergibt der Ausdruck Math. rint(d*100.0)/100.0 die gerundete Zahl.

Listing 22.6Round2Scales.java

class Round2Scales {

public static double roundScale2( double d ) {

return Math.rint( d * 100 ) / 100.;

}



public static void main( String[] args ) {

System.out.println( roundScale2(+1.341 ) ); // 1.34

System.out.println( roundScale2(–1.341 ) ); // –1.34

System.out.println( roundScale2(+1.345 ) ); // 1.34

System.out.println( roundScale2(–1.345 ) ); // –1.34



System.out.println( roundScale2(+1.347 ) ); // 1.35

System.out.println( roundScale2(–1.347 ) ); // –1.35

}

}

Arbeiten wir statt mit rint(double) mit round(…), wird die Zahl 1,345 nicht auf 1,34, sondern auf 1,35 gerundet. Wer nun Lust hat, etwas auszuprobieren, darf testen, wie der Format-String %.2f bei printf(…) rundet.

 

Zum Seitenanfang

22.3.5Rest der ganzzahligen Division * Zur vorigen ÜberschriftZur nächsten Überschrift

Neben dem Restwert-Operator %, der den Rest der Division berechnet, gibt es auch eine statische Methode Math.IEEEremainder(double, double).

Listing 22.7IEEEremainder.java, main()

double a = 44.0;

double b = 2.2;

System.out.println( a / b ); // 20.0

System.out.println( a % b ); // 2.1999999999999966

System.out.println( Math.IEEEremainder( a, b ) ); // –3.552713678800501E-15

Das zweite Ergebnis ist mit der mathematischen Ungenauigkeit fast 2,2, aber etwas kleiner, sodass der Algorithmus nicht noch einmal 2,2 abziehen konnte. Die statische Methode IEEEremainder(double, double) liefert ein Ergebnis nahe null (–0,000000000000003552713 6788005), was besser ist, denn 44,0 lässt sich ohne Rest durch 2,2 teilen, also wäre der Rest eigentlich 0.

class java.lang.Math
  • static double IEEEremainder(double dividend, double divisor)

    Liefert den Rest der Division von Dividend und Divisor, so wie es der IEEE-754-Standard vorschreibt.

Eine eigene statische Methode, die mitunter bessere Ergebnisse liefert – mit den Werten 44 und 2,2 wirklich 0,0 –, ist die folgende:

public static double remainder( double a, double b ) {

return Math.signum(a) *

(Math.abs(a) – Math.abs(b) * Math.floor(Math.abs(a)/Math.abs(b)));

}
 

Zum Seitenanfang

22.3.6Division mit Rundung Richtung negativ unendlich, alternativer Restwert * Zur vorigen ÜberschriftZur nächsten Überschrift

Die Ganzzahldivision in Java ist simpel gestrickt. Vereinfacht ausgedrückt: Konvertiere die Ganzzahlen in Fließkommazahlen, führe die Division durch und schneide alles hinter dem Komma ab. So ergeben zum Beispiel 3 / 2 = 1 und 9 / 2 = 4. Bei negativem Ergebnis, durch entweder negativen Dividenden oder Divisor, das gleiche Spiel: -9 / 2 = -4 und 9 / -2 = -4. Schauen wir uns einmal die Rundungen an.

Ist das Ergebnis einer Division positiv und mit Nachkommaanteil, so wird das Ergebnis durch das Abschneiden der Nachkommastellen ein wenig kleiner, also abgerundet. Wäre 3/2 bei Fließkommazahlen 1,5, ist es bei einer Ganzzahldivision abgerundet 1. Bei negativen Ergebnissen einer Division ist das genau andersherum, denn durch das Abschneiden der Nachkommastellen wird die Zahl etwas größer. -3/2 ist genau genommen –1,5, aber bei der Ganzzahldivision -1. Doch -1 ist größer als –1,5. Java wendet ein Verfahren an, das gegen null rundet.

Methoden für Division gegen minus unendlich, floorDiv(…)

Zwei Methoden runden bei negativem Ergebnis einer Division nicht gegen null, sondern gegen negativ unendlich, also auch in Richtung der kleineren Zahl, wie es bei den positiven Ergebnissen ist.

class java.lang.Math

class java.lang.StrictMath
  • static int floorDiv(int x, int y)

  • static long floorDiv(long x, long y)

Ganz praktisch heißt das: 4/2 = Math.floorDiv(4, 3) = 1, aber wo -4 / 3 = -1 ergibt, liefert Math.floorDiv(-4, 3) = -2.

Methoden für Division gegen minus unendlich, floorMod(…)

Die Division taucht indirekt auch bei der Berechnung des Restwerts auf. Zur Erinnerung: Der Zusammenhang zwischen Division a/b und Restwert a%b (a heißt Dividend, b Divisor) ist (int)(a/b) * b + (a%b) = a. In der Gleichung gibt es eine Division, doch da es mit a / b und floorDiv(a, b) zwei Arten von Divisionen gibt, muss es folglich auch zwei Arten von Restwertbildung geben, die sich dann unterscheiden, wenn die Vorzeichen unterschiedlich sind. Neben a % b gibt es daher die Bibliotheksmethode floorMod(a, b), und der Zusammenhang zwischen floorMod(…) und floorDiv(…) ist: floorDiv(a, b) * b + floorMod(a, b) == b. Nach einer Umformung der Gleichung folgt floorMod(a, b) = a - (floorDiv(a, b) * b). Das Ergebnis ist im Bereich -abs(b) und abs(b), und das Vorzeichen des Ergebnisses bestimmt der Divisor b (beim %-Operator ist es der Dividend a).

Die Javadoc zeigt ein Beispiel mit den Werten 4 und 3 bei unterschiedlichen Vorzeichen:

floorMod(…)-Methode

%-Operator

floorMod(+4, +3) == +1

+4 % +3 == +1

floorMod(+4, -3) == -2

+4 % -3 == +1

floorMod(-4, +3) == +2

-4 % +3 == -1

floorMod(-4, -3) == -1

-4 % -3 == -1

Tabelle 22.11Ergebnis unterschiedlicher Restwertbildung

Sind die Vorzeichen für a und b identisch, so ist auch das Ergebnis von floorMod(a, b) und a % b gleich. Die Beispiele in der Tabelle machen auch den Unterschied im Ergebnisvorzeichen deutlich, das einmal vom Dividenden (%) und einmal vom Divisor (floorMod(…)) kommt. Die komplett anderen Ereignisse (vom Vorzeichen einmal abgesehen) beim Paar (+4, –3) und (–4, +3) ergeben sich ganz einfach aus unterschiedlichen Ergebnissen der Division:

floorMod(+4, -3) = +4 - (floorDiv(+4, -3) * -3) = +4 - (-2 * -3) = +4 - +6 =

-2 +4 % -3 = +4 - (+4/-3 * -3) = +4 – (-1 * -3) = +4 – 3 = +1
class java.lang.Math

class java.lang.StrictMath
  • static int floorMod(int x, int y)

  • static long floorMod(long x, long y)

    implementiert im Methodenrumpf mit return x - floorDiv(x, y) * y;

 

Zum Seitenanfang

22.3.7Wurzel- und Exponentialmethoden Zur vorigen ÜberschriftZur nächsten Überschrift

Die Math-Klasse bietet außerdem Methoden zum Berechnen der Wurzel und weitere Exponentialmethoden:

class java.lang.Math
  • static double sqrt(double x)

    Liefert die Quadratwurzel von x; sqrt steht für square root.

  • static double cbrt(double a)

    Berechnet die dritte Wurzel aus a.

  • static double hypot(double x, double y)

    Berechnet die Wurzel aus x2 + y2, also den euklidischen Abstand. Könnte als sqrt(x*x, y*y) umgeschrieben werden, doch hypot(…) bietet eine bessere Genauigkeit und Performance.

  • static double scalb(double d, double scaleFactor)

    Liefert d mal 2 hoch scaleFactor. Kann prinzipiell auch als d * Math.pow(2, scaleFactor) geschrieben werden, doch scalb(…) bietet eine bessere Performance.

  • static double exp(double x)

    Liefert den Exponentialwert von x zur Basis e (der eulerschen Zahl e = 2,71828…), also ex.

  • static double expm1(double x)

    Liefert den Exponentialwert von x zur Basis e minus 1, also ex – 1. Berechnungen nahe null kann expm1(x) + 1 präziser ausdrücken als exp(x).

  • static double pow(double x, double y)

    Liefert den Wert der Potenz xy. Für ganzzahlige Werte gibt es keine eigene Methode.

Die Frage nach dem 0.0/0.0 und 0.0^0.0 *

Wie wir wissen, ist 0.0/0.0 ein glattes NaN. Im Unterschied zu den Ganzzahlwerten bekommen wir hier allerdings keine Exception, denn dafür ist extra die Spezialzahl NaN eingeführt worden. Interessant ist die Frage, was denn (long)(double)(0.0/0.0) ergibt. Die Sprachdefinition sagt hier in § 5.1.3, dass die Konvertierung eines Fließkommawerts NaN in ein int 0 oder in ein long 0 ergibt.[ 263 ](Leider gab es in den ersten Versionen der JVM einen Fehler, sodass Long.MAX_VALUE an Stelle von 0.0 produziert wurde. Dieser Fehler ist lange behoben. )

Eine weitere spannende Frage ist das Ergebnis von 0.0^0.0. Um allgemeine Potenzen zu berechnen, wird die statische Funktion Math.pow(double a, double b) eingesetzt. Wir erinnern uns aus der Schulzeit daran, dass wir die Quadratwurzel einer Zahl ziehen, wenn der Exponent b genau 1/2 ist. Doch jetzt wollen wir wissen, was denn gilt, wenn a = b = 0 gilt. § 20.11.13 der Sprachdefinition fordert, dass das Ergebnis immer 1.0 ist, wenn der Exponent b gleich –0.0 oder 0.0 ist. Es kommt also in diesem Fall überhaupt nicht auf die Basis a an. In einigen Algebra-Büchern wird 0^0 als undefiniert behandelt. Es macht aber durchaus Sinn, 0^0 als 1 zu definieren, da es andernfalls viele Sonderbehandlungen für 0 geben müsste.[ 264 ](Hier schreiben die Autoren R. Graham, D. Knuth, O. Patashnik des Buchs Concrete Mathematics: »Some textbooks leave the quantity 0^0 undefined, because the functions x^0 and 0^x have different limiting values when x decreases to 0. But this is a mistake. We must define x^0 = 1 for all x, if the binomial theorem is to be valid when x=0, y=0, and/or x=-y. The theorem is too important to be arbitrarily restricted! By contrast, the function 0^x is quite unimportant.«, Addison-Wesley, 1994, ISBN 0-201-55802-5. )

 

Zum Seitenanfang

22.3.8Der Logarithmus * Zur vorigen ÜberschriftZur nächsten Überschrift

Der Logarithmus ist die Umkehrfunktion der Exponentialfunktion. Die Exponentialfunktion und der Logarithmus hängen durch folgende Beziehung zusammen: Ist y = ax, dann ist x = loga(y). Der Logarithmus, den Math.log(double) berechnet, ist der natürliche Logarithmus zur Basis e. In der Mathematik wird dieser mit ln angegeben (logarithmus naturalis). Logarithmen mit der Basis 10 heißen dekadische oder briggsche Logarithmen und werden mit lg abgekürzt; der Logarithmus zur Basis 2 (binärer Logarithmus, dualer Logarithmus) wird mit lb abgekürzt. In Java gibt es die statische Methode log10(double) für den briggschen Logarithmus lg, nicht aber für den binären Logarithmus lb, der weiterhin nachgebildet werden muss. Allgemein gilt folgende Umrechnung: logb(x) = loga(x) / loga(b).

[zB]Beispiel

Eine eigene statische Methode soll den Logarithmus zur Basis 2 berechnen:

public static double lb( double x ) {

return Math.log( x ) / Math.log( 2.0 );

}

Da Math.log(2) konstant ist, sollte dieser Wert aus Performance-Gründen in einer Konstanten gehalten werden.

class java.lang.Math
  • static double log(double a)

    Berechnet von a den Logarithmus zur Basis e.

  • static double log10(double a)

    Liefert von a den Logarithmus zur Basis 10.

  • static double log1p(double x)

    Liefert log(x) + 1.

 

Zum Seitenanfang

22.3.9Winkelmethoden * Zur vorigen ÜberschriftZur nächsten Überschrift

Die Math-Klasse stellt einige winkelbezogene Methoden und ihre Umkehrungen zur Verfügung. Im Gegensatz zur bekannten Schulmathematik werden die Winkel für sin(double), cos(double), tan(double) im Bogenmaß (2π entspricht einem Vollkreis) und nicht im Gradmaß (360 Grad entspricht einem Vollkreis) übergeben.

class java.lang.Math
  • static double sin(double x)

  • static double cos(double x)

  • static double tan(double x)

    Liefert den Sinus/Kosinus/Tangens von x.

Arcus-Methoden

Die Arcus-Methoden realisieren die Umkehrfunktionen zu den trigonometrischen Methoden. Das Argument ist kein Winkel, sondern zum Beispiel bei asin(double) der Sinuswert zwischen –1 und 1. Das Ergebnis ist dann ein Winkel im Bogenmaß, etwa zwischen –π/2 und π/2.

class java.lang.Math
  • static double asin(double x)

  • static double acos(double x)

  • static double atan(double x)

    Liefert den Arcus-Sinus, Arcus-Kosinus bzw. Arcus-Tangens von x.

  • static atan2(double x, double y)

    Liefert bei der Konvertierung von Rechteckkoordinaten in Polarkoordinaten den Winkel theta, also eine Komponente des Polarkoordinaten-Tupels. Die statische Methode berücksichtigt das Vorzeichen der Parameter x und y, und der freie Schenkel des Winkels befindet sich im richtigen Quadranten.

Hyperbolicus-Methoden bietet Java über sinh(double), tanh(double) und cosh(double).

Umrechnungen von Gradmaß in Bogenmaß

Zur Umwandlung eines Winkels von Gradmaß in Bogenmaß und umgekehrt existieren zwei statische Methoden:

class java.lang.Math
  • static double toRadians(double angdeg)

    Wandelt Winkel von Gradmaß in Bogenmaß um.

  • static double toDegrees(double angrad)

    Wandelt Winkel von Bogenmaß in Gradmaß um.

 

Zum Seitenanfang

22.3.10Zufallszahlen Zur vorigen ÜberschriftZur nächsten Überschrift

Positive Gleitkomma-Zufallszahlen zwischen größer gleich 0,0 und echt kleiner 1,0 liefert die statische Methode Math.random(). Die Rückgabe ist double, und eine Typumwandlung auf int führt immer zum Ergebnis 0.

Möchten wir Werte in einem anderen Wertebereich haben, ist es eine einfache Lösung, die Zufallszahlen von Math.random() durch Multiplikation (Skalierung) auf den gewünschten Wertebereich auszudehnen und per Addition (ein Offset) geeignet zu verschieben. Um ganzzahlige Zufallszahlen zwischen min (inklusiv) und max (inklusiv) zu erhalten, schreiben wir:

Listing 22.8RandomIntInRange.java

public static long random( long min, long max ) {

return min + Math.round( Math.random() * (max – min) );

}

Eine Alternative bietet der direkte Einsatz der Klasse Random und der Objektmethode nextInt(n).

Die Implementierung steckt nicht in der Mathe-Klasse selbst, sondern in Random, was wir uns in Abschnitt 22.5, »Zufallszahlen: Random, SecureRandom, SplittableRandom«, genauer ansehen.

 


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 ist auch eine Insel

Java ist auch eine Insel




Zum Katalog: Java SE 9-Standard-Bibliothek

Java SE 9-Standard-Bibliothek




Zum Katalog: Professionell entwickeln mit Java EE 8

Professionell entwickeln mit Java EE 8




Zum Katalog: Entwurfsmuster

Entwurfsmuster




Zum Katalog: IT-Projektmanagement

IT-Projektmanagement




 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich

InfoInfo



 

 


Copyright © Rheinwerk Verlag GmbH 2017

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.

 

[Rheinwerk Computing]



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