Opérateur logique Java court-circuiter

ensemble a utilise des opérateurs booléens à court-circuitage.

ce que "court-circuiter" signifie dans le contexte des opérateurs booléens est celui d'un ensemble de booléens b1, b2, ..., bn, les versions court-circuit cesseront l'évaluation dès que le premier de ces booléens sera vrai (||) ou faux (&&).

par exemple:

// 2 == 2 will never get evaluated because it is already clear from evaluating
// 1 != 1 that the result will be false.
(1 != 1) && (2 == 2)

// 2 != 2 will never get evaluated because it is already clear from evaluating
// 1 == 1 that the result will be true.
(1 == 1) || (2 != 2)

court-circuitage " signifie que le second opérateur ne sera pas vérifié si le premier opérateur décide du résultat final.

E. G. Expression is: True / / False

dans le cas de ||, tout ce dont nous avons besoin est l'un des côtés pour être vrai. Donc si le côté gauche est vrai, il n'y a aucun point à vérifier le côté droit, et donc qui ne sera pas vérifié du tout.

De Même, Faux && Vrai

En cas de &&, nous avons besoin de des deux côtés pour être Vrai. Donc si le côté gauche est faux, il n'y a aucun intérêt à vérifier le côté droit, la réponse doit être fausse. Et donc qui ne sera pas vérifiée.

boolean a = (x < z) && (x == x);

ce type court-circuit, ce qui signifie que si (x < z) évalue à faux alors ce dernier n'est pas évalué, a sera faux, sinon && évaluera également (x == x) .

& est un opérateur bitwise, mais aussi un booléen et un opérateur qui ne court-circuit.

Vous pouvez les tester en quelque chose comme suit (voir combien de fois la méthode est appelée dans chaque cas):

public static boolean getFalse() {
    System.out.println("Method");
    return false;
}

public static void main(String[] args) {
    if(getFalse() && getFalse()) { }        
    System.out.println("=============================");        
    if(getFalse() & getFalse()) { }
}

en termes simples, court-circuiter signifie arrêter l'évaluation une fois que vous savez que la réponse ne peut plus changer. Par exemple, si vous évaluez une chaîne de AND logique et que vous découvrez un FALSE au milieu de cette chaîne, vous savez que le résultat va être faux, peu importe les valeurs du reste des expressions de la chaîne. Même chose pour une chaîne de OR s: Une fois que vous découvrez un TRUE , vous savez la réponse tout de suite, et donc vous pouvez sauter l'évaluation du reste des expressions.

vous indiquez à Java que vous voulez court-circuiter en utilisant && au lieu de & et || au lieu de | . Le premier set de votre poteau est court-circuitant.

notez que c'est plus qu'une tentative de sauvegarder quelques cycles CPU: dans des expressions comme celle-ci

if (mystring != null && mystring.indexOf('+') > 0) {
    ...
}

court-circuit signifie une différence entre fonctionnement correct et un crash (dans le cas où mystring est nul).

Java fournit deux opérateurs booléens intéressants qui ne se trouvent pas dans la plupart des autres langues informatiques. Ces versions secondaires de et et ou sont connus sous le nom de opérateurs de court-circuit logique . Comme vous pouvez le voir dans le tableau précédent, l'opérateur OR donne true quand A est true, peu importe ce que B est.

de la même façon, L'opérateur et donne un résultat faux quand A est faux, peu importe ce que B est. Si vous utilisez les formulaires || et && , plutôt que les formes | et & de ces opérateurs, Java ne se contentera pas d'évaluer l'opérande de droite. Ceci est très utile lorsque l'opérande de droite dépend du fait que la gauche soit vraie ou fausse pour fonctionner correctement.

par exemple, le fragment de code suivant montre comment vous pouvez profiter de l'évaluation logique de court-circuit pour être sûr qu'une opération de division sera valide avant de l'évaluer:

if ( denom != 0 && num / denom >10)

étant donné que la forme de court-circuit de et ( && ) est utilisée, il n'y a aucun risque de provoquer une exception de durée de fonctionnement en divisant par zéro. Si cette ligne de code était écrite en utilisant la seule version & de et, les deux côtés devraient être évalués, provoquant une exception d'exécution du temps lorsque denom est zéro.

il est de pratique courante d'utiliser les formes de court-circuit et et / ou dans les cas impliquant la logique booléenne, en laissant le caractère unique versions exclusivement pour les opérations bitwise. Toutefois, il y a des exceptions à cette règle. Par exemple, considérons l'énoncé suivant:

 if ( c==1 & e++ < 100 ) d = 100;

ici, en utilisant un seul & assure que l'opération d'incrément sera appliquée à e si c est égal à 1 ou non.

OU Logique :- retourne true si au moins un des opérandes true. Les deux opérandes sont évaluées avant d'appliquer l'opérateur ou.

court-Circuit ou: - si l'opérande de gauche retourne true, elle retourne true sans évaluer l'opérande de droite.

if(demon!=0&& num/demon>10)

puisque la forme de court-circuit de et (& & ) est utilisée, il n'y a aucun risque de causer une exception de fonctionnement lorsque le démon est zéro.

Réf. Java 2 cinquième édition par Herbert Schildt

il y a quelques différences entre les opérateurs & et && . Les mêmes différences s'appliquent à | et || . La chose la plus importante à garder à l'esprit est que && est un opérateur logique qui s'applique seulement aux opérandes booléennes, tandis que & est un bitwise opérateur qui s'applique aux types entiers aussi bien que booléens.

Avec une opération logique, vous peut faire court-circuiter parce que dans certains cas (comme le premier opérande de && étant false , ou le premier opérande de || étant true ), vous n'avez pas besoin d'évaluer le reste de l'expression. C'est très utile pour faire des choses comme vérifier pour null avant d'accéder à un fichier ou une méthode, et vérifier des zéros potentiels avant de les diviser par eux. Pour une expression complexe, chaque partie de l'expression est évaluée de façon récursive dans la même manière. Pour exemple, dans le cas suivant:

(7 == 8) || ((1 == 3) && (4 == 4))

seules les parties accentuées seront évaluées. Pour calculer le || , Vérifiez d'abord si 7 == 8 est true . Si c'était le cas, la droite serait totalement ignorées. Le côté droit ne vérifie que si 1 == 3 est false . Depuis il est, 4 == 4 n'a pas besoin d'être vérifié, et l'ensemble de l'expression false . Si le côté gauche était true , par exemple 7 == 7 au lieu de 7 == 8 , tout le côté droit serait sauté parce que toute l'expression || serait true indépendamment.

avec une opération bitwise, vous devez évaluer tous les opérandes parce que vous êtes vraiment juste la combinaison des bits. Les booléens sont effectivement un entier d'un bit en Java (indépendamment de la façon dont les internes fonctionnent), et c'est juste une coïncidence que vous pouvez faire un court-circuitage pour les opérateurs bitwise dans ce cas particulier. La raison pour laquelle vous ne pouvez pas court-circuiter un entier général & ou | opération est que certains bits peuvent être allumés et certains peuvent être désactivés dans l'un ou l'autre opérande. Quelque chose comme 1 & 2 donne zéro, mais vous n'avez aucun moyen de le savoir sans évaluer les deux opérandes.