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

Question

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

Est-ce que le & en Java est surchargé en interne ? Ou y a-t-il un autre concept derrière cela ?

Answer 1

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

Il y a deux différences entre & et && .

S'ils utilisent un ET logique

& et && peut être logique AND lorsque le & o && le résultat de l'expression de gauche et de droite est vrai, le résultat de toute 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 sera pas exécutée.

Prenons l'exemple de :

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 encore :

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 Bitwise AND opérateur, && ne peut pas.

L'opérateur ET " & " au sens du bit produit 1 si et seulement si les deux bits de son ses opérandes sont égaux à 1. Pour être plus précis, l'opérateur ET " & " au sens des bits renvoie 1 si l'un des deux bits est 1 et 0 si l'un des bits est 0. 

De la page wiki :

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

Answer 2

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

Lorsque les deux opérandes d'un opérateur &, ^ ou | sont de type booléen ou booléen, le type de l'expression de l'opérateur binaire 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 vraie si les deux valeurs des opérandes sont vraies ; sinon, le résultat est faux.

Pour ^, la valeur du résultat est vraie si les valeurs des opérandes sont différentes ; sinon, le résultat est faux.

Pour |, la valeur du résultat est fausse si les deux valeurs des opérandes sont fausses ; sinon, le résultat est vrai.

Le "truc" est que & es un Opérateur binaire pour les nombres entiers ainsi qu'un Opérateur logique booléen . Alors pourquoi ne pas, en voyant cela comme un exemple de surcharge des opérateurs est raisonnable.

Answer 3

'&&' : - est un opérateur logique ET qui produit une valeur booléenne de vrai ou faux sur la base 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 sous le nom d'opérateur de court-circuit car il n'évalue pas une autre condition. Si la condition 1 est fausse, il n'est pas nécessaire d'évaluer la condition 2.

Si la condition 1 est vraie, la condition 2 est évaluée, si elle est vraie, le résultat global sera vrai, sinon il sera faux.

'&' : - est un opérateur ET par bit. Il produit un (1) dans la sortie si les deux bits d'entrée sont un. Sinon, il produit un 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, se référer à ce http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html

Answer 4

Avec les booléens, il n'y a pas de différence de sortie entre les deux. Vous pouvez intervertir && 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 traitée. Lorsque l'on redresse une expression "(a != 0) & ( b != 0)" pour a= 0 et b = 1, il se passe ce qui suit :

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, il se produit ce qui suit :

a != 0 -->false
expression returns false

Moins d'étapes, moins de traitement, un meilleur codage, surtout lorsqu'il s'agit d'expressions booléennes ou d'arguments compliqués.

Answer 5

&& 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é. Pour && - 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 a été true .