Ausführbare Java-Docs: Math-Klasse

Q: Wie verwende ich Math.pow in Java?

Math.pow(base, exponent) liefert base hoch exponent als double, also ist Math.pow(2, 3) gleich 8.0. Um das Ergebnis in einem int zu speichern, caste es: int n = (int) Math.pow(2, 10); ergibt 1024. Java hat keinen Potenzoperator ^; ^ ist das bitweise XOR.

Q: Wie erzeuge ich mit Math.random eine Zufallszahl in einem Bereich?

Math.random() liefert einen double von 0.0 bis ausschließlich 1.0. Für eine ganze Zahl von min bis einschließlich max nimm (int) (Math.random() (max - min + 1)) + min. Ein Würfelwurf ist (int) (Math.random() 6) + 1.

Q: Muss ich die Math-Klasse in Java importieren?

Nein. Math liegt im Paket java.lang, das jede Java-Datei automatisch importiert. Alle ihre Methoden sind static, du rufst sie also auf dem Klassennamen auf, etwa Math.sqrt(16), ohne ein Objekt zu erzeugen.

Q: Warum liefert Math.round in Java einen long?

Math.round(double) liefert einen long, weil ein double Werte weit über dem Bereich von int fassen kann. Um das Ergebnis einem int zuzuweisen, brauchst du einen Cast: int n = (int) Math.round(2.6);. Math.round(float) liefert einen int.

Q: Was ist der Unterschied zwischen Math.floor, Math.ceil und Math.round?

Math.floor rundet ab (2.7 wird zu 2.0, -2.3 zu -3.0), Math.ceil rundet auf (2.1 wird zu 3.0), und Math.round geht zur nächsten ganzen Zahl, wobei Hälften aufgerundet werden (2.5 wird zu 3). floor und ceil liefern einen double; round liefert einen long.

Ein Werkzeugkasten aus statischen Methoden

java.lang.Math ist eine Klasse voller fertiger mathematischer Funktionen: Potenzen, Wurzeln, Beträge, Runden, Trigonometrie, Logarithmen und Zufallszahlen. Zwei Dinge machen sie einfach zu benutzen:

Sie liegt in java.lang, das jede Java-Datei automatisch importiert. Du musst keine import-Zeile schreiben.
Jede Methode ist static. Du rufst sie auf dem Klassennamen auf, Math.sqrt(25), und erzeugst nie ein Math-Objekt. Was static bedeutet, erklärt die Seite zu statischen Membern.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(2, 3));    // 8.0
        System.out.println(Math.sqrt(25));     // 5.0
        System.out.println(Math.abs(-7));      // 7
        System.out.println(Math.max(4, 9));    // 9
        System.out.println(Math.round(2.6));   // 3
    }
}

Manche Ergebnisse werden mit .0 ausgegeben, andere nicht. Jede Math-Methode hat einen festen Rückgabetyp, und diesen zu kennen ist der größte Teil dessen, was es über diese Klasse zu lernen gibt.

Methode	Macht	Liefert
`Math.pow(a, b)`	a hoch b	`double`
`Math.sqrt(x)`	Quadratwurzel	`double`
`Math.cbrt(x)`	Kubikwurzel	`double`
`Math.abs(x)`	Betrag	denselben Typ wie `x`
`Math.max(a, b)` / `Math.min(a, b)`	größeren / kleineren von zwei Werten	den breiteren der beiden Typen
`Math.round(x)`	nächste ganze Zahl	`long` für einen `double`, `int` für einen `float`
`Math.floor(x)` / `Math.ceil(x)`	abrunden / aufrunden	`double`
`Math.random()`	Zufallszahl von 0.0 bis unter 1.0	`double`
`Math.PI`, `Math.E`	die Konstanten π und e	`double`

Math.pow: Potenzen

Math.pow(base, exponent) erhebt eine Zahl in eine Potenz. Die Methode nimmt zwei double-Parameter und liefert einen double, auch wenn du ganze Zahlen übergibst:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(2, 3));     // 8.0
        System.out.println(Math.pow(5, 2));     // 25.0
        System.out.println(Math.pow(2, -1));    // 0.5
        System.out.println(Math.pow(9, 0.5));   // 3.0 (eine Quadratwurzel)

        int kilobyte = (int) Math.pow(2, 10);
        System.out.println(kilobyte);           // 1024
    }
}

Um das Ergebnis in einem int zu speichern, caste es mit (int). Bei kleinen ganzzahligen Potenzen ist das double-Ergebnis exakt, also liefert der Cast die richtige Antwort. Bei großen Ergebnissen geht der Cast schief: Ein double über Integer.MAX_VALUE (2.147.483.647) wird genau zu Integer.MAX_VALUE, also ergibt (int) Math.pow(2, 40) den Wert 2147483647. Caste bei größeren Potenzen zu long und denk daran, dass ein double oberhalb von 2⁵³ nicht mehr jede ganze Zahl exakt darstellen kann. Was ein Cast mit dem Wert macht, erklärt die Seite zur Typumwandlung.

