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