Les opérateurs en Java : arithmétiques, de comparaison, logiques et d'affectation

À quoi servent les opérateurs

Les opérateurs sont les symboles qui combinent des valeurs pour en calculer de nouvelles. Vous les utilisez déjà de façon informelle - + additionne, > compare - et Java les regroupe en quelques familles : arithmétiques, de comparaison, logiques, d'affectation, plus quelques cas spéciaux comme l'incrémentation et le ternaire.

La plupart des opérateurs prennent deux valeurs (une avant, une après le symbole) et produisent un résultat. Toute la subtilité consiste à savoir de quel type est ce résultat et dans quel ordre ils s'appliquent - c'est là que les débutants trébuchent.

Les opérateurs arithmétiques

Les cinq opérateurs arithmétiques travaillent sur des nombres : +, -, *, / et % (reste).

public class Main {
    public static void main(String[] args) {
        int a = 17;
        int b = 5;

        System.out.println(a + b);   // 22
        System.out.println(a - b);   // 12
        System.out.println(a * b);   // 85
        System.out.println(a / b);   // 3  (division entière !)
        System.out.println(a % b);   // 2  (le reste)
    }
}

L'opérateur % est le reste après la division : 17 % 5 vaut 2 parce que 5 entre trois fois dans 17 en laissant 2. C'est l'outil quotidien pour tester la divisibilité - n % 2 == 0 est le test standard « n est-il pair ? ».

Notez aussi que + joue un double rôle : avec des nombres il additionne, mais avec une String d'un côté ou de l'autre il assemble du texte.

public class Main {
    public static void main(String[] args) {
        System.out.println("Total: " + 3 + 4);   // Total: 34
        System.out.println("Total: " + (3 + 4));  // Total: 7
    }
}

La première ligne se lit de gauche à droite : "Total: " + 3 est déjà une chaîne, donc le 4 est ajouté comme texte. Encadrez le calcul de parenthèses quand vous voulez qu'il soit effectué en premier.

Le piège de la division entière

C'est la surprise la plus fréquente de toutes. Quand les deux opérandes de / sont des entiers, Java effectue une division entière et écarte la fraction - il n'arrondit pas, il tronque vers zéro.

public class Main {
    public static void main(String[] args) {
        System.out.println(5 / 2);        // 2, pas 2.5
        System.out.println(9 / 10);       // 0
        System.out.println(5.0 / 2);      // 2.5  (un seul double suffit)
        System.out.println((double) 5 / 2); // 2.5 (convertir un opérande)
    }
}

Pour obtenir un résultat décimal, faites en sorte qu'au moins un opérande soit un double - écrivez-le avec un .0, ou convertissez un côté avec (double). Faire (double)(5 / 2) n'aide pas, car la division entière 5 / 2 a déjà eu lieu avant la conversion ; vous devez convertir un opérande, pas le résultat.

Les opérateurs de comparaison

Les opérateurs de comparaison posent une question oui/non et renvoient un boolean. Il y en a six : ==, !=, <, >, <=, >=.

public class Main {
    public static void main(String[] args) {
        int score = 75;

        System.out.println(score >= 60);   // true
        System.out.println(score == 100);  // false
        System.out.println(score != 0);    // true
    }
}

Attention à la différence entre = (affectation - « mets cette valeur ici ») et == (comparaison - « sont-ils égaux ? »). Les confondre est un bug classique.

Une mise en garde importante : == compare les références d'objets, pas les contenus. Pour les chaînes, utilisez .equals().

public class Main {
    public static void main(String[] args) {
        String a = "hi";
        String b = new String("hi");

        System.out.println(a == b);        // false - objets différents
        System.out.println(a.equals(b));   // true  - même texte
    }
}

Utilisez == pour les types primitifs comme int et boolean, et .equals() chaque fois que vous comparez le contenu d'objets tels que String.

Les opérateurs logiques

Les opérateurs logiques combinent des valeurs booléennes : && (et), || (ou) et ! (non). C'est ainsi que vous exprimez des conditions comme « assez âgé et a un billet ».

public class Main {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;

        System.out.println(age >= 18 && hasTicket);  // true
        System.out.println(age < 13 || hasTicket);    // true
        System.out.println(!hasTicket);                // false
    }
}

&& et || font un court-circuit : Java arrête d'évaluer dès que la réponse est certaine. Avec &&, si le côté gauche est false, le côté droit n'est jamais vérifié ; avec ||, si le côté gauche est true, le côté droit est ignoré. Ce n'est pas qu'une optimisation - vous pouvez vous en servir pour la sécurité :

if (text != null && text.length() > 0) { ... }

Si text est null, le côté gauche est false et text.length() n'est jamais appelé, ce qui évite une NullPointerException. Inversez l'ordre et le programme planterait.

Affectation et incrémentation

= affecte, mais Java possède aussi des affectations composées qui combinent une opération et une affectation : +=, -=, *=, /=, %=. Et ++ / -- ajoutent ou retranchent un.

public class Main {
    public static void main(String[] args) {
        int count = 10;

        count += 5;   // count = count + 5  -> 15
        count -= 2;   // -> 13
        count *= 2;   // -> 26
        System.out.println(count);

        count++;      // -> 27
        count--;      // -> 26
        System.out.println(count);
    }
}

++ existe en deux variantes : postfixée (count++) renvoie l'ancienne valeur puis incrémente ; préfixée (++count) incrémente d'abord puis renvoie la nouvelle valeur. La différence ne compte que lorsque vous utilisez le résultat dans la même expression :

public class Main {
    public static void main(String[] args) {
        int x = 5;
        System.out.println(x++);   // affiche 5, puis x devient 6
        System.out.println(++x);   // x devient 7, affiche 7
    }
}

Quand ++ est seul sur sa ligne, postfixé ou préfixé ne change rien - préférez donc celui qui se lit le plus clairement et n'entassez pas d'incrémentations dans des expressions plus grandes.

L'opérateur ternaire

Le ternaire condition ? a : b est un if/else compact qui produit une valeur : si la condition est true il vaut a, sinon b.

public class Main {
    public static void main(String[] args) {
        int score = 72;

        String result = score >= 60 ? "pass" : "fail";
        System.out.println(result);   // pass

        int max = (score > 100) ? 100 : score;
        System.out.println(max);      // 72
    }
}

Il brille pour les affectations courtes de type ceci-ou-cela. Résistez à la tentation d'imbriquer des ternaires dans des ternaires - cela devient vite illisible, et un simple if/else est plus clair.

Priorité et parenthèses

Les opérateurs s'appliquent dans un ordre fixe, un peu comme en mathématiques : *, /, % se lient plus fort que + et -, qui se lient plus fort que les comparaisons, qui se lient plus fort que &&, puis ||.

public class Main {
    public static void main(String[] args) {
        System.out.println(2 + 3 * 4);        // 14, pas 20
        System.out.println((2 + 3) * 4);      // 20
        System.out.println(5 > 3 && 1 < 2);   // true
    }
}

Vous n'avez pas besoin de mémoriser le tableau complet. Quand une expression mélange des familles ou que vous devez vous arrêter pour deviner l'ordre, ajoutez des parenthèses - elles ne coûtent rien et rendent l'intention évidente pour le prochain lecteur.

Ensuite : la conversion de type (casting)

Plusieurs pièges vus ici - la division entière, le mélange de int et de double - se ramènent aux types. Convertir délibérément entre types numériques s'appelle le casting, et c'est le sujet de la page suivante.