Java hat keinen Potenzoperator. 2 ^ 3 kompiliert, aber ^ ist das bitweise XOR, und das Ergebnis ist 1, nicht 8. Das ist einer der häufigsten Anfängerfehler in Java-Code mit Mathematik.

Ein double ab zehn Millionen wird in wissenschaftlicher Schreibweise ausgegeben, was beim ersten Ausgeben einer Zehnerpotenz überrascht:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(10, 6));          // 1000000.0
        System.out.println(Math.pow(10, 7));          // 1.0E7
        System.out.println((long) Math.pow(10, 7));   // 10000000
    }
}

1.0E7 bedeutet 1,0 × 10⁷. Der Wert ist derselbe, nur die Ausgabeform ändert sich. Caste zu long oder formatiere mit String.format("%.0f", value), um ihn als einfache Ziffern auszugeben.

Math.sqrt und Math.cbrt: Wurzeln

Math.sqrt(x) liefert die Quadratwurzel von x als double. Math.cbrt(x) liefert die Kubikwurzel.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.sqrt(16));    // 4.0
        System.out.println(Math.sqrt(2));     // 1.4142135623730951
        System.out.println(Math.cbrt(27));    // 3.0
        System.out.println(Math.sqrt(-4));    // NaN

        double a = 3;
        double b = 4;
        System.out.println(Math.sqrt(a * a + b * b));   // 5.0
        System.out.println(Math.hypot(a, b));           // 5.0
    }
}

Die Quadratwurzel einer negativen Zahl ist keine reelle Zahl, deshalb liefert Math.sqrt(-4) den Wert NaN („not a number“), statt eine Exception zu werfen. NaN breitet sich durch jede Rechnung aus, in die es gerät. Prüf die Eingaben also vor dem Wurzelziehen, wenn negative Werte möglich sind. Math.hypot(a, b) berechnet sqrt(a*a + b*b) direkt, ein üblicher Weg, den Abstand zwischen zwei Punkten zu bestimmen.

Math.abs: Betrag

Math.abs(x) entfernt das Vorzeichen. Anders als pow und sqrt liefert es denselben Typ, den du hineingibst: einen int für einen int, einen double für einen double.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.abs(-7));      // 7
        System.out.println(Math.abs(7));       // 7
        System.out.println(Math.abs(-2.5));    // 2.5

        int start = 12;
        int end = 5;
        System.out.println("Distance: " + Math.abs(end - start));   // Distance: 7
    }
}

Der übliche Einsatz ist eine Differenz, bei der dich die Größe interessiert, nicht die Richtung, etwa der Abstand zwischen zwei Positionen.

Math.max und Math.min

Math.max(a, b) liefert den größeren von zwei Werten und Math.min(a, b) den kleineren. Sie nehmen genau zwei Argumente. Für drei oder mehr verschachtelst du die Aufrufe:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.max(4, 9));      // 9
        System.out.println(Math.min(4, 9));      // 4
        System.out.println(Math.max(3, 7.5));    // 7.5

        int a = 12, b = 45, c = 30;
        System.out.println(Math.max(a, Math.max(b, c)));   // 45

        int score = 130;
        int clamped = Math.max(0, Math.min(score, 100));
        System.out.println(clamped);             // 100
    }
}

Haben die beiden Argumente unterschiedliche Typen, wird der schmalere zuerst erweitert. Math.max(3, 7.5) vergleicht zwei double-Werte und liefert einen double. Das letzte Beispiel begrenzt einen Wert auf den Bereich von 0 bis 100: Math.min kappt ihn bei 100, Math.max verhindert, dass er unter 0 fällt.

Runden: round, floor, ceil

Java hat drei Rundungsmethoden, und sie unterscheiden sich sowohl in der Richtung als auch im Rückgabetyp:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.round(2.4));    // 2
        System.out.println(Math.round(2.5));    // 3
        System.out.println(Math.round(-2.5));   // -2

        System.out.println(Math.floor(2.7));    // 2.0
        System.out.println(Math.floor(-2.3));   // -3.0

        System.out.println(Math.ceil(2.1));     // 3.0
        System.out.println(Math.ceil(-2.7));    // -2.0

        System.out.println((int) 2.7);          // 2
        System.out.println((int) -2.7);         // -2
    }
}

Math.round geht zur nächsten ganzen Zahl. Ein Wert genau in der Mitte wird aufgerundet, in Richtung plus unendlich, also wird 2.5 zu 3 und -2.5 zu -2. Für ein double-Argument liefert es einen long (und für einen float einen int).
Math.floor rundet immer ab, in Richtung minus unendlich, und liefert einen double.
Math.ceil rundet immer auf, in Richtung plus unendlich, und liefert einen double.
Ein Cast (int) ist überhaupt kein Runden: Er schneidet den Nachkommaanteil ab, wodurch positive Zahlen kleiner und negative Zahlen größer werden.

