Quelle est la différence entre & et && en Java?

J'ai toujours pensé que l' &&opérateur en Java est utilisé pour vérifier si ses deux opérandes booléens le sont true, et l' &opérateur est utilisé pour effectuer des opérations par 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 étant qu'il vérifie l'opérande RHS même si l'opérande LHS est faux.

L' &opérateur 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é à faux 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, cela lèvera 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 aucune exception si (x! = 0) évalue à faux le tout évalue directement à faux sans évaluer le (1/x > 1).

ÉDITER:

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

exprA || exprB<- cela signifie évaluer exprAet seulement si c'est falsealors évaluer exprBet faire 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 au niveau du bit 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 d'arguments ...

Pour les arguments entiers, l'esperluette unique ("&") est l'opérateur "ET au niveau du bit". La double esperluette ("&&") n'est définie que pour deux arguments booléens.

Pour les arguments booléens, l'esperluette simple constitue l'opérateur "ET logique" (inconditionnel) tandis que la double esperluette ("&&") est l'opérateur "ET logique conditionnel". C'est-à-dire que l'esperluette simple évalue toujours les deux arguments alors que l'esperluette double n'évalue le deuxième argument que si le premier argument est vrai.

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

&& est un opérateur de court-circuit tandis 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

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

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

Pour &, la valeur de résultat est vraie si les deux valeurs d'opérande sont vraies; sinon, le résultat est faux.

Pour ^, la valeur de résultat est true si les valeurs d'opérande sont différentes; sinon, le résultat est faux.

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

Le "truc" est qu'il &s'agit d'un opérateur binaire entier ainsi que d'un opérateur logique booléen . Alors pourquoi pas, voir cela comme un exemple de surcharge d'opérateurs est raisonnable.

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

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

S'ils utilisent comme ET logique

&et &&peut être logique AND, lorsque le résultat de l'expression &ou de &&gauche et de droite tout est vrai, l'ensemble du résultat de l'opération peut être vrai.

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

lors de l'utilisation &&comme logique AND, si le résultat de l'expression de gauche est faux, 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 supplémentaire:

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 bits

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

L'opérateur binaire 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 il renvoie 0 si l'un des bits est égal à 0. 

Depuis la page wiki:

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

'&&': - est un opérateur ET logique produisant une valeur booléenne vraie ou fausse basée sur la relation logique de ses arguments.

Par exemple: - Condition1 && Condition2

Si Condition1 est fausse, alors (Condition1 && Condition2) sera toujours fausse, c'est la 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 il sera faux.

'&': - est un opérateur AND au niveau du bit. 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, reportez-vous à http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html

&&et ||sont appelés opérateurs de court-circuit. Lorsqu'ils sont utilisés, pour ||- si le premier opérande est évalué à true, alors le reste des opérandes n'est pas évalué. For &&- si le premier opérande est évalué à false, les autres ne sont pas évalués du tout.

donc if (a || (++x > 0))dans cet exemple, la variable x ne sera pas incrémentée si a l'é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 se situe derrière la scène où les informations sont traitées. 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, ce qui suit se produit:

a != 0 -->false
expression returns false

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

Outre && et || étant un court-circuit, considérez également la priorité des opérateurs 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 au niveau du bit utilisé pour vérifier les deux conditions car nous devons parfois évaluer les deux conditions. Mais l'opérateur logique && passe à la deuxième condition lorsque la première condition donne vrai.

toutes les réponses sont great, et il semble que noplus de réponse, is needed mais je voulais juste souligner 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 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érez l'expression (i != 0) && (10 / i == 2). La condition dépendante (10 / i == 2)doit appear afterl' &&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és évaluation de court-circuit parce que le deuxième argument est exécuté ou évalué que only ifl' firstargument fait not sufficeà determinela valuede laexpression

Références: Java ™ How To Program (premiers objets), dixième édition