Nuovi metodi matematici Java 8

1. Introduzione

Di solito, quando pensiamo alle nuove funzionalità fornite con la versione 8 di Java, la programmazione funzionale e le espressioni lambda sono le prime cose che vengono in mente.

Tuttavia, oltre a queste grandi caratteristiche ce ne sono altre, forse di minore impatto ma anche interessanti e molte volte non molto conosciute o addirittura coperte da alcuna recensione.

In questo tutorial, enumereremo e daremo un piccolo esempio di ciascuno dei nuovi metodi aggiunti a una delle classi principali del linguaggio: java.lang.Math .

2. Nuovi metodi * exact ()

Innanzitutto, abbiamo un gruppo di nuovi metodi che estendono alcune delle operazioni aritmetiche esistenti e più comuni.

Come vedremo, sono abbastanza autoesplicativi, in quanto hanno esattamente la stessa funzionalità dei metodi da cui derivano ma con l'aggiunta di lanciare un'eccezione nel caso in cui il valore risultante superi i valori massimi o minimi dei loro tipi .

Possiamo usare questi metodi sia con interi che con long come parametri.

2.1. addExact ()

Aggiunge i due parametri, lanciando un'eccezione ArithmeticException in caso di overflow (che vale per tutti i metodi * Exact () ) dell'addizione:

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

2.2. substractExact ()

Sottrae il valore del secondo parametro dal primo, lanciando un'eccezione ArithmeticException in caso di overflow della sottrazione:

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

2.3. incrementExact ()

Incrementa il parametro di uno, generando un'eccezione ArithmeticException in caso di overflow:

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

2.4. decrementExact ()

Decrementa il parametro di uno, generando un'eccezione ArithmeticException in caso di overflow:

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

2.5. multiplyExact ()

Moltiplica i due parametri, lanciando un'eccezione ArithmeticException in caso di overflow del prodotto:

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

2.6. negateExact ()

Modifica il segno del parametro, generando un'eccezione ArithmeticException in caso di overflow.

In questo caso, dobbiamo pensare alla rappresentazione interna del valore in memoria per capire perché c'è un overflow, in quanto non è intuitivo come il resto dei metodi "esatti":

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

Il secondo esempio richiede una spiegazione in quanto non è ovvio: l'overflow è dovuto al fatto che Integer.MIN_VALUE è −2.147.483.648 e dall'altra parte Integer.MAX_VALUE è 2.147.483.647, quindi il valore restituito non rientra in un Integer di una unità.

3. Altri metodi

3.1. floorDiv ()

Divide il primo parametro per il secondo, quindi esegue un'operazione floor () sul risultato, restituendo l' Integer minore o uguale al quoziente:

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

Il quoziente esatto è 3.5 quindi floor (3.5) == 3.

Diamo un'occhiata a un altro esempio:

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

Il quoziente esatto è -3,5 quindi floor (-3,5) == -4.

3.2. modDiv ()

Questo è simile al metodo precedente floorDiv () , ma applica l' operazione floor () sul modulo o sul resto della divisione anziché sul quoziente:

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

Come possiamo vedere, modDiv () per due numeri positivi è lo stesso dell'operatore% . Diamo un'occhiata a un esempio diverso:

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

Restituisce 1 e non 2 perché floorDiv (-5, 3) è -2 e non -1.

3.3. nextDown ()

Restituisce il valore immediatamente inferiore del parametro (supporta parametri float o double ):

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

4. Conclusione

In questo articolo abbiamo descritto brevemente le funzionalità di tutti i nuovi metodi aggiunti alla classe java.lang.Math nella versione 8 della piattaforma Java e abbiamo visto anche alcuni esempi di come utilizzarli.

Come sempre, il codice sorgente completo è disponibile su GitHub.