Weil Math.round(double) einen long liefert, kompiliert die Zuweisung an einen int nicht ohne Cast:

int n = Math.round(2.6);          // error: incompatible types: possible lossy conversion from long to int
int m = (int) Math.round(2.6);    // OK, m ist 3
long k = Math.round(2.6);         // OK

Um auf eine bestimmte Zahl von Nachkommastellen zu runden, skalierst du hoch, rundest und skalierst wieder herunter. Die Division durch 100.0 (einen double) statt durch 100 behält die Nachkommastellen:

public class Main {
    public static void main(String[] args) {
        double price = 19.4567;

        System.out.println(Math.round(price * 100) / 100.0);   // 19.46
        System.out.println(Math.round(price * 100) / 100);     // 19

        System.out.println(String.format("%.2f", price));      // 19.46
    }
}

Die zweite Zeile teilt einen long durch einen int, das ist Ganzzahldivision, also gehen die Nachkommastellen verloren. Wenn du eine gerundete Zahl nur anzeigen willst, ist String.format("%.2f", value) einfacher und ändert den gespeicherten Wert nicht.

Math.random: Zufallszahlen

Math.random() liefert einen double, der mindestens 0.0 und kleiner als 1.0 ist. Der Wert ist bei jedem Aufruf anders, deshalb ändert sich die Ausgabe der Programme in diesem Abschnitt bei jedem Klick auf Ausführen.

public class Main {
    public static void main(String[] args) {
        double r = Math.random();
        System.out.println(r);
        System.out.println(r >= 0.0 && r < 1.0);   // true
    }
}

Für eine ganze Zahl in einem Bereich streckst du diesen Wert, castest ihn und verschiebst ihn. Für eine ganze Zahl von min bis max, beide eingeschlossen:

int value = (int) (Math.random() * (max - min + 1)) + min;

So funktioniert das bei einem Würfel, bei dem min gleich 1 und max gleich 6 ist:

Math.random() * 6 ergibt einen double von 0.0 bis ausschließlich 6.0.
(int) schneidet den Nachkommaanteil ab und ergibt eine der Zahlen 0, 1, 2, 3, 4, 5.
+ 1 verschiebt das zu 1, 2, 3, 4, 5, 6.

public class Main {
    public static void main(String[] args) {
        int min = 1;
        int max = 6;

        for (int i = 0; i < 5; i++) {
            int roll = (int) (Math.random() * (max - min + 1)) + min;
            System.out.print(roll + " ");
        }
        System.out.println();

        int lowest = max;
        int highest = min;
        for (int i = 0; i < 10000; i++) {
            int roll = (int) (Math.random() * (max - min + 1)) + min;
            lowest = Math.min(lowest, roll);
            highest = Math.max(highest, roll);
        }
        System.out.println("lowest: " + lowest + ", highest: " + highest);
    }
}

Die erste Zeile zeigt fünf zufällige Würfe. Die zweite Zeile prüft zehntausend Würfe und gibt in der Praxis immer lowest: 1, highest: 6 aus: Die Formel erreicht beide Enden des Bereichs und geht nie darüber hinaus.

Die Klammern um Math.random() * (max - min + 1) sind wichtig. Ein Cast wirkt auf den Wert direkt dahinter, also castet (int) Math.random() * 6 zuerst Math.random(). Das ist immer 0, und 0 * 6 ist 0, also kommt bei jedem „Wurf“ dasselbe heraus.

Für Spiele und Übungen ist Math.random() in Ordnung. Für alles Weitere liefern die Klasse java.util.Random und ThreadLocalRandom.current().nextInt(min, max + 1) (in java.util.concurrent) direkt ganze Zahlen, und Random kann einen Seed bekommen, um in Tests dieselbe Folge zu wiederholen. Keine davon eignet sich für Passwörter oder Sicherheitstokens; nimm dafür java.security.SecureRandom.

Math.PI und Math.E

Math.PI (π) und Math.E (die Eulersche Zahl e) sind Konstanten vom Typ static final double:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.PI);   // 3.141592653589793
        System.out.println(Math.E);    // 2.718281828459045

        double radius = 3;
        double area = Math.PI * radius * radius;
        double circumference = 2 * Math.PI * radius;

        System.out.printf("area: %.2f%n", area);                     // area: 28.27
        System.out.printf("circumference: %.2f%n", circumference);   // circumference: 18.85
    }
}

Nimm sie, statt 3.14 zu tippen. Sie sind so genau, wie ein double es erlaubt, und der Name sagt der lesenden Person, was die Zahl ist.

