Originariamente inviato da LeleFT
Sono i cosiddetti operatori bitwise e short-circuit.
Premesso che quelli singoli NON si dovrebbero usare al posto dei doppi, vediamo il perchè.

Gli operatori singoli operano sui bit: sono operatori che servono a fare "calcoli" tra bit, non sono operatori logici. Il risultato può sembrare uguale, ma non lo è, per un semplice motivo.

Gli operatori doppi offrono il short-circuit evaluation, mentre gli altri no. Cosa comporta? Vediamo un esempio:

codice:
boolean test = false;
if (test && fireTheWorld()) {
   // The world is on fire
}
Questo codice effettua per prima cosa una verifica sulla condizione "test". Se questa risulta falsa, il resto dell'espressione non viene valutato, quindi non viene preso in considerazione poichè sarebbe "inutile": FALSE messo in AND con qualunque altra cosa darà sempre FALSE. Il risultato dell'espressione è già noto, non serve verificare altro.

Nell'esempio, quindi, dato che la variabile booleana "test" è false, non viene eseguito il metodo "fireTheWorld()", non si entra nel corpo dell'isruzione if e si passa oltre.

Questo esempio:
codice:
boolean test = false;
if (test & fireTheWorld()) {
   // The world is on fire
}
è decisamente diverso: viene valutata prima la condizione "test" e successivamente, qualunque sia il risultato della valutazione, viene valutato anche fireTheWorld(). Con la conseguenza che, sebbene il risultato dell'espressione totale sia comunque FALSE, il metodo "fireTheWorld()" viene comunque invocato... ed il mondo va a fuoco nonostante le nostre buone intenzioni. Non si entra, comunque, nel corpo dell'if, ma il metodo viene invocato.

Un esempio più numerico:
codice:
int a = 9;
int b = 0;
if ((b != 0) && (a / b > 1)) {   // <<-- corretto!
   // a e b non sono uguali
}

if ((b != 0) & (a / b > 1)) {   // <<-- sbagliato!
   // a e b non sono uguali
}
La prima if è corretta: essendo che b è uguale a 0, la seconda parte (che effettua una divisione) non viene valutata, quindi non viene eseguita.

La seconda if è sbagliata: viene verificato che b è uguale a zero, ma ciò nonostante, la divisione successiva viene eseguita, sollevando un bell'errore di divisione per zero.

La stessa cosa si applica all'operatore ||

Ciao.
Grazie Lele sei stato esaustivo ma ti volevo chiedere ancora una cosa per OR sul suo funzionamento... nel senso che se ho:

codice:
int b = 0;
int c = 1;

if(b == 0 || c == 2){
    istruzione
}
Non dovrebbe verificare lo stesso entrambi i criteri? Mi spiego meglio se da come hai detto te con || dovrebbe verifica la prima condizione è true verifica lo stesso anche la seconda? Ma in questo caso che cosa fa dove ho una condizione a true e l'altra a false?

codice:
int b = 0; 
int c = 1;  

if(b == 1 || c == 2){     
   istruzione 
}
Invece in questo caso che la prima è già a false dovrebbe verificare anche la seconda condizione? Anche perchè a sto punto si trasformerebbe in && non credi?
Poi mi sbaglio....

Grazie in anticipo....