Java Language Les opérateurs conditionnels et et / ou conditionnels (&& et ||)


Exemple

Java fournit un opérateur conditionnel et un opérateur conditionnel ou conditionnel, qui prennent tous deux un ou deux opérandes de type boolean et produisent un résultat boolean . Ceux-ci sont:

  • && - l'opérateur AND conditionnel,

  • || - les opérateurs conditionnels-OU. L’évaluation de <left-expr> && <right-expr> est équivalente au pseudo-code suivant:

    {
       boolean L = evaluate(<left-expr>);
       if (L) {
           return evaluate(<right-expr>);
       } else {
           // short-circuit the evaluation of the 2nd operand expression
           return false;
       }
    }
    

L'évaluation de <left-expr> || <right-expr> est équivalent au pseudo-code suivant:

    {
       boolean L = evaluate(<left-expr>);
       if (!L) {
           return evaluate(<right-expr>);
       } else {
           // short-circuit the evaluation of the 2nd operand expression
           return true;
       }
    }

Comme le montre le pseudo-code ci-dessus, le comportement des opérateurs de court-circuit équivaut à utiliser des instructions if / else .

Exemple - utilisation de && comme garde dans une expression

L'exemple suivant montre le modèle d'utilisation le plus courant pour l'opérateur && . Comparez ces deux versions d'une méthode pour tester si un Integer fourni est zéro.

public boolean isZero(Integer value) {
    return value == 0;
}

public boolean isZero(Integer value) {
    return value != null && value == 0;
}

La première version fonctionne dans la plupart des cas, mais si l'argument value est null , une NullPointerException sera lancée.

Dans la deuxième version, nous avons ajouté un test de "garde". La value != null && value == 0 expression est évaluée en exécutant d'abord le test value != null . Si le test null réussit (c.-à-d. Qu'il est évalué à true ), l'expression value == 0 est évaluée. Si le test null échoue, alors l'évaluation de la value == 0 est ignorée (court-circuitée) et nous n'obtenons pas une NullPointerException .

Exemple - utilisation de && pour éviter un calcul coûteux

L'exemple suivant montre comment && peut être utilisé pour éviter un calcul relativement coûteux:

public boolean verify(int value, boolean needPrime) {
    return !needPrime | isPrime(value);
}

public boolean verify(int value, boolean needPrime) {
    return !needPrime || isPrime(value);
}

Dans la première version, les deux opérandes du | sera toujours évalué, donc la méthode (coûteuse) isPrime sera appelée inutilement. La deuxième version évite l'appel inutile en utilisant || au lieu de | .