Ganzzahlige Ergebnisse vs. double-Ergebnisse

Die meisten Math-Methoden nehmen und liefern double. Wenn du ihnen int-Werte gibst, erweitert Java die Argumente automatisch zu double, aber die Rechnung, die du vor dem Aufruf schreibst, passiert trotzdem in int. Daher kommen die meisten falschen Antworten:

public class Main {
    public static void main(String[] args) {
        int items = 7;
        int perBox = 2;

        System.out.println(Math.ceil(items / perBox));            // 3.0 (falsch)
        System.out.println(Math.ceil((double) items / perBox));   // 4.0

        System.out.println(Math.sqrt(10 / 4));     // 1.4142135623730951
        System.out.println(Math.sqrt(10 / 4.0));   // 1.5811388300841898

        int boxes = (int) Math.ceil((double) items / perBox);
        System.out.println(boxes + " boxes");      // 4 boxes
    }
}

items / perBox ist 7 / 2, und die Division zweier int-Werte verwirft den Rest, also ist das Ergebnis 3, bevor Math.ceil es überhaupt sieht. Math.ceil(3.0) ist 3.0. Mach einen Operanden zum double, mit einem Cast oder einem Literal wie 4.0, damit die Division ihren Nachkommaanteil behält. Die Seite zu Operatoren erklärt die Ganzzahldivision ausführlicher.

Die allgemeine Regel: Leg fest, welchen Typ du am Ende willst, lass die Division oder Multiplikation in double passieren, wenn Nachkommastellen zählen, und caste nur einmal, ganz am Ende, zurück zu int oder long.

Weitere nützliche Methoden

Noch ein paar Methoden aus derselben Klasse, alle auf dieselbe Weise aufgerufen:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.log10(1000));      // 3.0
        System.out.println(Math.log(Math.E));      // 1.0 (natürlicher Logarithmus)
        System.out.println(Math.signum(-4.2));     // -1.0

        System.out.println(-7 % 3);                // -1
        System.out.println(Math.floorMod(-7, 3));  // 2

        double angle = Math.toRadians(90);
        System.out.println(Math.sin(angle));       // 1.0

        try {
            Math.addExact(Integer.MAX_VALUE, 1);
        } catch (ArithmeticException e) {
            System.out.println("overflow: " + e.getMessage());   // overflow: integer overflow
        }
    }
}

Math.log ist der natürliche Logarithmus; Math.log10 ist der Logarithmus zur Basis 10.
Math.floorMod(a, b) liefert einen Rest mit dem Vorzeichen von b. Das willst du, wenn Werte in einem Bereich umlaufen sollen, etwa bei Wochentagen. Der Operator % behält das Vorzeichen von a.
Die trigonometrischen Methoden (sin, cos, tan) arbeiten mit Bogenmaß. Rechne Grad vorher mit Math.toRadians um.
Math.addExact, Math.multiplyExact und ihre Verwandten werfen bei einem Überlauf eine ArithmeticException, statt stillschweigend zu einer negativen Zahl umzuschlagen.

Häufig gestellte Fragen

Wie verwende ich Math.pow in Java?

Math.pow(base, exponent) liefert base hoch exponent als double, also ist Math.pow(2, 3) gleich 8.0. Um das Ergebnis in einem int zu speichern, caste es: int n = (int) Math.pow(2, 10); ergibt 1024. Java hat keinen Potenzoperator ^; ^ ist das bitweise XOR.

Wie erzeuge ich mit Math.random eine Zufallszahl in einem Bereich?

Math.random() liefert einen double von 0.0 bis ausschließlich 1.0. Für eine ganze Zahl von min bis einschließlich max nimm (int) (Math.random() * (max - min + 1)) + min. Ein Würfelwurf ist (int) (Math.random() * 6) + 1.

Muss ich die Math-Klasse in Java importieren?

Nein. Math liegt im Paket java.lang, das jede Java-Datei automatisch importiert. Alle ihre Methoden sind static, du rufst sie also auf dem Klassennamen auf, etwa Math.sqrt(16), ohne ein Objekt zu erzeugen.

Warum liefert Math.round in Java einen long?

Math.round(double) liefert einen long, weil ein double Werte weit über dem Bereich von int fassen kann. Um das Ergebnis einem int zuzuweisen, brauchst du einen Cast: int n = (int) Math.round(2.6);. Math.round(float) liefert einen int.

Was ist der Unterschied zwischen Math.floor, Math.ceil und Math.round?

Math.floor rundet ab (2.7 wird zu 2.0, -2.3 zu -3.0), Math.ceil rundet auf (2.1 wird zu 3.0), und Math.round geht zur nächsten ganzen Zahl, wobei Hälften aufgerundet werden (2.5 wird zu 3). floor und ceil liefern einen double; round liefert einen long.