Différence entre & et &&

J’ai toujours pensé que l’opérateur && en Java est utilisé pour vérifier si ses deux opérandes booléens sont true et que l’opérateur & est utilisé pour effectuer des opérations sur deux types d’entiers.

Récemment, j’ai appris que l’opérateur peut aussi être utilisé pour vérifier si ses deux opérandes booléens sont true , la seule différence est qu’il vérifie l’opérande RHS même si l’opérande LHS est faux.

L’opérateur en Java est-il surchargé en interne? Ou y a-t-il un autre concept derrière cela?

Related of "Différence entre & et &&"

& < - vérifie les deux opérandes
&& < - arrête d'évaluer si le premier opérande a la valeur false car le résultat sera faux

(x != 0) & (1/x > 1) < - cela signifie évaluer (x != 0) puis évaluer (1/x > 1) puis faire le &. le problème est que pour x = 0, une exception sera lancée.

(x != 0) && (1/x > 1) < - cela signifie évaluer (x != 0) et seulement si cela est vrai alors évaluer (1/x > 1) donc si vous avez x = 0 alors ceci est parfaitement sûr et ne jettera aucune exception si (x! = 0) a la valeur false, le tout est directement évalué à false sans évaluer le (1/x > 1) .

MODIFIER:

exprA | exprB exprA | exprB < - cela signifie évaluer exprA puis évaluer exprB puis faire le | .

exprA || exprB exprA || exprB < - cela signifie évaluer exprA et seulement si c’est false alors évaluez exprB et faites le || .

En plus de ne pas être un évaluateur paresseux en évaluant les deux opérandes, je pense que les principales caractéristiques des opérateurs binarys comparent chaque octet d’opérandes comme dans l’exemple suivant:

 int a = 4; int b = 7; System.out.println(a & b); // prints 4 //meaning in an 32 bit system // 00000000 00000000 00000000 00000100 // 00000000 00000000 00000000 00000111 // =================================== // 00000000 00000000 00000000 00000100 
 boolean a, b; Operation Meaning Note --------- ------- ---- a && b logical AND short-circuiting a || b logical OR short-circuiting a & b boolean logical AND not short-circuiting a | b boolean logical OR not short-circuiting a ^ b boolean logical exclusive OR !a logical NOT short-circuiting (x != 0) && (1/x > 1) SAFE not short-circuiting (x != 0) & (1/x > 1) NOT SAFE 

Cela dépend du type des arguments …

Pour les arguments entiers, l’esperluète simple (“&”) est l’opérateur “bit-wise AND”. La double esperluette (“&&”) n’est définie que pour deux arguments booléens.

Pour les arguments booléens, l’esperluète unique constitue l’opérateur “logique AND” (inconditionnel) alors que l’esperluette double (“&&”) est l’opérateur “ET logique conditionnel”. C’est-à-dire que l’esperluète unique évalue toujours les deux arguments alors que la double esperluette évaluera uniquement le second argument si le premier argument est vrai.

Pour tous les autres types d’arguments et combinaisons, une erreur de compilation doit se produire.

&& est un opérateur de court-circuit alors que & est un opérateur AND.

Essaye ça.

  Ssortingng s = null; boolean b = false & s.isEmpty(); // NullPointerException boolean sb = false && s.isEmpty(); // sb is false 

Je pense que ma réponse peut être plus compréhensible:

Il existe deux différences entre & et && .

S’ils utilisent comme logique ET

& and && peut être logique AND , lorsque le résultat de l’expression & ou && gauche et à droite est tout vrai, le résultat de l’opération entière peut être vrai.

quand & et && comme logique AND , il y a une différence:

lorsque vous utilisez && comme logique AND , si le résultat de l’expression de gauche est faux, l’expression correcte ne s’exécutera pas.

