Nouvelles méthodes Java 8 Math

Java 8 Math Nouvelles méthodes

1. introduction

En général, lorsque nous pensons aux nouvelles fonctionnalités de la version 8 de Java, la programmation fonctionnelle et les expressions lambda viennent à l’esprit.

Néanmoins, en plus de ces grandes fonctionnalités, il y en a d'autres, qui ont peut-être un impact moindre, mais aussi intéressantes et souvent pas vraiment connues ou même couvertes par une critique.

Dans ce didacticiel, nous énumérerons et donnerons un petit exemple de chacune des nouvelles méthodes ajoutées à l'une des classes principales du langage:java.lang.Math.

**2. Nouvelles méthodes*exact()**

Premièrement, nous avons un groupe de nouvelles méthodes qui étendent certaines des opérations arithmétiques existantes et les plus courantes.

Comme nous le verrons, ils sont assez explicites, car ils ont exactement les mêmes fonctionnalités que les méthodes dont ils dérivent mais avecthe addition of throwing an exception in case, the resulting value overflows the max or min values of their types.

Nous pouvons utiliser ces méthodes avec à la foisintegers etlongs comme paramètres.

2.1. addExact()

Ajoute les deux paramètres,throwing an ArithmeticException in case of overflow (which goes for all *Exact() methods) de l'addition:

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

2.2. substractExact()

Soustrait la valeur du deuxième paramètre du premier, en lançant unArithmeticException en cas de dépassement de la soustraction:

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

2.3. incrementExact()

Incrémente le paramètre de un, lançant unArithmeticException en cas de débordement:

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

2.4. decrementExact()

Décrémente le paramètre de un, lançant unArithmeticException en cas de débordement:

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

2.5. multiplyExact()

Multipliez les deux paramètres en lançant unArithmeticException en cas de débordement du produit:

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

2.6. negateExact()

Modifie le signe du paramètre, lançant unArithmeticException en cas de débordement.

Dans ce cas, il faut réfléchir à la représentation interne de la valeur en mémoire pour comprendre pourquoi il y a un débordement, ce qui n'est pas aussi intuitif que le reste des méthodes «exactes»:

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

Le deuxième exemple nécessite une explication car ce n’est pas évident:The overflow is due to the Integer.MIN_VALUE being −2.147.483.648, and on the other side the Integer.MAX_VALUE being 2.147.483.647 donc la valeur renvoyée ne rentre pas dans unInteger d’une unité.

3. Autres méthodes

3.1. floorDiv()

Divise le premier paramètre par le second, puis effectue une opérationfloor() sur le résultat, renvoyant leInteger inférieur ou égal au quotient:

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

Le quotient exact est de 3,5 doncfloor(3.5) == 3.

Regardons un autre exemple:

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

Le quotient exact est -3,5 doncfloor(-3.5) == -4.

3.2. modDiv()

Celle-ci est similaire à la méthode précédentefloorDiv(), mais en appliquant l'opérationfloor() sur le module ou le reste de la division au lieu du quotient:

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

Comme nous pouvons le voir, lesmodDiv() for two positive numbers is the same as % operator. Prenons un exemple différent:

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

Il renvoie 1 et non 2 carfloorDiv(-5, 3) vaut -2 et non -1.

3.3. nextDown()

Renvoie la valeur immédiatement inférieure du paramètre (prend en charge les paramètresfloat oudouble):

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

4. Conclusion

Dans cet article, nous avons brièvement décrit les fonctionnalités de toutes les nouvelles méthodes ajoutées à la classejava.lang.Math dans la version 8 de la plate-forme Java et avons également vu quelques exemples de leur utilisation.

Comme toujours, le code source complet est disponibleover on GitHub.

TOC