Java Math-Klasse und ihre Methoden

In diesem Artikel geben wir einen kurzen Überblick über die Math-Klasse in Java. Lassen Sie uns über die Methoden dieser Klasse und deren Verwendung sprechen. Die Math-Klasse befindet sich im Paket java.lang und stellt eine Reihe statischer Methoden zur Durchführung verschiedener mathematischer Berechnungen bereit. Im Folgenden finden Sie Beispiele für Berechnungen, für die die Mathematikklasse nützlich sein kann:

• Berechnung absoluter Werte (Modulowerte)
• Berechnung der Werte trigonometrischer Funktionen (Sinus, Cosinus usw.)
• Erhöhung in verschiedenen Graden
• Extraktion von Wurzeln in unterschiedlichem Ausmaß
• Zufallszahlengenerierung
• Rundung
• Usw.

Im Folgenden werden wir versuchen zu untersuchen, wie die Java Math-Klasse zur Lösung der oben aufgeführten Probleme beiträgt. Beginnen wir mit der Analyse der Klasse mit Methoden, mit denen Sie einen Wert modulo berechnen können. Verantwortlich dafür ist die Abs-Methode. Diese Methode ist überladen und die Math-Klasse weist die folgenden Unterschiede auf:

• statische Doppel-Bauchmuskeln (Doppel-A)
• statische float abs(float a)
• static int abs(int a)
• statische lange Bauchmuskeln (langes a)

Anwendungsbeispiel:

public static void main(String[] args) {
        System.out.println(Math.abs(-1));      // 1
        System.out.println(Math.abs(-21.8d));  // 21.8
        System.out.println(Math.abs(4532L));   // 4532
        System.out.println(Math.abs(5.341f));  // 5.341
    }

Berechnung der Werte trigonometrischer Funktionen

Mit der Mathematikklasse können Sie verschiedene trigonometrische Funktionen berechnen – Sinus, Kosinus, Tangens usw. Eine vollständige Liste der Methoden finden Sie auf der offiziellen Dokumentationswebsite . Nachfolgend finden Sie eine Liste dieser Methoden:

• statische Doppelsünde (Doppel a)
• statisches Doppel-Cos(Doppel-A)
• statisches Double Tan (Double A)
• statisches Doppel-Asin (Doppel-A)
• statisches Doppel-Acos (Doppel-A)
• statisches Doppel-Atan (Doppel-A)

Berechnungsmethoden: Sinus, Kosinus, Tangens, Arkussinus, Arkuskosinus, Arkustangens. Jede Methode berechnet einen Wert für den Winkel „a“. Dieser Parameter wird an jede Methode übergeben und jeweils im Bogenmaß gemessen (und nicht in Grad, wie wir es gewohnt sind). Hier gibt es zwei Neuigkeiten, gute und schlechte. Beginnen wir mit dem Guten. Die Math-Klasse verfügt über Methoden zum Umrechnen von Bogenmaß in Grad und Grad in Bogenmaß:

• static double toDegrees(double angrad)
• statisches Double toRadians(double angdeg)

Hier konvertiert die toDegrees-Methode den im Bogenmaß gemessenen Winkel angrad in Grad. Die toRadians-Methode hingegen wandelt den in Grad gemessenen Winkel Angdeg in Bogenmaß um. Die schlechte Nachricht ist, dass dies mit einem Fehler geschieht. Hier ist ein Beispiel für die Berechnung von Sinus und Cosinus:

public static void main(String[] args) {
        System.out.println(Math.sin(Math.toRadians(0)));
        System.out.println(Math.sin(Math.toRadians(30)));
        System.out.println(Math.sin(Math.toRadians(90)));

        System.out.println(Math.cos(Math.toRadians(0)));
        System.out.println(Math.cos(Math.toRadians(30)));
        System.out.println(Math.cos(Math.toRadians(90)));
    }

Das Programm gibt Folgendes aus:

0.0
0.49999999999999994
1.0

1.0
0.8660254037844387
6.123233995736766E-17

Was nicht ganz mit den Sinus- und Cosinustabellen übereinstimmt, teilweise aufgrund von Fehlern bei der Umrechnung von Grad in Bogenmaß.

Potenzierung

Um eine Zahl zu potenzieren, stellt die Math-Klasse eine pow-Methode bereit, die die folgende Signatur hat:

static double pow(double a, double b)

Diese Methode erhöht den Parameter „a“ auf die Potenz „b“. Beispiele:

public static void main(String[] args) {
        System.out.println(Math.pow(1,2)); // 1.0
        System.out.println(Math.pow(2,2)); // 4.0
        System.out.println(Math.pow(3,2)); // 9.0
        System.out.println(Math.pow(4,2)); // 16.0
        System.out.println(Math.pow(5,2)); // 25.0

        System.out.println(Math.pow(1,3)); // 1.0
        System.out.println(Math.pow(2,3)); // 8.0
        System.out.println(Math.pow(3,3)); // 27.0
        System.out.println(Math.pow(4,3)); // 64.0
        System.out.println(Math.pow(5,3)); // 125.0
    }

Wurzelextraktion

Die Math-Klasse stellt Methoden zum Ziehen von Quadrat- und Kubikwurzeln bereit. Für dieses Verfahren sind folgende Methoden verantwortlich:

• statisches doppeltes Quadrat (doppeltes a)
• statisches Doppel-Cbrt (Doppel-A)

Die sqrt-Methode zieht die Quadratwurzel und die cbrt-Methode zieht die Kubikwurzel. Beispiele:

