Qual è la differenza tra & e && in Java?

Ho sempre pensato che l' &&operatore in Java sia usato per verificare se entrambi gli operandi booleani lo sono true, e l' &operatore è usato per eseguire operazioni bit per bit su due tipi interi.

Recentemente ho scoperto che l' &operatore può anche essere usato per verificare se entrambi gli 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
&& <- interrompe la valutazione 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 &. 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 valuta (1/x > 1)quindi se hai x = 0, questo è perfettamente sicuro e non genererà alcuna eccezione se (x! = 0) valuta falso l'intero valore viene valutato direttamente su falso senza valutare il (1/x > 1).

MODIFICARE:

exprA | exprB<- questo significa valutare exprAquindi valutare exprBquindi fare il |.

exprA || exprB<- questo significa valutare exprAe solo se questo è falsequindi valutare exprBe fare il ||.

Oltre a non essere un valutatore pigro valutando entrambi gli operandi, penso che le caratteristiche principali 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 argomenti booleani, la singola e commerciale costituisce l'operatore "logico" (incondizionato) mentre la doppia e commerciale ("&&") è l'operatore "logico condizionale". Ciò significa che la singola e commerciale valuta sempre entrambi gli argomenti, mentre la doppia e commerciale valuterà il secondo argomento solo se il primo argomento è vero.

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

&& è un operatore di corto circuito mentre & è un operatore AND.

Prova questo.

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

è come specificato nel JLS (15.22.2) :

Quando entrambi gli operandi di un &, ^ o | gli operatori sono di tipo booleano o booleano, quindi il tipo dell'espressione dell'operatore bit a bit è booleano. In tutti i casi, gli operandi sono soggetti a conversione unboxing (§5.1.8), se necessario.

Per &, il valore del risultato è vero se entrambi i valori dell'operando sono veri; in caso contrario, il risultato è falso.

Per ^, il valore del risultato è vero se i valori dell'operando sono diversi; in caso contrario, 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 intero operatore bit per bit , nonché un operatore logico booleano . Quindi perché no, vedere questo come un esempio di sovraccarico dell'operatore è ragionevole.

Penso che la mia risposta possa essere più comprensibile:

Ci sono due differenze tra &e&& .

Se usano come AND logico

&e &&può essere logico AND, quando il &o&& espressione left e right risultano tutte vere, l'intero risultato dell'operazione può essere vero.

quando &e &&come logicoAND , c'è una differenza:

quando usato &&come logicoAND , se il risultato dell'espressione sinistra è falso, l'espressione destra 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 usato come operatore bit

&può essere usato come ANDoperatore Bitwise , &&no.

L'operatore AND bit a bit "1" 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ù precisi a bit a bit AND L'operatore "&" restituisce 1 se uno dei due bit è 1 e restituisce 0 se uno dei bit è 0. 

Dalla pagina wiki:

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

'&&': - è un operatore logico AND che produce un valore booleano di vero o falso in base alla relazione logica dei suoi argomenti.

Ad esempio: - Condizione1 && Condizione2

Se Condition1 è falso, allora (Condition1 && Condition2) sarà sempre falso, questo è il motivo per cui questo operatore logico è anche noto come Operatore di cortocircuito perché non valuta un'altra condizione. Se Condition1 è falso, non è necessario valutare Condtiton2.

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

'&': - è un operatore Bitwise AND. Produce uno (1) nell'uscita se entrambi i bit di ingresso 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.

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

&&e ||sono chiamati operatori di corto circuito. Quando vengono utilizzati, per ||- se il primo operando viene valutato true, il resto degli operandi non viene valutato. Per &&- se il primo operando valutafalse , gli altri non vengono affatto valutati.

quindi if (a || (++x > 0))in questo esempio la variabile x non verrà incrementata se fosse un 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 si regola un'espressione "(a! = 0) & (b! = 0)" per a = 0 eb = 1, si verifica 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 si scrive un'espressione (a != 0) && ( b != 0)quando a = 0 eb = 1, si verifica quanto segue:

a != 0 -->false
expression returns false

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

Oltre a && e || essendo in corto circuito, considerare anche la precedenza dell'operatore quando si mescolano le due forme. Penso che non sarà immediatamente evidente a tutti che result1 e result2 contengono 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 dobbiamo valutare entrambe le condizioni. Ma l'operatore logico && passa alla seconda condizione quando la prima condizione si manifesta.

tutte le risposte sono great, e sembra che nopiù risposte, is needed ma ho appena voluto sottolineare qualcosa &&sull'operatore chiamatodependent condition

Nelle espressioni che usano l'operatore &&, una condizione — chiameremo questo dependent condition—può richiedere che un'altra condizione sia vera perché 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 di dipendenza (10 / i == 2)deve appear afterl' &&operatore per evitare la possibilità di divisione per zero.

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

e un'altra cosa: && e ||sono chiamati valutazione di corto circuito perché il secondo argomento viene eseguita o valutata only ifl' firstargomento non not sufficeper determinela valuedelexpression

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