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éennes sont true
, et l'opérateur &
est utilisé pour effectuer des opérations Bit-wise sur deux types entiers.
récemment, j'ai appris que l'opérateur &
peut également être utilisé vérifier si les deux opérandes booléennes sont true
, la seule différence est qu'il vérifie l'opérande RHS même si l'opérande LHS est fausse.
est-ce que L'opérateur &
de Java est surchargé en interne? Ou est-il un autre concept derrière cela?
13 réponses
& lt; - vérifie les deux opérandes
&& < -- cesse d'évaluer si le premier opérande évalue à false puisque le résultat sera false
(x != 0) & (1/x > 1)
<-- cela signifie évaluer (x != 0)
évaluer (1/x > 1)
, puis faire le &. le problème est que pour x=0 cela va jeter une exception.
(x != 0) && (1/x > 1)
< -- cela signifie évaluer (x != 0)
et seulement si c'est vrai, alors évaluer (1/x > 1)
donc si vous avez x=0, alors c'est parfaitement sûr et ne lèvera une exception si (x != 0) évalue à false le tout évalue directement à false sans évaluer le (1/x > 1)
.
EDIT:
exprA | exprB
<-- cela signifie évaluer exprA
évaluer exprB
puis faire |
.
exprA || exprB
<-- cela signifie évaluer exprA
et seulement si c'est false
évaluer exprB
et ne 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 bitwise comparent chaque Byte 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 d'arguments...
pour les arguments entiers, le simple ampli ("&") est l'opérateur" bit-wise AND". Le double ampersand ( "& & " ) n'est défini que pour deux arguments booléens.
pour les arguments booléens, l'ampère simple constitue l'opérateur (inconditionnel) "logique et" tandis que l'ampère double ("&&") est l'opérateur "conditionnel logique et". C'est-à-dire que le seul esperluette toujours évalue les deux arguments alors que le double ampersand n'évaluera le second argument que si le premier argument est vrai.
pour tous les autres types d'arguments et combinaisons, une erreur de compilation devrait se produire.
&& est un court-circuit de l'opérateur alors que & est un opérateur ET.
essayez ceci.
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 y a deux différences entre &
et &&
.
S'ils utilisent comme logique et
&
et &&
peuvent être logique AND
, lorsque le &
ou &&
à gauche et à droite résultat de l'expression tout est vrai, tout le résultat de l'opération peut être vrai.
quand &
et &&
comme logique AND
, il y a une différence:
si vous utilisez &&
comme AND
, si le résultat de l'expression de gauche est faux, l'expression de droite ne s'exécutera pas.
prendre 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:
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 bitwise et " & " produit 1 si et seulement si les deux bits dans ses opérandes sont 1. Cependant, si les deux bits sont à 0 ou les deux bits sont différents alors cet opérateur produit 0. Pour être plus précis, l'opérateur bitwise et " &" renvoie 1 si l'un des deux bits est 1 et il retourne 0 si l'un des bits est de 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 A&,^, ou | operator sont de type booléen ou booléen, alors le type de l'expression de l'opérateur bitwise est booléen. Dans tous les cas, les opérandes sont sujettes à la conversion unboxing (§5.1.8) si nécessaire.
Pour les, la valeur du résultat est vrai si les deux opérandes de l'valeurs true; sinon, le résultat est faux.
pour ^, la valeur de résultat est vraie si les valeurs d'opérande sont différentes; sinon, le résultat est faux.
Pour |, la valeur du résultat est faux si les deux opérandes de l'valeurs sont fausses; sinon, le résultat est vrai.
le "truc" est que &
est un opérateur entier Bitwise aussi bien qu'un opérateur logique booléen . Alors, pourquoi pas, de voir un exemple surcharge de l'opérateur est raisonnable.
‘&&’ : - est dans une Logique d'opérateur de produire une valeur booléenne true ou false en fonction de la relation logique de ses arguments.
par exemple: - Condition1 & & Condition2
si la Condition1 est fausse, alors (Condition1 && Condition2) sera toujours fausse, c'est la raison pour laquelle cet opérateur logique est également connu comme opérateur de court-Circuit parce qu'il n'évalue pas une autre condition. Si la Condition1 est fausse , alors il n'est pas nécessaire de évaluer la Constitution2.
Si la Condition1 est vraie, alors la Condition2 est évaluée, si c'est vrai, alors le résultat global sera vrai sinon, il sera faux.
‘&’ : - soit au niveau du Bit ET de l'Opérateur. Il produit 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 de 1100
int b=6; / / binaire la représentation de 6 0110
int c=(a & b); // représentation binaire de (12 & 6) est 0100
la valeur de c est 4.
pour référence , référez-vous à ce http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html
&&
et ||
sont appelés court-circuit opérateurs. Quand ils sont utilisés, pour ||
- si le premier opérande évalue à true
, alors le reste des opérandes ne sont pas évalués. Pour &&
- si le premier opérande évalue à 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
.
avec les booléens, il n'y a pas de différence de production entre les deux. Vous pouvez permuter && et & ou || et | et il ne changera jamais le résultat de votre expression.
La différence se situe derrière la scène où l'information est traitée. Quand vous redressez une expression "(a != 0) & (b != 0)" pour a = 0 et b = 1, les cas suivants se produisent:
left side: a != 0 --> false
right side: b 1= 0 --> true
left side and right side are both true? --> false
expression returns false
quand vous écrivez une expression (a != 0) && ( b != 0)
quand a = 0 et b = 1, ce qui suit arrive:
a != 0 -->false
expression returns false
moins de pas, moins de traitement, un meilleur codage, surtout quand on fait beaucoup d'expressions booléennes ou des arguments compliqués.
en plus de & et | | / court-circuiter, tenir compte aussi 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 le résultat 1 et le résultat 2 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 bitwise plus utilisé pour vérifier les deux conditions parce que parfois nous avons besoin d'évaluer les deux conditions. Mais & & opérateur logique passer à la 2ème condition quand la première condition donne vrai.
toutes les réponses sont great
, et il semble que no
plus de réponse is needed
mais je viens de faire remarquer quelque chose à propos de l'opérateur &&
appelé dependent condition
dans les expressions utilisant l'opérateur &&, une condition-nous l'appellerons le dependent condition
- peut exiger une autre condition pour être vraie pour l'évaluation de la condition dépendante pour être significative.
dans ce cas, la condition dépendante doit être placée après l'opérateur && pour prévenir les erreurs.
considérez 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 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
ne not suffice
à determine
le value
du expression
, Les Références: Java™ Comment Le Programme (Début Objets), La Dixième Édition De