Gli operatori logici AND, OR, XOR, NOT – Con esempi in java

Quando si inizia a studiare logica o programmazione, una delle prime cose di cui si sente parlare sono gli operatori logici. Ma cosa sono gli operatori logici e a cosa servono?

Nella vita normale ci capita quasi continuamente di utilizzare gli operatori logici per effettuare scelte, ragionamenti, o per chiedere a qualcuno di scegliere qualcosa. Frasi del tipo “questo vestito è blu o nero” oppure “Se al mercato ci sono mele e pere, comprale”, non sono altro che applicazioni in lingua corrente degli operatori logici.

Indice

• Cosa sono gli operatori logici?
• Quali sono i principali operatori logici java che prenderemo in esame?
• L’operatore AND in java
  • Esempi
• L’operatore OR in java
  • Esempi
• L’operatore XOR in java
  • Esempi
• L’operatore AND bitwise in java
  • Esempi
• L’operatore NOT in java
  • Esempi
• Conclusioni

Cosa sono gli operatori logici?

Per capire cosa sono gli operatori logici partiamo dall’analisi della definizione che possiamo trovare su wikipedia e cerchiamo di spiegarla con parole semplici:

Un connettivo logico o operatore logico (nel contesto dell’algebra di Boole, i connettivi logici sono detti anche operatori booleani), è un elemento grammaticale di collegamento che instaura fra due proposizioni A e B una qualche relazione che dia origine ad una terza proposizione C con un valore vero o falso, in base ai valori delle due proposizioni fattori ed al carattere del connettivo utilizzato.

Connettivo logico – Wikipedia

Cosa ci dice questa definizione? Come prima cosa ci dice che un operatore logico è un elemento di collegamento fra due proposizioni. Avremo quindi due “frasi” nella lingua parlata o due espressioni nel caso del linguaggio java. Queste due proposizioni danno origine ad una nuova proposizione composta dalle due proposizioni originali più l’operatore logico. Questa nuova proposizione avrà un valore vero o falso strettamente dipendente dal valore delle due espressioni e del tipo di operatore logico che abbiamo posto fra loro.

Possiamo quindi dedurre che, usando le stesse due espressioni ma frapponendo diversi operatori logici avremo risultati diversi.

Quali sono i principali operatori logici java che prenderemo in esame?

In questa pagina ci occuperemo di chiarire il funzionamento di alcuni dei principali operatori logici prendendo come esempio il loro utilizzo nel linguaggio di programmazione java. La discussione degli esempi sarà focalizzata sul linguaggio, ma la descrizione teorica dell’operatore può essere applicata a diversi linguaggi di programmazione ed estesa al campo della logica in generale.

Gli operatori che prenderemo in esame saranno AND, OR, XOR, AND bitwise, OR bitwise. A questi aggiungeremo l’operatore NOT che però, a differenza degli altri, si applica ad una sola espressione.

L’operatore AND in java

La parola AND in inglese è il corrispettivo della congiunzione “e” italiana. L’operatore AND è quindi l’equivalente di mettere una e fra le due espressioni.
A AND B sarà quindi vera solamente se A e B sono entrambe vere. Basterà quindi che almeno una fra A e B sia falsa a far diventare falsa l’espressione A AND B.

Espressione	Risultato
vero AND vero	vero
vero AND falso	falso
falso AND vero	falso
falso AND falso	falso

Esempi

In java l’operatore AND utilizza la sintassi && posta fra le due espressioni. Vediamo un esempio:

boolean a = true;
boolean b = true;
boolean result = a && b;
System.out.println(result);

In questo caso il programma stamperà true in quanto entrambe le variabili a e b sono true.
Il caso più comune dell’operatore && è quello di essere utilizzato per definire l’espressione di un costrutto if else.

boolean a = true;
boolean b = true;
if(a && b) {
  System.out.println("Risultato vero");
} else {
  System.out.println("Risultato falso");
}

L’operatore OR in java

Se l’operatore And era equivalente alla congiunzione e, l’operatore OR si può assimilare alla congiunzione “o”.

L’espressione A OR B sarà quindi vera quando è vera A o B. In questo caso si tratta di un “o” non esclusivo, ovvero basterà che almeno una fra A e B sia vera, quindi anche il caso di entrambe le espressioni vere darà risultato vero.

Espressione	Risultato
vero OR vero	vero
vero OR falso	vero
falso OR vero	vero
falso OR falso	falso

Dalla tabella possiamo dedurre quindi che in sostanza il risultato dell’operatore OR è falso quando entrambe le espressioni sono false, ed è vero in tutti gli altri casi.

Esempi

In java l’operatore OR utilizza la sintassi || posta fra le due espressioni. Vediamo un esempio:

boolean a = false;
boolean b = true;
boolean result = a || b;
System.out.println(result);

In questo caso il risultato sarà true, in quanto almeno uno dei due fra a e b (b) è true.

Anche in questo caso l’operatore || è molto utilizzato nei costrutti if else proprio come per l’operatore AND.

boolean a = false;
boolean b = true;
if(a || b) {
  System.out.println("Risultato vero");
} else {
  System.out.println("Risultato falso");
}

L’operatore XOR in java

L’operatore XOR in programmazione è solitamente meno utilizzato dei due precedenti, ma non per questo si tratta di un operatore meno importante o meno “potente”.

Si tratta in questo caso di un OR esclusivo. Abbiamo detto parlando dell’operatore OR che quest’ultimo era non esclusivo, ovvero che OR fra due espressioni vere da un risultato vero. Lo XOR, al contrario, è esclusivo, ovvero per avere un risultato vero solo e soltanto una delle espressioni deve essere vera. In pratica lo XOR è vero se le espressioni sono diverse (una vera e una falsa). Proviamo a riassumere i casi con la solita tabella:

Espressione	Risultato
vero XOR vero	falso
vero XOR falso	vero
falso XOR vero	vero
falso XOR falso	falso

Osservando la tabella è decisamente più chiaro come espressioni “uguali” diano falso mentre espressioni diverse danno vero.

Esempi

In java l’operatore XOR utilizza il simbolo ^ fra le due espressioni. vediamo un primo esempio semplice.

boolean a = false;
boolean b = true;
boolean result = a ^ b;
System.out.println(result);

In questo esempio il programma stamperà true, in quanto solo una delle due espressioni (b) è vera mentre l’altra è falsa.

Anche in questo caso l’operatore ^ può essere utilizzato nei costrutti if else proprio come i precedenti.

boolean a = false;
boolean b = true;
if(a ^ b) {
  System.out.println("Risultato vero");
} else {
  System.out.println("Risultato falso");
}

L’operatore AND bitwise in java

L’operatore AND bitwise è un tipo di operatore AND leggermente diverso da quello preso in analisi precedentemente.

In questo caso il risultato della valutazione dell’espressione è lo stesso della valutazione dell’AND precedente, quindi dal punto di vista logico non ci sono differenze apparenti.

L’operatore AND bitwise in java utilizza il simbolo & (a differenza del doppio && visto precedentemente)

Ma se il risultato di && e & è lo stesso, allora viene da chiedersi: che differenza c’è tra && e & ?
La differenza sta nella valutazione delle espressioni in fase di esecuzione del codice:

L’operatore && interrompe la valutazione delle espressioni non appena ne trova una falsa, mentre l’operatore & valuta tutte le espressioni anche se ne ha già trovata una falsa (che quindi sicuramente darà esito della valutazione negativo).

Se quindi l’espressione A è falsa, scrivendo A && B verrà valutata A, ed essendo questa falsa il programma restituirà come risultato falso senza occuparsi di valutare B che è, a questo punto, ininfluente. Nel caso in cui invece scriveremo A & B verrà valutata l’espressione A, ma nonostante la falsità di quest’ultima, verrebbe valutata anche l’espressione B per poi restituire falso indipendentemente dal risultato della valutazione di B.

Esempio

Ad una prima analisi sembrerebbe ininfluente l’utilizzo di & o &&. Ci sono però diversi motivi per cui potrebbe essere necessario o conveniente utilizzare uno piuttosto che l’altro.

Il primo esempio è un esempio in cui la differenza fra & e && può fare la differenza fra un codice che funziona correttamente ed uno che va in errore. Vediamo le due diverse espressioni:

List<int> lista = null;
if(lista != null && lista.size() > 0) {
  System.out.println("lista contenente elementi");
} else {
  System.out.println("lista nulla o vuota");
}

List<int> lista = null;
if(lista != null & lista.size() > 0) {
  System.out.println("lista contenente elementi");
} else {
  System.out.println("lista nulla o vuota");
}

Nel primo codice, l’espressione lista != null viene valutata con false, in quanto l’oggetto lista non è diverso da null, il programma interrompe la valutazione restituendo immediatamente false (l’espressione lista.size() > 0 viene ignorata). Nel secondo caso, la prima espressione viene valutata false, ma avendo utilizzato l’operatore AND bitwise & il programma procederà con la valutazione dell’espressione lista.size() > 0 che però, essendo l’oggetto lista null, genererà una NullPointerException che manderà in errore il codice. In questo caso quindi l’utilizzo di && permette di salvaguardare l’esecuzione dall’errore che si genererebbe nel valutare la seconda espressione nel caso in cui la prima sia falsa.

Un altro punto importante è che, nel caso in cui avessimo una delle due espressioni che richieda molte risorse per essere valutata, utilizzando l’operatore && possiamo porre l’espressione che richiede meno risorse per prima ed evitare di utilizzare risorse nel caso in cui questa sia falsa.

if(metodoLeggero() && metodoMoltoPesanteELungoDaElaborare()) {
...

In questo caso, metodoLeggero sarà eseguito ogni volta, mentre metodoMoltoPesanteELungoDaElaborare sarà eseguito solamente quando necessario.

Ci si potrebbe quindi chiedere quando e perché. utilizzare l’operatore AND bitwise &?
Uno dei casi in cui potrebbe essere utile utilizzare & al posto di && è il caso in cui, nella seconda espressione, si faccia qualche operazione necessaria per il corretto svolgimento del programma. Potremmo infatti chiamare un determinato metodo che svolge delle operazioni che vogliamo eseguire indipendentemente dalla verità o falsità della prima espressione.

L’operatore NOT in java

Come abbiamo detto all’inizio, l’operatore NOT è un operatore che coinvolge una sola espressione. Il suo scopo è quello di invertire il valore dell’espressione a cui è applicato. NOT vero sarà quindi falso e NOT falso costituirà un’espressione vera.

Espressione	Risultato
NOT vero	falso
NOT falso	vero

Come possiamo vedere, l’effetto dell’operatore NOT è quello di “ribaltare” il valore dell’espressione da vera a falsa e viceversa.

Esempi

L’operatore NOT in java si esprime con il simbolo ! che deve essere posto prima dell’espressione da valutare. Spesso è preferibile, per ragioni di sintassi e di leggibilità del codice, racchiudere l’espressione fra parentesi tonde, in modo da eliminare ogni ambiguità e permettere di identificare a cosa si riferisce l’operatore.

!(5>4)        //false
!(5>4 && 8>7) //false
!(5 == 3)     //true

Conclusioni

Finisce qui la nostra panoramica dei principali operatori logici. Speriamo di aver fatto un po’ di chiarezza su quali sono, a cosa servono e come si utilizzano in java.