Java 8 Math Neue Methoden

1. Einleitung

Wenn wir über die neuen Funktionen nachdenken, die mit Version 8 von Java geliefert wurden, sind normalerweise funktionale Programmierung und Lambda-Ausdrücke die ersten Dinge, die uns in den Sinn kommen.

Abgesehen von diesen großen Funktionen gibt es noch andere, die möglicherweise eine geringere Auswirkung haben, aber auch interessant sind und oft nicht wirklich bekannt sind oder sogar von einer Rezension abgedeckt werden.

In diesem Tutorial werden wir jede der neuen Methoden auflisten und ein kleines Beispiel geben, die einer der Kernklassen der Sprache hinzugefügt wurden: java.lang.Math .

2. Neue * genaue () Methoden

Erstens haben wir eine Gruppe neuer Methoden, die einige der vorhandenen und gebräuchlichsten arithmetischen Operationen erweitern.

Wie wir sehen werden, sind sie ziemlich selbsterklärend, da sie genau die gleiche Funktionalität haben wie die Methoden, von denen sie abgeleitet sind, aber mit dem Hinzufügen einer Ausnahme für den Fall, dass der resultierende Wert die Max- oder Min-Werte ihrer Typen überschreitet .

Wir können diese Methoden sowohl mit ganzen Zahlen als auch mit langen als Parameter verwenden.

2.1. addExact ()

Fügt die beiden Parameter hinzu und löst im Falle eines Überlaufs (der für alle * Exact () -Methoden gilt) der Addition eine ArithmeticException aus :

Math.addExact(100, 50); // returns 150 Math.addExact(Integer.MAX_VALUE, 1); // throws ArithmeticException

2.2. substractExact ()

Subtrahiert den Wert des zweiten Parameters vom ersten und löst bei Überlauf der Subtraktion eine ArithmeticException aus:

Math.subtractExact(100, 50); // returns 50 Math.subtractExact(Long.MIN_VALUE, 1); // throws ArithmeticException

2.3. incrementExact ()

Erhöht den Parameter um eins und löst im Falle eines Überlaufs eine ArithmeticException aus:

Math.incrementExact(100); // returns 101 Math.incrementExact(Integer.MAX_VALUE); // throws ArithmeticException

2.4. decrementExact ()

Dekrementiert den Parameter um eins und löst bei Überlauf eine ArithmeticException aus:

Math.decrementExact(100); // returns 99 Math.decrementExact(Long.MIN_VALUE); // throws ArithmeticException

2.5. multiplyExact ()

Multiplizieren Sie die beiden Parameter und lösen Sie bei Überlauf des Produkts eine ArithmeticException aus:

Math.multiplyExact(100, 5); // returns 500 Math.multiplyExact(Long.MAX_VALUE, 2); // throws ArithmeticException

2.6. negateExact ()

Ändert das Vorzeichen des Parameters und löst bei Überlauf eine ArithmeticException aus.

In diesem Fall müssen wir über die interne Darstellung des Werts im Speicher nachdenken, um zu verstehen, warum es zu einem Überlauf kommt, der nicht so intuitiv ist wie die übrigen „exakten“ Methoden:

Math.negateExact(100); // returns -100 Math.negateExact(Integer.MIN_VALUE); // throws ArithmeticException

Das zweite Beispiel bedarf einer Erklärung, da es nicht offensichtlich ist: Der Überlauf ist darauf zurückzuführen, dass Integer.MIN_VALUE −2.147.483.648 und auf der anderen Seite Integer.MAX_VALUE 2.147.483.647 ist, sodass der zurückgegebene Wert nicht in eine Integer passt um eine Einheit.

3. Andere Methoden

3.1. floorDiv ()

Dividiert den ersten Parameter durch den zweiten und führt dann eine floor () - Operation über dem Ergebnis aus, wobei die Ganzzahl zurückgegeben wird, die kleiner oder gleich dem Quotienten ist:

Math.floorDiv(7, 2)); // returns 3 

Der genaue Quotient ist 3,5, also Boden (3,5) == 3.

Schauen wir uns ein anderes Beispiel an:

Math.floorDiv(-7, 2)); // returns -4 

Der genaue Quotient ist -3,5, also Boden (-3,5) == -4.

3.2. modDiv ()

Diese Methode ähnelt der vorherigen Methode floorDiv () , wendet jedoch die Operation floor () auf den Modul oder den Rest der Division anstelle des Quotienten an:

Math.modDiv(5, 3)); // returns 2 

Wie wir sehen können, entspricht modDiv () für zwei positive Zahlen dem Operator% . Schauen wir uns ein anderes Beispiel an:

Math.modDiv(-5, 3)); // returns 1 

Es wird 1 und nicht 2 zurückgegeben, da floorDiv (-5, 3) -2 und nicht -1 ist.

3.3. nextDown ()

Gibt den unmittelbar niedrigeren Wert des Parameters zurück (unterstützt Float- oder Double- Parameter):

float f = Math.nextDown(3); // returns 2.9999998 double d = Math.nextDown(3); // returns 2.999999761581421

4. Fazit

In diesem Artikel haben wir kurz die Funktionalität aller neuen Methoden beschrieben, die der Klasse java.lang.Math in Version 8 der Java-Plattform hinzugefügt wurden, und einige Beispiele für deren Verwendung gesehen.

Wie immer ist der vollständige Quellcode auf GitHub verfügbar.