Come Eseguire il Confronto fra Date in Java

Esistono diversi modi per confrontare due date nel linguaggio Java. All'interno del programma una data viene rappresentata sotto forma di un numero intero (long), relativo a uno specifico punto temporale — il numero di millisecondi che sono trascorsi dal 1 gennaio 1970. In questo linguaggio "Date" è un oggetto e quindi include svariati metodi di comparazione. Sostanzialmente qualunque metodo per il confronto di due date, esegue in realtà il confronto fra due numeri che rappresentano gli istanti di tempo a cui le date fanno riferimento.

Metodo 1

Metodo 1 di 4:

Usare il Metodo "compareTo"

1
Utilizza il metodo "compareTo". La classe "Date" implementa l'interfaccia "Comparable<Date>", quindi due oggetti di questo tipo (cioè due date) possono essere confrontati direttamente tramite il metodo "compareTo". Se le date sono identiche, cioè fanno riferimento al medesimo istante di tempo, il metodo restituirà il valore zero (0). Se l'oggetto "Date" che invoca il metodo "compareTo" rappresenta una data antecedente a quella usata come argomento del metodo, il confronto restituirà un valore numerico minore di zero. Al contrario, se l'oggetto "Date" che invoca il metodo "compareTo" rappresenta una data successiva a quella usata come argomento, il confronto restituirà un valore numerico superiore a zero. Come già detto se le due date confrontate sono uguali, verrà restituito il valore numerico zero. ^{[1]
X
Fonte di ricerca}
2
Crea due oggetti "Date". Il primo passo da compiere, prima di poter effettuare il confronto, consiste nel creare i due oggetti che conterranno le date da comparare. Uno dei modi per farlo consiste nell'utilizzare la classe "SimpleDateFormat". Quest'ultima permette di inserire una data all'interno di un oggetto di tipo "Date" in modo semplice e veloce.
```
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); //Dichiarazione dell'oggetto che rappresenta il formato della data che andremo a usare nel confronto. Quando andremo a inserire i valori dovremo rispettare tale formato
Date date1 = sdf.parse("1995-02-23"); //date1 rappresenta il 23 febbraio 1995
Date date2 = sdf.parse("2001-10-31"); //date2 rappresenta il 31 ottobre 2001
Date date3 = sdf.parse("1995-02-23"); //date3 rappresenta il 23 febbraio 1995
```
3
Confronta gli oggetti di tipo "Date". Il codice seguente mostra i risultati che otterremo in ognuna delle casistiche possibili: nel caso in cui la prima data è minore della seconda, quando abbiamo due date uguali, e quando la prima data è maggiore della seconda.
```
date1.compareTo(date2); //date1 < date2 otterremo come risultato un valore minore di 0
date2.compareTo(date1); //date2 > date1 otterremo come risultato un valore maggiore di 0
date1.compareTo(date3); //date1 = date3 otterremo come risultato esattamente 0
```
Pubblicità

Metodo 2

Metodo 2 di 4:

Usare i Metodi "Equals", "After" e "Before"

1
Usa i metodi di confronto "equals", "after" e "before". Gli oggetti della classe "Date" possono essere confrontati direttamente utilizzando i metodi "equals", "after" e "before". Se le due date confrontate fanno riferimento al medesimo istante di tempo, il metodo "equals" restituirà il valore booleano "true". Per esporre l'utilizzo di questi metodi, useremo le stesse date di esempio utilizzate per descrivere il comportamento del metodo "compareTo". ^{[2]
X
Fonte di ricerca}
2
Confrontiamo i valori usando il metodo "before". Il seguente codice mostra entrambe le casistiche, cioè quando viene restituito il valore booleano "true" e quando viene restituito "false". Se "date1" rappresenta una data antecedente a quella memorizzata nell'oggetto "date2", il metodo "before" restituirà il valore "true". In caso contrario otterremo il valore booleano "false".
```
System.out.print(date1.before(date2)); //verrà stampato il valore "true"
System.out.print(date2.before(date2)); //verrà stampato il valore "false"
```
3
Confrontiamo i valori usando il metodo "after". Il seguente codice mostra entrambe le casistiche, cioè quando viene restituito il valore booleano "true" e quando viene restituito "false". Se "date2" rappresenta una data successiva a quella memorizzata nell'oggetto "date1", il metodo "after" restituirà il valore "true". In caso contrario otterremo il valore booleano "false".
```
System.out.print(date2.after(date1)); //verrà stampato il valore "true"
System.out.print(date1.after(date2)); //verrà stampato il valore "false"
```
4
Confrontiamo i valori usando il metodo "equals". Il seguente codice mostra entrambe le casistiche, cioè quando viene restituito il valore booleano "true" e quando viene restituito "false". Se entrambi gli oggetti "Date" del confronto rappresentano la stessa data, il metodo "equals" restituirà il valore "true". In caso contrario otterremo il valore booleano "false".
```
System.out.print(date1.equals(date3)); //verrà stampato il valore "true"
System.out.print(date1.equals(date2)); //verrà stampato il valore "false"
```
Pubblicità

Metodo 3

Metodo 3 di 4:

Usare la Classe "Calendar"

