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?

125
demandé sur Kevin Panko 2011-04-06 13:46:55

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 || .

219
répondu ITroubs 2011-04-09 10:14:36

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
41
répondu suat 2011-08-26 03:57:58
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
28
répondu Torres 2011-04-06 09:50:09

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.

9
répondu developer 2011-04-06 09:52:38

&& 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
8
répondu Prince John Wesley 2011-04-06 14:38:02

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

7
répondu aircraft 2017-07-05 19:47:55

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.

5
répondu Andreas_D 2013-10-22 13:56:31

‘&&’ : - 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

4
répondu satish 2015-11-17 09:23:13

&& 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 .

3
répondu ACV 2016-04-29 11:49:55

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.

3
répondu Ryan 2016-09-27 11:42:40

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
3
répondu mgr326639 2018-01-29 13:33:33

& 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.

0
répondu Yasir Shabbir Choudhary 2016-11-10 09:42:55

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

0
répondu Basheer AL-MOMANI 2017-03-03 22:09:19