Differenza tra & e &&

Ho sempre pensato che l’operatore && in Java sia usato per verificare se entrambi i suoi operandi booleani sono true , e l’operatore & è usato per fare operazioni bit-bit su due tipi interi.

Recentemente ho scoperto che l’operatore & può anche essere usato per verificare se entrambi i suoi operandi booleani sono true , l’unica differenza è che controlla l’operando RHS anche se l’operando LHS è falso.

L’operatore & in Java è sovraccarico internamente? O c’è qualche altro concetto dietro questo?

& <- verifica entrambi gli operandi
&& <- smette di valutare se il primo operando viene valutato come falso poiché il risultato sarà falso

(x != 0) & (1/x > 1) <- questo significa valutare (x != 0) quindi valutare (1/x > 1) quindi fare il segno &. il problema è che per x = 0 questo genererà un’eccezione.

(x != 0) && (1/x > 1) <- questo significa valutare (x != 0) e solo se questo è vero quindi valutare (1/x > 1) quindi se hai x = 0 allora questo è perfettamente sicuro e non genererà alcuna eccezione se (x! = 0) restituisce il valore falso di tutto ciò che è valutato direttamente a false senza valutare (1/x > 1) .

MODIFICARE:

exprA | exprB exprA | exprB <- questo significa valutare exprA quindi valutare exprB quindi fare il | .

exprA || exprB exprA || exprB <- questo significa valutare exprA e solo se questo è false valutare exprB e fare il || .

Oltre a non essere un valutatore pigro valutando entrambi gli operandi, penso che le principali caratteristiche degli operatori bit a bit confrontino ogni byte di operandi come nell’esempio seguente:

 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 

Dipende dal tipo di argomenti …

Per argomenti interi, la singola e commerciale (“&”) è l’operatore “bit-saggio AND”. La doppia e commerciale (“&&”) non è definita per nient’altro che due argomenti booleani.

Per gli argomenti booleani, la singola e commerciale costituisce l’operatore “logico AND” (incondizionato) mentre la doppia e commerciale (“&&”) è l’operatore “AND logico condizionale”. Vale a dire che la singola e commerciale valuta sempre entrambi gli argomenti, mentre la doppia e commerciale valuterà solo il secondo argomento se il primo argomento è vero.

Per tutti gli altri tipi di argomenti e combinazioni, dovrebbe verificarsi un errore in fase di compilazione.

&& è un operatore di cortocircuito mentre & è un operatore AND.

Prova questo.

  String s = null; boolean b = false & s.isEmpty(); // NullPointerException boolean sb = false && s.isEmpty(); // sb is false 

Penso che la mia risposta possa essere più comprensibile:

Ci sono due differenze tra & e && .

Se usano come AND logico

& e && possono essere logici AND , quando l’espressione & o && sinistra e destra risultano tutti veri, l’intero risultato dell’operazione può essere vero.

quando & e && come AND logico, c’è una differenza:

quando si usa && come AND logico, se il risultato dell’espressione sinistra è falso, l’espressione corretta non verrà eseguita.