public static void main(String[] args) {
        System.out.println(Math.sqrt(4));   // 2.0
        System.out.println(Math.sqrt(9));   // 3.0
        System.out.println(Math.sqrt(16));  // 4.0

        System.out.println(Math.cbrt(8));   // 2.0
        System.out.println(Math.cbrt(27));  // 3.0
        System.out.println(Math.cbrt(125)); // 5.0
    }

Zufallszahlengenerierung

Um Zufallszahlen zu erzeugen, stellt die Math-Klasse die Zufallsmethode bereit. Diese Methode generiert eine zufällige positive reelle (doppelte) Zahl im Bereich von 0,0 bis 1,0. Die Methodensignatur sieht folgendermaßen aus:

public static double random()

Schauen wir uns Beispiele an:

public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
        System.out.println(Math.random());
    }
}

Nach Ausführung der Hauptmethode wurde auf der Konsole Folgendes angezeigt:

0.37057465028778513
0.2516253742011597
0.9315649439611121
0.6346725713527239
0.7442959932755443

Mit ein wenig Manipulation können Sie die Zufallsmethode der Math-Klasse verwenden, um ganzzahlige Zufallszahlen zu erhalten, die in einem bestimmten Bereich liegen. Hier ist ein Beispiel für eine Funktion, die zwei Argumente min und max akzeptiert und eine zufällige Ganzzahl zurückgibt, die im Bereich von min (einschließlich) bis max (einschließlich) liegt:

static int randomInARange(int min, int max) {
    return  (int) (Math.random() * ((max - min) + 1)) + min;
}

Schreiben wir eine Main-Methode, in der wir die randomInARange-Methode testen:

public class MathExample {


    public static void main(String[] args) {
        // Карта, в которой мы будем хранить количество выпадений Wieого-то числа
        Map<Integer, Integer> map = new TreeMap<>();

        // За 10000 операций
        for (int i = 0; i < 10000; i++) {

            // Сгенерируем рандомное число от -10 включительно до 10 включительно
            final Integer randomNumber = randomInARange(-10, 10);


            if (!map.containsKey(randomNumber)) {
                // Если карта еще не содержит "выпавшего случайного числа"
                // Положим его в карту с кол-вом выпадений = 1
                map.put(randomNumber, 1);
            } else {
                // Иначе, увеличим количество выпадений данного числа на 1
                map.put(randomNumber, map.get(randomNumber) + 1);
            }
        }

        // Выведем на экран содержимое карты в формате ключ=[Bedeutung]
        for (Map.Entry<Integer, Integer> entry : map.entrySet()){
            System.out.println(String.format("%d=[%d]", entry.getKey(), entry.getValue()));
        }
    }

    static int randomInARange(int min, int max) {
        return  (int) (Math.random() * ((max - min) + 1)) + min;
    }
}

Nach dem Ausführen der Hauptmethode könnte die Ausgabe so aussehen:

-10=[482]
-9=[495]
-8=[472]
-7=[514]
-6=[457]
-5=[465]
-4=[486]
-3=[500]
-2=[490]
-1=[466]
0=[458]
1=[488]
2=[461]
3=[470]
4=[464]
5=[463]
6=[484]
7=[479]
8=[459]
9=[503]
10=[444]

Process finished with exit code 0

Rundung

Eines der Werkzeuge zum Runden von Zahlen in Java sind die Methoden der Math-Klasse. Genauer gesagt, die Rund-, Decken- und Bodenmethoden:

• statische lange Runde (Doppel-A)
• static int runde(float a)
• statischer Doppelboden (Doppel A)
• statische Doppeldecke (doppelt a)

Die Rundenmethode – rundet wie gewohnt auf den Durchschnittsmenschen. Ist der Nachkommateil der Zahl größer oder gleich 0,5, wird die Zahl aufgerundet, andernfalls abgerundet. Die Bodenmethode rundet die Zahl immer ab (in Richtung negativer Unendlich), unabhängig von den Werten des Bruchteils. Die Ceil-Methode hingegen rundet Zahlen unabhängig von den Werten des Bruchteils auf (in Richtung positiver Unendlichkeit). Schauen wir uns Beispiele an:

public static void main(String[] args) {
    System.out.println(Math.round(1.3)); // 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(Math.floor(1.3)); // 1.0
    System.out.println(Math.floor(1.4)); // 1.0
    System.out.println(Math.floor(1.5)); // 1.0
    System.out.println(Math.floor(1.6)); // 1.0

    System.out.println(Math.ceil(1.3)); // 2.0
    System.out.println(Math.ceil(1.4)); // 2.0
    System.out.println(Math.ceil(1.5)); // 2.0
    System.out.println(Math.ceil(1.6)); // 2.0
}

Abschluss

In diesem Artikel haben wir einen oberflächlichen Blick auf den Mathematikunterricht geworfen. Wir haben uns angeschaut, wie Sie mit dieser Klasse Folgendes erreichen können:

• Werte modulo berechnen;
• Werte trigonometrischer Funktionen berechnen;
• Erhöhen Sie Zahlen zu Potenzen;
• Extrahieren Sie Quadrat- und Kubikwurzeln;
• Zufallszahlen generieren;
• Runde Zahlen.

Es gibt viele andere interessante Methoden in dieser Klasse. Diese finden Sie auf der offiziellen Dokumentationswebsite . Nun, für das erste Kennenlernen reichen die oben aufgeführten Methoden völlig aus.