Java Math-Klasse

Die java.lang.Math-Klasse ist eine Sammlung statischer Methoden für mathematische Operationen, die über die grundlegenden +, -, *, /, % Operatoren hinausgehen. Absolutwerte, Potenzen, Wurzeln, Trigonometrie, Logarithmen, Runden und Zufallszahlen — all das ist hier zu finden. Da Math im Paket java.lang liegt, wird es implizit importiert — es ist keine import-Anweisung erforderlich, die Methoden werden direkt aufgerufen: Math.sqrt(2).

Diese Seite geht jede Methodengruppe durch, zeigt den genauen Rückgabewert und weist auf Fallstricke hin (welche Methoden double vs. long zurückgeben, warum Trigonometrie in Radiant arbeitet und wann Math das falsche Werkzeug ist). Jede Methode ist static, wird also auf der Klasse selbst aufgerufen, niemals auf einer Instanz.

Absolutwert, min, max

Math.abs(-7);          // 7
Math.abs(-3.14);       // 3.14

Math.min(3, 5);        // 3
Math.max(3, 5);        // 5
Math.min(1.5, 1.7);    // 1.5

Alle vier sind für int, long, float und double überladen.

Potenzen und Wurzeln

Math.pow(2, 10);       // 1024.0  — always returns double
Math.sqrt(2);          // 1.4142135623730951
Math.cbrt(27);         // 3.0
Math.exp(1);           // 2.718281828... — e^x

Für ganzzahlige Exponenten ist Math.pow überdimensioniert — eine Schleife oder << ist schneller.

Logarithmen

Math.log(Math.E);      // 1.0  — natural log (ln)
Math.log10(1000);      // 3.0  — base-10 log
Math.log(8) / Math.log(2);   // 3.0 — log base 2

Java hat keine eingebaute „log-Basis-N"-Methode, daher berechnet man sie mit der Basiswechselformel: Math.log(x) / Math.log(base). Für höhere Präzision nahe x = 1 berechnet Math.log1p(x) den Wert ln(1 + x) und Math.expm1(x) berechnet e^x - 1, ohne signifikante Stellen zu verlieren.

Runden

Math.floor(2.7);       // 2.0
Math.ceil(2.1);        // 3.0
Math.round(2.5);       // 3   — ties round up
Math.round(-2.5);      // -2  — toward positive infinity
Math.rint(0.5);        // 0.0 — banker's rounding
Math.rint(1.5);        // 2.0

Für dezimalbewusstes Runden (z. B. auf zwei Dezimalstellen für Geldbeträge) verwendet man BigDecimal mit einem RoundingMode.

Trigonometrie

Alle trigonometrischen Funktionen arbeiten in Radiant. Umrechnen mit Math.toRadians / Math.toDegrees:

Math.sin(Math.PI / 2);          // 1.0
Math.cos(0);                    // 1.0
Math.tan(Math.PI / 4);          // 0.999999... (≈ 1)

Math.toRadians(180);            // Math.PI
Math.toDegrees(Math.PI);        // 180.0

Math.atan2(1, 1);               // π/4  — handles quadrant correctly

Math.atan2(y, x) ist das richtige Werkzeug, um „den Winkel dieses Vektors" zu berechnen, nicht Math.atan(y/x).

Konstanten

Math.PI;       // 3.141592653589793
Math.E;        // 2.718281828459045

Zufallszahlen

Math.random() gibt einen double-Wert gleichmäßig verteilt in [0.0, 1.0) zurück:

double r = Math.random();          // 0.0 ≤ r < 1.0
int dieRoll = 1 + (int)(Math.random() * 6);  // 1..6

Für alles Weitere (mit Seed, reproduzierbar, Bereiche, Gaußverteilung) verwendet man java.util.Random oder java.util.concurrent.ThreadLocalRandom:

import java.util.Random;
Random rng = new Random(42);   // seeded, reproducible
int n = rng.nextInt(100);      // 0..99
double g = rng.nextGaussian(); // normal distribution

Für Sicherheits-Tokens sollte man nicht Math.random oder Random verwenden — stattdessen java.security.SecureRandom nutzen.

Überlaufgeprüfte Arithmetik

Math.addExact, subtractExact, multiplyExact, negateExact, incrementExact, decrementExact werfen eine ArithmeticException bei ganzzahligem Überlauf:

Math.addExact(Integer.MAX_VALUE, 1);  // throws ArithmeticException

Nützlich, wenn Korrektheit wichtiger ist als Geschwindigkeit.

Eine Demonstration

Was kommt als nächstes

• Java Operatoren — die arithmetischen Operatoren +, -, *, /, %, auf denen Math aufbaut.
• Java Datentypen — warum Math.pow double zurückgibt und wann ein int überläuft.
• Java Benutzereingabe mit Scanner — Zahlen und Text vom Terminal einlesen.

Übungen