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 au niveau du bit sur deux types d'entiers.
Récemment, j'ai appris que l'opérateur & peut également ê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?
& <- vérifie les deux opérandes
&& <- arrête d’évaluer si le premier opérande est évalué à false car le résultat sera false
(x != 0) & (1/x > 1) <- cela signifie évaluer (x != 0), puis évaluer (1/x > 1), puis exécutez la commande &. le problème est que pour x = 0 cela va générer une exception.
(x != 0) && (1/x > 1) <- cela signifie d'évaluer (x != 0) et que si cela est vrai, alors évaluer (1/x > 1), donc si vous avez x = 0, cela est parfaitement sûr et ne lève aucune exception si (x! = 0) évalue directement le tout faux est évalué à false sans évaluer le (1/x > 1).
MODIFIER:
exprA | exprB <- cela signifie évaluer exprA puis évaluer exprB puis faire le |.
exprA || exprB <- cela signifie d'évaluer exprA et que s'il s'agit de false, évaluez exprB et exécutez le ||.
En plus de ne pas être un évaluateur paresseux en évaluant les deux opérandes, je pense que les caractéristiques principales des opérateurs au niveau des bits 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'esperluette unique ("&") est l'opérateur "ET AND". Le double et commercial ("&&") n'est défini que pour deux arguments booléens.
Pour les arguments booléens, la simple esperluette constitue l'opérateur "inconditionnel" et "logique" tandis que la double esperluette ("&&") est l'opérateur "conditionnel logique ET". C'est-à-dire que l'esperluette simple évalue toujours les deux arguments alors que l'esperluette double n'évaluera le deuxième argument que si le premier argument est vrai.
Pour tous les autres types d'arguments et combinaisons, une erreur de compilation devrait survenir.
&& est un opérateur de court-circuit alors que & est un opérateur AND.
Essaye ça.
String 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 AND
& et && peuvent être logiques AND, lorsque le résultat de l'expression & ou && gauche et droite est que tout est vrai, le résultat total de l'opération peut être vrai.
lorsque & et && sous forme de AND logique, il existe une différence:
lorsque vous utilisez && en tant que valeur logique AND, si le résultat de l'expression de gauche est false, l'expression de droite ne s'exécutera pas.
Prenons l'exemple:
String str = null;
if(str!=null && !str.equals("")){ // the right expression will not execute
}
Si vous utilisez &:
String str = null;
if(str!=null & !str.equals("")){ // the right expression will execute, and throw the NullPointerException
}
Un autre exemple plus:
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é en tant qu'opérateur binaire AND, && ne peut pas.
L'opérateur AND "&" au niveau du bit 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 génère 0. Pour être plus précis, l'opérateur AND "&" renvoie 1 si l'un des bits est 1 et renvoie 0 si l'un des bits est 0.
De la page wiki:
http://www.roseindia.net/Java/master-Java/java-bitwise-and.shtml
c'est comme spécifié dans JLS (15.22.2) :
Lorsque les deux opérandes de &, ^, ou | opérateur sont de type booléen ou booléen, le type de l'expression d'opérateur au niveau du bit est booléen. Dans tous les cas, les opérandes sont soumis à la conversion de décoffrage (§5.1.8) selon les besoins.
Pour &, la valeur du résultat est vraie si les deux valeurs d'opérande sont vraies; sinon, le résultat est faux.
Pour ^, la valeur du résultat est vraie 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 false; sinon, le résultat est vrai.
Le "truc" est que & est un opérateur bitwise 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 logique ET qui produit une valeur booléenne vraie ou fausse basée sur la relation logique de ses arguments.
Par exemple: - Condition1 && Condition2
Si Condition1 est faux, alors (Condition1 && Condition2) sera toujours faux, c'est pourquoi 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, la Condition2 est évaluée, si elle est vraie, le résultat global sera vrai, sinon ce sera faux.
'&': - est un opérateur AND au niveau des bits. Il produit un un (1) dans la sortie si les deux bits d’entrée sont un. Sinon, il produit zéro (0).
Par exemple:-
int a = 12; // la représentation binaire de 12 est 1100
int b = 6; // la représentation binaire de 6 est 0110
int c = (a & b); // la représentation binaire de (12 & 6) est 0100
La valeur de c est 4.
pour référence, référez-vous http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html
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 se situe derrière la scène où l'information est en cours de traitement. Lorsque vous rectifiez une expression "(a! = 0) & (b! = 0)" pour a = 0 et b = 1, voici ce qui se passe:
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) quand a = 0 et b = 1, voici ce qui se passe:
a != 0 -->false
expression returns false
Moins d'étapes, moins de traitement, un meilleur codage, en particulier lorsque vous utilisez de nombreuses expressions booléennes ou des arguments compliqués.
&& et || sont appelés opérateurs de court-circuit. Quand ils sont utilisés, pour || - si le premier opérande est évalué à true, les autres opérandes ne sont pas évalués. Pour && - si le premier opérande a pour valeur false, les autres ne sont pas évalués du tout.
so if (a || (++x > 0)) dans cet exemple, la variable x ne sera pas incrémentée si a était true.
Outre && et || étant en court-circuit, tenez également compte de 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 binaire plus utilisé pour vérifier les deux conditions car il est parfois nécessaire d'é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 que no plus answer is needed mais je voulais juste signaler quelque chose à propos de l'opérateur && appelé dependent condition
Dans les expressions utilisant l'opérateur &&, 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 ait un sens.
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 éviter la possibilité d'une division par zéro.
un autre exemple (myObject != null) && (myObject.getValue() == somevaluse)
et une autre chose: && et || sont appelés évaluation de court-circuit parce que le deuxième argument est exécuté ou évalué only if l'argument first fait not suffice à determine le value_ du expression
Références: Programmation Java ™ (premiers objets), Dixième édition