Prenons l’exemple:

 Ssortingng str = null; if(str!=null && !str.equals("")){ // the right expression will not execute } 

Si vous utilisez & :

 Ssortingng str = null; if(str!=null & !str.equals("")){ // the right expression will execute, and throw the NullPointerException } 

Un autre exemple:

 int x = 0; int y = 2; if(x==0 & ++y>2){ System.out.print(“y=”+y); // print is: y=3 } 

 int x = 0; int y = 2; if(x==0 && ++y>2){ System.out.print(“y=”+y); // print is: y=2 } 

& peut être utilisé comme opérateur de bit

& peut être utilisé comme opérateur Bitwise AND , && ne peut pas.

L’opérateur binary AND “&” produit 1 si et seulement si les deux bits de ses opérandes sont 1. Cependant, si les deux bits sont à 0 ou si les deux bits sont différents, cet opérateur produit 0. Pour être plus précis au niveau du bit L’opérateur AND “&” renvoie 1 si l’un des deux bits est égal à 1 et renvoie 0 si l’un des bits est égal à 0.

De la page wiki:

http://www.roseindia.net/java/master-java/java-bitwise-and.shtml

c’est comme spécifié dans le JLS (15.22.2) :

Lorsque les deux opérandes de &, ^, ou | L’opérateur est de type booléen ou booléen, alors le type d’expression de l’opérateur au niveau du bit est booléen. Dans tous les cas, les opérandes sont soumis à la conversion unboxing (§5.1.8) si nécessaire.

Pour &, la valeur du résultat est true si les deux valeurs d’opérande sont vraies; sinon, le résultat est faux.

Pour ^, la valeur du résultat est true si les valeurs de l’opérande sont différentes. sinon, le résultat est faux.

Pour |, la valeur du résultat est false si les deux valeurs d’opérande sont fausses; sinon, le résultat est vrai.

Le “truc” est que & est un opérateur binary Integer ainsi qu’un opérateur logique booléen . Alors, pourquoi ne pas voir cela comme un exemple de surcharge de l’opérateur est raisonnable.

‘&&’: – est un opérateur AND logique qui produit une valeur booléenne true ou false en fonction de la relation logique de ses arguments.

Par exemple: – Condition1 && Condition2

Si Condition1 est fausse, alors (Condition1 && Condition2) sera toujours false, raison pour laquelle cet opérateur logique est également appelé opérateur de court-circuit car il n’évalue pas une autre condition. Si Condition1 est fausse, il n’est pas nécessaire d’évaluer Condtiton2.

Si Condition1 est vraie, alors Condition2 est évaluée, si elle est vraie alors le résultat global sera vrai, sinon ce sera faux.

‘&’: – est un opérateur bit à bit ET. Il produit un (1) dans la sortie si les deux bits d’entrée ne font qu’un. Sinon, il produit zéro (0).

Par exemple:-

int a = 12; // représentation binary de 12 est 1100

int b = 6; // la représentation binary de 6 est 0110

int c = (a & b); // la représentation binary de (12 & 6) est 0100

La valeur de c est 4.

pour référence, référez-vous à cette http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html

&& et || sont appelés opérateurs de court-circuit. Quand ils sont utilisés, pour || – si le premier opérande est évalué à true , le rest des opérandes ne sont pas évalués. Pour && – si le premier opérande est évalué à false , le rest ne sera pas évalué du tout.

donc if (a || (++x > 0)) dans cet exemple la variable x ne sera pas incrémentée si a était true .

Avec les booléens, il n’y a pas de différence de sortie entre les deux. Vous pouvez échanger && et & ou || et | et cela ne changera jamais le résultat de votre expression.

La différence réside dans la scène où l’information est en cours de traitement. Lorsque vous redressez une expression “(a! = 0) & (b! = 0)” pour a = 0 et b = 1, ce qui suit se produit:

 left side: a != 0 --> false right side: b 1= 0 --> true left side and right side are both true? --> false expression returns false 

Lorsque vous écrivez une expression (a != 0) && ( b != 0) lorsque a = 0 et b = 1, les événements suivants se produisent:

 a != 0 -->false expression returns false 

Moins d’étapes, moins de traitement, meilleur codage, en particulier lors de nombreuses expressions booléennes ou d’arguments compliqués.

Outre && et || étant court-circuitant, considérez également la priorité de l’opérateur lors du mélange des deux formes. Je pense qu’il ne sera pas immédiatement évident pour tout le monde que result1 et result2 contiennent des valeurs différentes.

 boolean a = true; boolean b = false; boolean c = false; boolean result1 = a || b && c; //is true; evaluated as a || (b && c) boolean result2 = a | b && c; //is false; evaluated as (a | b) && c 

& est un opérateur binary plus utilisé pour vérifier les deux conditions parce que parfois nous devons évaluer les deux conditions. Mais l’opérateur logique && passe à la 2ème condition lorsque la première condition est vraie.

toutes les réponses sont great et il semble no autre réponse ne is needed mais je me suis contenté de signaler quelque chose à propos de l’opérateur && appelé dependent condition

Dans les expressions utilisant operator &&, une condition – nous l’appellerons dependent condition – peut nécessiter qu’une autre condition soit vraie pour que l’évaluation de la condition dépendante soit significative.

Dans ce cas, la condition dépendante doit être placée après l’opérateur && pour éviter les erreurs.

Considérons l’expression (i != 0) && (10 / i == 2) . La condition dépendante (10 / i == 2) doit appear after l’opérateur && pour empêcher la possibilité de division par zéro.

un autre exemple (myObject != null) && (myObject.getValue() == somevaluse)

et autre chose: && et || sont appelées évaluation de court-circuit car le deuxième argument est exécuté ou évalué only if le first argument ne not suffice pour determine la value de l’ expression

Références: Java ™ Programmer (premiers objects), dixième édition