Prendi l’esempio:

 String str = null; if(str!=null && !str.equals("")){ // the right expression will not execute } 

Se si utilizza & :

 String str = null; if(str!=null & !str.equals("")){ // the right expression will execute, and throw the NullPointerException } 

Un altro esempio:

 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 } 

e può essere utilizzato come operatore bit

& può essere usato come operatore Bitwise AND , && non può.

L’operatore AND bit “&” produce 1 se e solo se entrambi i bit nei suoi operandi sono 1. Tuttavia, se entrambi i bit sono 0 o entrambi i bit sono diversi, questo operatore produce 0. Per essere più preciso bit a bit AND L’operatore “&” restituisce 1 se uno dei due bit è 1 e restituisce 0 se uno qualsiasi dei bit è 0.

Dalla pagina wiki:

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

è come specificato in JLS (15.22.2) :

Quando entrambi gli operandi di un &, ^, o | l’operatore è di tipo booleano o booleano, quindi il tipo di espressione dell’operatore bit a bit è booleano. In tutti i casi, gli operandi sono soggetti alla conversione di unboxing (§5.1.8) secondo necessità.

Per &, il valore del risultato è vero se entrambi i valori dell’operando sono veri; altrimenti, il risultato è falso.

Per ^, il valore del risultato è vero se i valori dell’operando sono diversi; altrimenti, il risultato è falso.

Per |, il valore del risultato è falso se entrambi i valori dell’operando sono falsi; altrimenti, il risultato è vero.

Il “trucco” è che è un Operatore bit per bit a interi così come un operatore logico booleano . Quindi, perché no, vedere questo come esempio di sovraccarico dell’operatore è ragionevole.

‘&&’: – è un operatore logico AND produce un valore booleano di vero o falso basato sulla relazione logica dei suoi argomenti.

Ad esempio: – Condizione 1 e Condizione2

Se Condizione1 è false, quindi (Condizione1 e Condizione2) saranno sempre false, questo è il motivo per cui questo operatore logico è anche noto come Operatore Cortocircuito perché non valuta un’altra condizione. Se Condizione1 è falsa, non è necessario valutare Condtiton2.

Se Condizione1 è vera, viene valutata Condizione2, se è vera, allora il risultato complessivo sarà vero altrimenti sarà falso.

‘&’: – è un Operatore Bitwise AND. Produce uno (1) nell’output se entrambi i bit di input sono uno. Altrimenti produce zero (0).

Per esempio:-

int a = 12; // la rappresentazione binaria di 12 è 1100

int b = 6; // la rappresentazione binaria di 6 è 0110

int c = (a & b); // La rappresentazione binaria di (12 e 6) è 0100

Il valore di c è 4.

per riferimento, consultare questo http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html

&& e || sono chiamati operatori di cortocircuito. Quando vengono utilizzati, per || – se il primo operando viene valutato su true , il resto degli operandi non viene valutato. Per && – se il primo operando viene valutato come false , il resto non viene valutato.

quindi if (a || (++x > 0)) in questo esempio la variabile x non verrà incrementata se a era true .

Con i booleani, non c’è differenza di output tra i due. Puoi scambiare && e & o || e | e non cambierà mai il risultato della tua espressione.

La differenza sta dietro la scena in cui le informazioni vengono elaborate. Quando hai ragione un’espressione “(a! = 0) & (b! = 0)” per a = 0 eb = 1, accade quanto segue:

 left side: a != 0 --> false right side: b 1= 0 --> true left side and right side are both true? --> false expression returns false 

Quando scrivi un’espressione (a != 0) && ( b != 0) quando a = 0 eb = 1, accade quanto segue:

 a != 0 -->false expression returns false 

Meno passaggi, meno elaborazione, migliore codifica, specialmente quando si eseguono molte espressioni booleane o argomenti complicati.

Oltre a && e || essendo in cortocircuito, considera anche la precedenza degli operatori quando si mischiano le due forms. Penso che non sarà immediatamente evidente a tutti che result1 e result2 contengano valori diversi.

 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 

& È un operatore bit a bit più utilizzato per controllare entrambe le condizioni, perché a volte è necessario valutare entrambe le condizioni. Ma && l’operatore logico passa alla 2a condizione quando la prima condizione diventa vera.

tutte le risposte sono great , e sembra che no più is needed una risposta, ma ho solo voluto indicare qualcosa && chiamato dependent condition

Nelle espressioni che utilizzano l’operatore &&, una condizione – chiameremo questa dependent condition – può richiedere che un’altra condizione sia vera affinché la valutazione della condizione dipendente sia significativa.

In questo caso, la condizione dipendente deve essere posizionata dopo l’operatore && per evitare errori.

Considera l’espressione (i != 0) && (10 / i == 2) . La condizione dipendente (10 / i == 2) deve appear after l’operatore && per impedire la possibilità di divisione per zero.

un altro esempio (myObject != null) && (myObject.getValue() == somevaluse)

e un’altra cosa: && e || sono chiamati valutazione di cortocircuito perché il secondo argomento è eseguito o valutato only if il first argomento non not suffice per determine il value expression

Riferimenti: Java ™ How To Program (Early Objects), Decima edizione