1
Utilizza la classe "Calendar". Anche quest'ultima è dotata dei metodi di confronto "compareTo": "equals", "after" e "before", che funzionano esattamente nello stesso modo descritto per la classe "Date". Se le date da confrontare sono memorizzate in un oggetto di tipo "Calendar", non c'è ragione di estrarle per effettuare la comparazione, basta semplicemente sfruttare i metodi dell'oggetto.^{[3]
X
Fonte di ricerca}
2
Crea le istanze della classe "Calendar". Per poter usare i metodi della classe "Calendar" dobbiamo per prima cosa creare delle istanze di tale elemento. Fortunatamente è possibile sfruttare le date che abbiamo già inserito nelle istanze della classe "Date".
```
Calendar cal1 = Calendar.getInstance(); //dichiarazione dell'oggetto cal1
Calendar cal2 = Calendar.getInstance(); //dichiarazione dell'oggetto cal2
Calendar cal3 = Calendar.getInstance(); //dichiarazione dell'oggetto cal3
cal1.setTime(date1); //inseriamo la data all'interno dell'oggetto cal1
cal2.setTime(date2); //inseriamo la data all'interno dell'oggetto cal2
cal3.setTime(date3); //inseriamo la data all'interno dell'oggetto cal3
```
3
Confrontiamo gli oggetti "cal1" e "cal2" usando il metodo "before". Il seguente codice stamperà a video il valore booleano "true", se la data contenuta in "cal1" è precedente a quella memorizzata in "cal2".
```
System.out.print(cal1.before(cal2)); //verrà mostrato a video il valore "true"
```
4
Confrontiamo gli oggetti "cal1" e "cal2" usando il metodo "after". Il seguente codice stamperà a video il valore booleano "false", se la data contenuta in "cal1" è precedente a quella memorizzata in "cal2".
```
System.out.print(cal1.after(cal2)); //verrà mostrato a video il valore "false"
```
5
Confrontiamo gli oggetti "cal1" e "cal2" usando il metodo "equals". Il seguente codice mostra entrambe le casistiche, cioè quando verrà restituito il valore booleano "true" e quando invece verrà restituito "false". Le condizioni perché questo si verifichi dipendono ovviamente dal valore assunto dalle istanze della classe "Calendar" che andremo a confrontare. Il seguente codice di esempio dovrebbe stampare a video il valore "true", seguito dal valore "false" sulla riga successiva.
```
System.out.println(cal1.equals(cal3)); //verrà mostrato il valore true dato che cal1 è uguale a cal3
System.out.print(cal1.equals(cal2)); //verrà mostrato il valore false dato che cal1 è diverso da cal2
```
Pubblicità

Metodo 4

Metodo 4 di 4:

Usare il Metodo "getTime"

1
Usa il metodo "getTime". In Java è possibile confrontare direttamente due date dopo aver trasformato il relativo valore in un tipo di dato primitivo (cioè le tipologie di dati predefinite del linguaggio). I metodi descritti in precedenza sono tuttavia da preferire, dato che risultano più leggibili e possono quindi essere più adatti a un contesto lavorativo in cui il codice sorgente dovrà essere gestito da persone diverse. Dato che il confronto avverrà fra dati primitivi può essere eseguito utilizzando direttamente gli operatori di confronto "<", ">" e "==".
2
Creiamo gli oggetti di tipo "long" che conterranno le date da confrontare. Per farlo, dovremo trasformare il valore memorizzato negli oggetti di tipo "Date" usati in preceda in un numero intero di tipo "long". Fortunatamente esiste un metodo che esegue questa conversione in modo semplice e rapido: "getTime()".
3
Verifichiamo se la prima data è minore della seconda. Per farlo, utilizzeremo l'operatore di confronto "<" per comparare i due valori interi che corrispondono alle date "date1" e "date2". Dato che il numero memorizzato nell'oggetto "time1" è minore di quello presente nell'oggetto "time2" verrà stampato il messaggio contenuto nel primo ramo della struttura logica "If-else". Il blocco di codice relativo all'istruzione "else" è stato incluso per rispettare la correttezza della sintassi.
4
Verifichiamo se la prima data è maggiore della seconda. Per farlo, utilizzeremo l'operatore di confronto ">" per comparare i due valori interi che corrispondono alle date "date1" e "date2". Dato che il numero memorizzato nell'oggetto "time1" è minore di quello presente nell'oggetto "time2" verrà stampato il messaggio contenuto nel primo ramo della struttura logica "If-else". Il blocco di codice relativo all'istruzione "else" è stato incluso per rispettare la correttezza della sintassi.
5
Verifichiamo se entrambe le date sono uguali. Per farlo, utilizzeremo l'operatore di confronto "==" per comparare i due valori interi che corrispondono alle date "date1" e "date2". Dato che il numero memorizzato nell'oggetto "time1" è uguale a quello presente nell'oggetto "time3" verrà stampato il messaggio contenuto nel primo ramo della struttura logica "If-else". Se il programma dovesse stampare a video il secondo messaggio (cioè quello incluso nell'istruzione "else"), significa che le due date confrontate non sono uguali.^{[4]
X
Fonte di ricerca}
```
if(time1 == time2){
System.out.println("Le date sono uguali");
}
else{
System.out.println("Le date sono diverse"); //verrà stampato questo messaggio dato che il valore di time1 è effettivamente diverso da time2
}
```
Pubblicità