Java 8 Math Nouvelles méthodes

1. Introduction

Habituellement, quand on pense aux nouvelles fonctionnalités fournies avec la version 8 de Java, la programmation fonctionnelle et les expressions lambda sont les premières choses qui 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 tutoriel, nous énumérerons et donnerons un petit exemple de chacune des nouvelles méthodes ajoutées à l'une des classes de base 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 avec l'ajout d'une exception au cas où, la valeur résultante dépasse les valeurs max ou min de leurs types .

Nous pouvons utiliser ces méthodes avec des entiers et des longs comme paramètres.

2.1. addExact ()

Ajoute les deux paramètres, lançant une ArithmeticException en cas de débordement (ce qui vaut pour toutes les méthodes * Exact () ) de l'ajout:

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 une ArithmeticException 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 une ArithmeticException en cas de débordement:

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

2.4. décrémentExact ()

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

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

2.5. multiplierExact ()

Multipliez les deux paramètres en lançant une ArithmeticException 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 une ArithmeticException 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: le débordement est dû au fait que Integer.MIN_VALUE est −2.147.483.648, et de l'autre côté, Integer.MAX_VALUE est 2.147.483.647 donc la valeur retournée ne rentre pas dans un Integer d'une unité.

3. Autres méthodes

3.1. floorDiv ()

Divise le premier paramètre par le second, puis exécute une opération floor () sur le résultat, en retournant l' entier inférieur ou égal au quotient:

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

Le quotient exact est de 3,5 donc floor (3,5) == 3.

Regardons un autre exemple:

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

Le quotient exact est -3,5 donc plancher (-3,5) == -4.

3.2. modDiv ()

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

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

Comme nous pouvons le voir, le modDiv () pour deux nombres positifs est le même que l'opérateur% . Regardons un exemple différent:

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

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

3.3. suivantDown ()

Renvoie la valeur immédiatement inférieure du paramètre (prend en charge les paramètres flottants ou doubles ):

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

4. Conclusion

Dans cet article, nous avons décrit brièvement les fonctionnalités de toutes les nouvelles méthodes ajoutées à la classe java.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 disponible à l'adresse over sur GitHub.