Differenze negli operatori booleani: & vs && e | vs ||

Question

Conosco le regole per && e || ma quali sono & e |? Per favore, spiegameli con un esempio.

Answer 1

Questi sono gli operatori OR bit a bit AND e bit a bit.

int a = 6; // 110 
int b = 4; // 100 

// Bitwise AND  

int c = a & b; 
// 110 
// & 100 
// ----- 
// 100 

// Bitwise OR 

int d = a | b; 
// 110 
// | 100 
// ----- 
// 110 

System.out.println(c); // 4 
System.out.println(d); // 6 

Grazie a Carlos per aver ricordato la sezione appropriata nel linguaggio Java Spec (15.22.1, 15.22.2) per quanto riguarda i diversi comportamenti del gestore in base a suoi ingressi.

In effetti quando entrambi gli ingressi sono booleano, gli operatori sono considerati gli operatori logici booleani e si comportano simile al condizionale-E (&&) e condizionale-Or (||) gli operatori, tranne per il fatto che non che fanno corto circuito così, mentre la seguente è sicura:

if((a != null) && (a.something == 3)){ 
} 

Questo non è:

if((a != null) & (a.something == 3)){ 
} 

Answer 2

Gli operatori & & e || sono in cortocircuito, nel senso che non valuteranno la loro espressione della mano destra se il valore dell'espressione della mano sinistra è sufficiente per determinare il risultato.

Answer 3

& e | sono operatori bit per bit su tipi integrali (per esempio int): http://download.oracle.com/javase/tutorial/java/nutsandbolts/op3.html

&& e || operano su booleane (o corto circuito, come altre risposte hanno già detto).

Answer 4

& e | fornire lo stesso risultato del & & e || operatori. La differenza è che valutano sempre entrambi i lati dell'espressione, dove come & & e || smettere di valutare se la prima condizione è sufficiente per determinare il risultato.

Answer 5

penso che stai parlando del significato logico di entrambi gli operatori, qui si ha una tabella-curriculum:

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 

Answer 6

Forse può essere utile sapere che il bit AND e OR bit a bit operatori sono sempre valutato prima di OR condizionale e OR condizionato utilizzato nella stessa espressione.

if ((1>2) && (2>1) | true) // false! 

Answer 7

Se un'espressione booleana coinvolge il & operatore viene valutata, entrambi gli operandi sono valutati. Quindi l'operatore & viene applicato all'operando.

Quando viene valutata un'espressione che coinvolge l'operatore & &, il primo operando viene valutato. Se il primo operando viene valutato su false, la valutazione del secondo operando viene saltata.

Se il primo operando restituisce un valore di vero, viene valutato il secondo operando.Se il secondo operando restituisce un valore true, l'operatore & & viene quindi applicato al primo e al secondo operando.

Simile per | e ||.

Answer 8

Mentre la differenza fondamentale è che & viene utilizzato per operazioni bit per bit soprattutto su long, int o byte dove può essere usato per tipo di maschera, i risultati possono differire anche se si utilizza invece di logico &&.

La differenza è più evidente in alcuni scenari:

1. Valutare alcune delle espressioni è molto tempo
2. Valutare una delle espressioni può essere fatto solo se il precedente era vero
3. Le espressioni avere qualche effetto collaterale (intenzionale o no)

Il primo punto è piuttosto semplice, non causa alcun errore, ma richiede più tempo. Se si dispone di diversi controlli in una dichiarazione condizionale, mettere quelli che sono meno costosi o più probabilità di fallire a sinistra.

Per il secondo punto, vedere questo esempio:

if ((a != null) & (a.isEmpty())) 

Questo fallisce per null, la valutazione della seconda espressione produce un NullPointerException. L'operatore logico && è pigro, se l'operando sinistro è falso, il risultato è falso indipendentemente dal corretto operando.

Esempio per il terzo punto - diciamo che abbiamo un'app che utilizza DB senza trigger o cascate. Prima di rimuovere un oggetto Building, è necessario modificare l'edificio di un oggetto Department in un altro. Diciamo anche che lo stato dell'operazione viene restituito come booleano (vero = successo). Poi:

if (departmentDao.update(department, newBuilding) & buildingDao.remove(building)) 

Questa valuta entrambe le espressioni ed esegue quindi la costruzione di rimozione, anche se l'aggiornamento reparto non riuscito per qualche motivo. Con &&, funziona come previsto e si interrompe dopo il primo errore.

