Java 8 - Exemples mathématiques exacts

Java 8 a introduit de nouvelles méthodes dans la classeMath qui lèveront unArithmeticException pour gérer les débordements. Ces méthodes se composent deaddExact,substractExact,multiplyExact,incrementExact,decrementExact etnegateExact avecint etlong arguments. En outre, il existe une méthode statiquetoIntExact pour convertir une valeurlong enint qui renvoie égalementArithmeticException.

Avant Java 8, le programmeur devait déboguer manuellement pour trouver les variables du code qui débordaient. J'étais très heureux de découvrir que Java 8 a introduit un nouvel ensemble de méthodes qui lèvent une exception lorsque le résultat déborde. Pour de nombreux développeurs, ce changement n'a pas d'effet majeur, mais pour les modestes développeurs comme moi, cela affectera certainement le temps passé à se gratter la tête pour comprendre pourquoi le résultat est faux ou à prendre des précautions compliquées pour éviter un débordement.

1. Math.multiplyExact

Cet exemple montre la différence entre la multiplication commune et le nouveaumultiplyExact

MultiplyExact.java

package com.techfou.exactmethods;

package com.techfou;

public class MultiplyExact {

    public static void main(String[] args) {

        int x = Integer.MAX_VALUE; //( = 2 147 483 647)
        int y = Integer.MAX_VALUE;
        Object z;

        System.out.println("---Before Java 8---");
        z = x * y;
        System.out.println("z : " + z);

        System.out.println("\n---Since Java 8---");
        try {

            z = Math.multiplyExact(x, y);

        } catch (ArithmeticException e) {

            System.out.println(e.getMessage()); //Java 8 throws integer overflow

            z = Math.multiplyExact((long) x, (long) y);
            System.out.println("z : " + z);
        }

        if (z instanceof Long) {
            System.out.println("\n> yuuuup z is Long");
        }
    }
}

Sortie:

---Before Java 8---
z : 1

---Since Java 8---
integer overflow
z : 4611686014132420609

> yuuuup z is Long

2. Détecter et gérer le débordement

Un exemple où nous gérons le débordement pourinteger et déterminons le débordement pourlong.

MultiplyExact2.java

package com.example.exactmethods;

public class MultiplyExact2 {

    public static void main(String[] args) {

        int x = 1000000;
        int y = 1000000;
        long a = Long.MAX_VALUE; //( = 9 223 372 036 854 775 807)
        long b = Long.MAX_VALUE;
        Object z, c;

        System.out.println("---Before Java 8---");
        z = x * y;
        c = a * b;
        System.out.println("z : " + z);
        System.out.println("c : " + c);

        System.out.println("\n---Since Java 8---");
        try {
            z = Math.multiplyExact(x, y);
            c = Math.multiplyExact(a, b);
        } catch (ArithmeticException e) {
            try {
                z = Math.multiplyExact((long) x, (long) y);
                c = null;
            } catch (ArithmeticException ex) {
                z = null;
            }
        }

        if (z instanceof Integer) {
            System.out.println("z is instance of Integer: " + z);
        }
        if (z instanceof Long) {
            System.out.println("z is instance of Long: " + z);
        } else {
            System.out.println("Overflow for z");
        }

        if (c instanceof Integer) {
            System.out.println("Instance of Integer: " + c);
        }
        if (c instanceof Long) {
            System.out.println("Instance of Long: " + c);
        } else {
            System.out.println("Overflow for c");
        }
    }
}

Sortie:

---Before Java 8---
z : -727379968
c : 1

---Since Java 8---
z is instance of Long: 1000000000000
Overflow for c

3. Toutes les méthodes xxxExact

Un exemple démontrant toutes les nouvelles méthodesxxxExact

AllExactMethods.java

package com.example.exactmethods;

public class AllExactMethods {

    public static void main(String[] args){
        int x = 10000;
        int y = 10000;
        Object z;

        z = Math.addExact(x, y);
        System.out.println("addExact: " + x + " + " + y + " = " + z);
        z = Math.subtractExact(x, y);
        System.out.println("subtractExact: " + x + " - " + y + " = " + z);
        z = Math.multiplyExact(x, y);
        System.out.println("multiplyExact: " + x + " * " + y + " = " + z);
        z = Math.incrementExact(x);
        System.out.println("incrementExact: " + x + " + 1 = " + z);
        z = Math.decrementExact(y);
        System.out.println("decrementExact: " + y + " - 1 = " + z);
        z = Math.negateExact(x);
        System.out.println("negateExact: " + x + " * -1 = " + z);
    }
}

Sortie:

addExact: 10000 + 10000 = 20000
subtractExact: 10000 - 10000 = 0
multiplyExact: 10000 * 10000 = 100000000
incrementExact: 10000 + 1 = 10001
decrementExact: 10000 - 1 = 9999
negateExact: 10000 * -1 = -10000

TOC

Java 8 - Exemples mathématiques exacts