Java 8 Math nieuwe methoden

1. Inleiding

Als we nadenken over de nieuwe functies van versie 8 van Java, zijn functioneel programmeren en lambda-expressies meestal de eerste dingen die in ons opkomen.

Desalniettemin zijn er naast die grote functies nog andere, die misschien een kleinere impact hebben, maar ook interessant en vaak niet echt bekend zijn of zelfs maar worden behandeld door een recensie.

In deze tutorial zullen we een opsomming geven en een klein voorbeeld geven van elk van de nieuwe methoden die zijn toegevoegd aan een van de kernklassen van de taal: java.lang.Math.

2. Nieuw * exact () Methoden

Ten eerste hebben we een groep nieuwe methoden die een aantal van de bestaande en meest voorkomende rekenkundige bewerkingen uitbreiden.

Zoals we zullen zien, spreken ze voor zich, omdat ze precies dezelfde functionaliteit hebben als de methoden waarvan ze zijn afgeleid, maar met de toevoeging van het gooien van een uitzondering in het geval dat de resulterende waarde de max of min waarden van hun typen overschrijdt.

We kunnen deze methoden met beide gebruiken gehele getallen en verlangt als parameters.

2.1. addExact ()

Voegt de twee parameters toe, het gooien van een ArithmeticException in geval van overloop (wat voor iedereen geldt * Exact () methoden) van de toevoeging:

Math.addExact (100, 50); // retourneert 150 Math.addExact (Integer.MAX_VALUE, 1); // gooit ArithmeticException

2.2. aftrekkenExact ()

Trekt de waarde van de tweede parameter af van de eerste en gooit een ArithmeticException in het geval van overloop van de aftrekking:

Math.subtractExact (100, 50); // retourneert 50 Math.subtractExact (Long.MIN_VALUE, 1); // gooit ArithmeticException

2.3. incrementExact ()

Verhoogt de parameter met één en gooit een ArithmeticException bij overloop:

Math.incrementExact (100); // retourneert 101 Math.incrementExact (Integer.MAX_VALUE); // gooit ArithmeticException

2.4. decrementExact ()

Verlaagt de parameter met één door een ArithmeticException bij overloop:

Math.decrementExact (100); // retourneert 99 Math.decrementExact (Long.MIN_VALUE); // gooit ArithmeticException

2.5. vermenigvuldigenExact ()

Vermenigvuldig de twee parameters, gooi een ArithmeticException in geval van overlopen van het product:

Math.multiplyExact (100, 5); // retourneert 500 Math.multiplyExact (Long.MAX_VALUE, 2); // gooit ArithmeticException

2.6. negateExact ()

Verandert het teken van de parameter door een ArithmeticException in geval van overstroming.

In dit geval moeten we nadenken over de interne representatie van de waarde in het geheugen om te begrijpen waarom er een overflow is, aangezien dit niet zo intuïtief is als de rest van de "exacte" methoden:

Math.negateExact (100); // retourneert -100 Math.negateExact (Integer.MIN_VALUE); // gooit ArithmeticException

Het tweede voorbeeld vereist een uitleg, omdat het niet duidelijk is: De overloop is te wijten aan de Geheel getal.MIN_VALUE zijnde -2.147.483.648, en aan de andere kant de Geheel getal.MAX_VALUE zijnde 2.147.483.647 dus de geretourneerde waarde past niet in een Geheel getal door een eenheid.

3. Andere methoden

3.1. floorDiv ()

Deelt de eerste parameter door de tweede en voert vervolgens een uit verdieping() bewerking over het resultaat, waarbij de Geheel getal dat is kleiner of gelijk aan het quotiënt:

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

Het exacte quotiënt is dus 3,5 verdieping (3.5) == 3.

Laten we naar een ander voorbeeld kijken:

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

Het exacte quotiënt is dus -3,5 verdieping (-3,5) == -4.

3.2. modDiv ()

Deze is vergelijkbaar met de vorige methode floorDiv (), maar het toepassen van de verdieping() operatie over de modulus of rest van de deling in plaats van het quotiënt:

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

Zoals we kunnen zien, is de modDiv () voor twee positieve getallen is hetzelfde als% operator. Laten we naar een ander voorbeeld kijken:

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

Het retourneert 1 en niet 2 omdat floorDiv (-5, 3) is -2 en niet -1.

3.3. volgendeDown ()

Retourneert de onmiddellijk lagere waarde van de parameter (ondersteunt vlotter of dubbele parameters):

zweven f = Math.nextDown (3); // retourneert 2.9999998 dubbele d = Math.nextDown (3); // retourneert 2.999999761581421

4. Conclusie

In dit artikel hebben we kort de functionaliteit beschreven van alle nieuwe methoden die aan de klasse zijn toegevoegd java.lang.Math in versie 8 van het Java-platform en ook enkele voorbeelden gezien van hoe je ze kunt gebruiken.

Zoals altijd is de volledige broncode beschikbaar op GitHub.