Corso di Java

Operatori relazionali e logici I

 

Java offre 6 operatori per le operazioni di confronto, come mostra la tabella seguente:

OPERATORE

SIGNIFICATO

ESEMPIO

==

Uguale a

x == 3

!=

Diverso da

x != 3

<

Minore di

x < 3

>

Maggiore di

x > 3

<=

Minore o uguale a

x <= 3

>=

Maggiore o uguale a

x >= 3


Con tali operatori è possibile effettuare confronti tra variabili, tra variabili e valori letterali o altri tipi di informazione, ottenendo come risultato un valore booleano true o false, a seconda che il confronto abbia dato esito positivo o negativo.
Nel codice di es.

int soldiInTasca = 10000;
int prezzoBigliettoConcerto = 40000;
boolean ciPossoAndare = soldiInTasca >= prezzoBigliettoConcerto;

la variabile ciPossoAndare assume il valore false, perché la variabile soldiInTasca ha un valore minore di prezzoBigliettoConcerto.

Le espressioni che restituiscono valori booleani si possono combinare in espressioni più complesse tramite gli operatori logici, che sono riassunti in tabella:

OPERATORE

SIGNIFICATO

!

NOT logico

&

AND

|

OR

^

XOR

&&

AND logico

||

OR logico


Il programma riportato qui di seguito mostra degli esempi di utilizzo degli operatori relazionali e logici:

import java.util.Random;

public class TestOperatoriLogici {
    public static void main(String arg[]) {
      Random rnd = new Random();
      int x = rnd.nextInt();
      int y = rnd.nextInt();

  
      System.out.println("----------------");
      System.out.println("Numeri generati:");
      System.out.println("----------------");
      System.out.println(" x = " + x);
      System.out.println(" y = " + y);
      System.out.println("----------------\n");
      System.out.println(" 1: x == y vale " + (x == y));
      System.out.println(" 2: x != y vale " + (x != y));
      System.out.println(" 3: x  < y vale " + (x < y));
      System.out.println(" 4: x  > y vale " + (x > y));
      System.out.println(" 5: x <= y vale " + (x <= y));
      System.out.println(" 6: x >= y vale " + (x >= y));
      System.out.println("----------------");
      System.out.println(" 7: !(x == y) vale " + !(x == y));
      System.out.println(" 8: (x != y) &  (x  < y) vale "
                            + ((x != y) &  (x  < y)));
        System.out.println(" 9: (x <= y) |  (x >= 0) vale "
                             + ((x <= y) |  (x >= 0)));
      System.out.println("10: !(x < y) ^  (x != y) vale "
                             + (!(x < y) ^  (x != y)));
      System.out.println("11: (x != y) && (x  < y) vale "
                             + ((x != y) && (x  < y)));
      System.out.println("12: (x <= y) || (x >= 0) vale "
                             + ((x <= y) || (x >= 0)));
      System.out.println("----------------");
    }
}

Un possibile risultato d’esecuzione è il seguente:

----------------
Numeri generati:
----------------
 x = 536896264
 y = -349864761
----------------

 1: x == y vale false
 2: x != y vale true
 3: x  < y vale false
 4: x  > y vale true
 5: x <= y vale false
 6: x >= y vale true
----------------
 7: !(x == y) vale true
 8: (x != y) &  (x  < y) vale false
 9: (x <= y) |  (x >= 0) vale true
10: !(x < y) ^  (x != y) vale false
11: (x != y) && (x  < y) vale false
12: (x <= y) || (x >= 0) vale true
----------------


Vediamo di capire cosa avviene.


Attraverso un’istanza della classe “Random” del package java.util vengono generati due numeri interi pseudocasuali x e y, che vengono mostrati a video.
Nelle istruzioni successive (volutamente contrassegnate con un numero) vengono stampate delle possibili espressioni logiche seguite dal loro valore booleano.
Le prime 6 espressioni non dovrebbero esserci oscure:
la 1 confronta x e y e ci dice se sono due numeri uguali;
la 2 ci dice se x e y sono diversi;
la 3 è falsa perché x non è minore di y;
la 4 è vera persché x è maggiore di y;
la 5 è uguale alla 3 e differisce da essa solo nel caso in cui x e y sono uguali;
la 6 è uguale alla 4 e differisce da essa solo nel caso in cui x e y sono uguali.
Le espressioni dalla 7 alla 12 sono un po’ più complesse e interessanti:
la 7 ci restituisce il valore opposto alla 1 ed equivale alla 2;

la 8 verifica che siano contemporaneamente vere le due condizioni, se una delle due è falsa, il risultato è falso;
la 9 verifica che almeno una delle due condizioni sia vera, se sono entrambe false, il risultato è falso;
la 10 mostra il funzionamento dello XOR logico, detto anche or esclusivo, che vale true se le due condizioni hanno valore logico opposto, false se le condizioni hanno lo stesso valore logico;
la 11 ha la stessa funzionalità della 8, ma differisce da essa, perché se la prima condizione è falsa, la seconda non viene valutata;
la 12 è uguale alla 9 con la differenza che se la prima condizione è vera, la seconda non viene valutata.

 

Torna all'indice Generale del corso di Corso di Java di Software Planet