streamalism.org

1. Introduktion

Normalt, når vi tænker på de nye funktioner, der fulgte med version 8 af Java, er funktionel programmering og lambda-udtryk de første ting, der kommer til at tænke på.

Ikke desto mindre er der foruden de store funktioner andre, måske med mindre indflydelse, men også interessante og mange gange ikke rigtig kendte eller endda dækket af nogen anmeldelse.

I denne vejledning opregner vi og giver et lille eksempel på hver af de nye metoder, der er føjet til en af ​​sprogets kerneklasser: java.lang.Math.

2. Ny *eksakt() Metoder

For det første har vi en gruppe nye metoder, der udvider nogle af de eksisterende og mest almindelige aritmetiske operationer.

Som vi vil se, er de ret selvforklarende, da de har nøjagtig den samme funktionalitet end de metoder, de stammer fra, men med tilføjelsen af ​​at kaste en undtagelse i tilfælde af, at den resulterende værdi overløber max- eller min-værdierne for deres typer.

Vi kan bruge disse metoder med begge heltal og længes som parametre.

2.1. addExact ()

Tilføjer de to parametre, kaster en Aritmetisk undtagelse i tilfælde af overløb (hvilket gælder for alle *Eksakt() metoder) af tilføjelsen:

Math.addExact (100, 50); // returnerer 150 Math.addExact (Integer.MAX_VALUE, 1); // kaster ArithmeticException

2.2. substrakt Eksakt ()

Substraherer værdien af ​​den anden parameter fra den første og kaster en Aritmetisk undtagelse i tilfælde af overløb af subtraktionen:

Math.subtractExact (100, 50); // returnerer 50 Math.subtractExact (Long.MIN_VALUE, 1); // kaster ArithmeticException

2.3. inkrementExact ()

Forøger parameteren med en, kaster en Aritmetisk undtagelse i tilfælde af overløb:

Math.incrementExact (100); // returnerer 101 Math.incrementExact (Integer.MAX_VALUE); // kaster ArithmeticException

2.4. decrementExact ()

Reducerer parameteren med en, kaster en Aritmetisk undtagelse i tilfælde af overløb:

Math.decrementExact (100); // returnerer 99 Math.decrementExact (Long.MIN_VALUE); // kaster ArithmeticException

2.5. multiplicere præcis ()

Multiplicer de to parametre, kast en Aritmetisk undtagelse i tilfælde af overløb af produktet:

Math.multiplyExact (100, 5); // returnerer 500 Math.multiplyExact (Long.MAX_VALUE, 2); // kaster ArithmeticException

2.6. negateExact ()

Ændrer parameterets tegn og kaster et Aritmetisk undtagelse i tilfælde af overløb.

I dette tilfælde skal vi tænke på den interne repræsentation af værdien i hukommelsen for at forstå, hvorfor der er et overløb, hvilket ikke er så intuitivt som resten af ​​de "nøjagtige" metoder:

Math.negateExact (100); // returnerer -100 Math.negateExact (Integer.MIN_VALUE); // kaster ArithmeticException

Det andet eksempel kræver en forklaring, da det ikke er indlysende: Overløbet skyldes Heltal.MIN_VALUE være −2.147.483.648, og på den anden side Heltal.MAX_VALUE bliver 2.147.483.647 så den returnerede værdi ikke passer ind i en Heltal af en enhed.

3. Andre metoder

3.1. floorDiv ()

Opdeler den første parameter med den anden og udfører derefter a etage() operation over resultatet, returnering af Heltal det er mindre eller lig med kvotienten:

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

Den nøjagtige kvotient er 3,5 så etage (3.5) == 3.

Lad os se på et andet eksempel:

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

Den nøjagtige kvotient er -3,5 så etage (-3,5) == -4.

3.2. modDiv ()

Denne svarer til den foregående metode floorDiv (), men anvender etage() operation over modulet eller den resterende deling i stedet for kvotienten:

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

Som vi kan se, er modDiv () for to positive tal er det samme som% operator. Lad os se på et andet eksempel:

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

Det returnerer 1 og ikke 2 fordi floorDiv (-5, 3) er -2 og ikke -1.

3.3. næste ned ()

Returnerer den umiddelbart lavere værdi af parameteren (understøtter flyde eller dobbelt parametre):

flyde f = Math.nextDown (3); // returnerer 2.9999998 dobbelt d = Math.nextDown (3); // returnerer 2.999999761581421

4. Konklusion

I denne artikel har vi kort beskrevet funktionaliteten af ​​alle de nye metoder, der er føjet til klassen java.lang.Math i version 8 af Java-platformen og også set nogle eksempler på, hvordan man bruger dem.

Som altid er den fulde kildekode tilgængelig på GitHub.