Per quanto riguarda a || b, è equivalente a !(!a && !b), si arresta se a è vero, non è più necessaria alcuna spiegazione.

Answer 9

In Java, i singoli operatori &, |, ^,! dipende dagli operandi. Se entrambi gli operandi sono ints, viene eseguita un'operazione bit a bit. Se entrambi sono booleani, viene eseguita un'operazione "logica".

Se entrambi gli operandi non corrispondono, viene generato un errore di compilazione.

I doppi operatori & &, || comportano in modo simile alle loro controparti singole, ma entrambi gli operandi devono essere espressioni condizionali, ad esempio:

if ((un < 0) & & (b < 0)) {...} o simile, if ((un < 0) || (b < 0)) {...}

fonte: java programmazione lang 4a ed

Answer 10

& &; || sono operatori logici .... cortocircuito

&; | sono operatori logici booleani .... Non cortocircuito

Spostamento alle differenze nell'esecuzione sulle espressioni. Gli operatori bit a bit valutano entrambi i lati indipendentemente dal risultato del lato sinistro. Ma nel caso di valutazione di espressioni con operatori logici, la valutazione dell'espressione della mano destra dipende dalla condizione della mano sinistra.

Per esempio:

int i = 25; 
int j = 25; 
if(i++ < 0 && j++ > 0) 
    System.out.println("OK"); 
System.out.printf("i = %d ; j = %d",i,j); 

Questo stamperà i = 26; j = 25, come la prima condizione è falsa la condizione di destra è bypassato il risultato è falso comunque prescindere dalla condizione destra (cortocircuito)

int i = 25; 
int j = 25; 
if(i++ < 0 & j++ > 0) 
    System.out.println("OK"); 
System.out.printf("i = %d ; j = %d",i,j); 

Ma, stamperà i = 26.; j = 26,

Answer 11

So che ci sono molte risposte qui, ma sembrano tutte un po 'confuse. Quindi, dopo aver fatto alcune ricerche dalla guida allo studio dell'oracolo di Java, ho individuato tre diversi scenari su quando utilizzare & & o &. I tre scenari sono logico E, bit a bit E e booleano E.

logico AND: AND logico (aka condizionale AND) utilizza l'operatore & &. È un significato cortocircuitato: se l'operando sinistro è falso, l'operando destro non verrà valutato.
Esempio:

int x = 0; 
if (false && (1 == ++x) { 
    System.out.println("Inside of if"); 
} 
System.out.println(x); // "0" 

Nell'esempio sopra il valore stampato alla console di x sarà 0, perché il primo operando nell'istruzione if è falsa, quindi java non ha bisogno di calcolare (1 == ++ x) quindi x non sarà calcolato.

AND bit per bit: bit a bit e utilizza l'operatore &. È usato per preformare un'operazione bit a bit sul valore. E 'molto più facile vedere quello che sta succedendo, cercando in operazioni su numeri binari es:

int a = 5;  //     5 in binary is 0101 
int b = 12; //     12 in binary is 1100 
int c = a & b; // bitwise & preformed on a and b is 0100 which is 4 

Come si può vedere nell'esempio, quando le rappresentazioni binarie dei numeri 5 e 12 sono allineati, poi un AND bit a bit preformato servirà solo a produrre un numero binario in cui la stessa cifra in entrambi i numeri hanno un 1. Quindi 0101 & 1100 == 0100. che in decimale è 5 & 12 == 4.

booleano: Ora il booleano L'operatore AND si comporta in modo simile e diverso sia verso AND bit a bit che verso AND logico.Mi piace pensare a come preformare un AND bit a bit tra due valori booleani (o bit), quindi utilizza l'operatore &. I valori booleani possono anche essere il risultato di un'espressione logica.

Restituisce un valore vero o falso, molto simile a AND logico, ma a differenza del logico AND non è cortocircuitato. Il motivo è che per preformare questo bit AND, deve conoscere il valore di entrambi gli operandi sinistro e destro. Ecco un esempio:

int x = 0; 
if (false & (1 == ++x) { 
    System.out.println("Inside of if"); 
} 
System.out.println(x); //"1" 

Ora, quando che se dichiarazione è corse, l'espressione (1 == ++ x) verrà eseguito, anche se l'operando a sinistra è falso. Quindi il valore stampato per x sarà 1 perché è stato incrementato.

Questo vale anche per OR logico (||), OR bit a bit (|), e booleano O (|) Spero che questo chiarisca una certa confusione.