Java Language
Data di lezione

Sintassi

• Date object = new Date();
• Date object = new Date(long date);

Parametri

Osservazioni

import java.util.Date;

public final class Transaction {
  private final Date date;

  public Date getTransactionDate() {
    return date;
  }
}

Creazione di oggetti Date

Date date = new Date();
System.out.println(date); // Thu Feb 25 05:03:59 IST 2016

Qui questo oggetto Date contiene la data e l'ora corrente in cui questo oggetto è stato creato.

Calendar calendar = Calendar.getInstance();
calendar.set(90, Calendar.DECEMBER, 11);
Date myBirthDate = calendar.getTime();
System.out.println(myBirthDate); // Mon Dec 31 00:00:00 IST 1990

Date oggetti Date sono creati meglio attraverso un'istanza di Calendar poiché l'uso dei costruttori di dati è deprecato e scoraggiato. Per fare ciò abbiamo bisogno di ottenere un'istanza della classe Calendar dal metodo factory. Quindi possiamo impostare l'anno, il mese e il giorno del mese utilizzando i numeri o, in caso di mesi, le costanti fornite dalla classe Calendar per migliorare la leggibilità e ridurre gli errori.

calendar.set(90, Calendar.DECEMBER, 11, 8, 32, 35);
Date myBirthDatenTime = calendar.getTime();
System.out.println(myBirthDatenTime); // Mon Dec 31 08:32:35 IST 1990

Insieme alla data, possiamo anche passare il tempo nell'ordine di ore, minuti e secondi.

Confronto degli oggetti Data

Calendario, data e data locale

//Use of Calendar and Date objects    
final Date today = new Date();
final Calendar calendar = Calendar.getInstance();
calendar.set(1990, Calendar.NOVEMBER, 1, 0, 0, 0);
Date birthdate = calendar.getTime();

final Calendar calendar2 = Calendar.getInstance();
calendar2.set(1990, Calendar.NOVEMBER, 1, 0, 0, 0);
Date samebirthdate = calendar2.getTime();

//Before example
System.out.printf("Is %1$tF before %2$tF? %3$b%n", today, birthdate, Boolean.valueOf(today.before(birthdate)));
System.out.printf("Is %1$tF before %1$tF? %3$b%n", today, today, Boolean.valueOf(today.before(today)));
System.out.printf("Is %2$tF before %1$tF? %3$b%n", today, birthdate, Boolean.valueOf(birthdate.before(today)));

//After example
System.out.printf("Is %1$tF after %2$tF? %3$b%n", today, birthdate, Boolean.valueOf(today.after(birthdate)));
System.out.printf("Is %1$tF after %1$tF? %3$b%n", today, birthdate, Boolean.valueOf(today.after(today)));
System.out.printf("Is %2$tF after %1$tF? %3$b%n", today, birthdate, Boolean.valueOf(birthdate.after(today)));

//Compare example
System.out.printf("Compare %1$tF to %2$tF: %3$d%n", today, birthdate, Integer.valueOf(today.compareTo(birthdate)));
System.out.printf("Compare %1$tF to %1$tF: %3$d%n", today, birthdate, Integer.valueOf(today.compareTo(today)));
System.out.printf("Compare %2$tF to %1$tF: %3$d%n", today, birthdate, Integer.valueOf(birthdate.compareTo(today)));

//Equal example
System.out.printf("Is %1$tF equal to %2$tF? %3$b%n", today, birthdate, Boolean.valueOf(today.equals(birthdate)));
System.out.printf("Is %1$tF equal to %2$tF? %3$b%n", birthdate, samebirthdate,
            Boolean.valueOf(birthdate.equals(samebirthdate)));
System.out.printf(
            "Because birthdate.getTime() -> %1$d is different from samebirthdate.getTime() -> %2$d, there are millisecondes!%n",
            Long.valueOf(birthdate.getTime()), Long.valueOf(samebirthdate.getTime()));

//Clear ms from calendars
calendar.clear(Calendar.MILLISECOND);
calendar2.clear(Calendar.MILLISECOND);
birthdate = calendar.getTime();
samebirthdate = calendar2.getTime();

System.out.printf("Is %1$tF equal to %2$tF after clearing ms? %3$b%n", birthdate, samebirthdate,
            Boolean.valueOf(birthdate.equals(samebirthdate)));

//Use of LocalDate
final LocalDate now = LocalDate.now();
final LocalDate birthdate2 = LocalDate.of(2012, 6, 30);
final LocalDate birthdate3 = LocalDate.of(2012, 6, 30);

//Hours, minutes, second and nanoOfsecond can also be configured with an other class LocalDateTime
//LocalDateTime.of(year, month, dayOfMonth, hour, minute, second, nanoOfSecond);

//isBefore example
System.out.printf("Is %1$tF before %2$tF? %3$b%n", now, birthdate2, Boolean.valueOf(now.isBefore(birthdate2)));
System.out.printf("Is %1$tF before %1$tF? %3$b%n", now, birthdate2, Boolean.valueOf(now.isBefore(now)));
System.out.printf("Is %2$tF before %1$tF? %3$b%n", now, birthdate2, Boolean.valueOf(birthdate2.isBefore(now)));

//isAfter example
System.out.printf("Is %1$tF after %2$tF? %3$b%n", now, birthdate2, Boolean.valueOf(now.isAfter(birthdate2)));
System.out.printf("Is %1$tF after %1$tF? %3$b%n", now, birthdate2, Boolean.valueOf(now.isAfter(now)));
System.out.printf("Is %2$tF after %1$tF? %3$b%n", now, birthdate2, Boolean.valueOf(birthdate2.isAfter(now)));

//compareTo example
System.out.printf("Compare %1$tF to %2$tF %3$d%n", now, birthdate2, Integer.valueOf(now.compareTo(birthdate2)));
System.out.printf("Compare %1$tF to %1$tF %3$d%n", now, birthdate2, Integer.valueOf(now.compareTo(now)));
System.out.printf("Compare %2$tF to %1$tF %3$d%n", now, birthdate2, Integer.valueOf(birthdate2.compareTo(now)));

//equals example
System.out.printf("Is %1$tF equal to %2$tF? %3$b%n", now, birthdate2, Boolean.valueOf(now.equals(birthdate2)));
System.out.printf("Is %1$tF to %2$tF? %3$b%n", birthdate2, birthdate3, Boolean.valueOf(birthdate2.equals(birthdate3)));

//isEqual example
System.out.printf("Is %1$tF equal to %2$tF? %3$b%n", now, birthdate2, Boolean.valueOf(now.isEqual(birthdate2)));
System.out.printf("Is %1$tF to %2$tF? %3$b%n", birthdate2, birthdate3, Boolean.valueOf(birthdate2.isEqual(birthdate3)));

Confronto delle date prima di Java 8

Prima di Java 8, le date potevano essere confrontate usando le classi java.util.Calendar e java.util.Date . La classe Date offre 4 metodi per confrontare le date:

• dopo (Data in cui)
• prima (Data in cui)
• compareTo (Date anotherDate)
• uguale (oggetto obj)

after , before , i metodi compareTo ed equals confrontano i valori restituiti dal metodo getTime () per ogni data.

compareTo metodo compareTo restituisce un numero intero positivo.

• Valore maggiore di 0: quando la data è successiva all'argomento data
• Valore maggiore di 0: quando la data è precedente all'argomento Date
• Il valore è uguale a 0: quando la data è uguale all'argomento della data

equals risultati equals possono essere sorprendenti, come mostrato nell'esempio, poiché i valori, come millisecondi, non vengono inizializzati con lo stesso valore se non esplicitamente indicati.

Da quando Java 8

Con Java 8 è disponibile java.time.LocalDate, un nuovo oggetto con cui lavorare con Date. LocalDate implementa ChronoLocalDate , la rappresentazione astratta di una data in cui la cronologia, o sistema di calendario, è inseribile.

Per avere la precisione temporale della data è necessario utilizzare l'oggetto java.time.LocalDateTime . LocalDate e LocalDateTime utilizzano lo stesso nome di metodi per il confronto.

Confrontare le date utilizzando un LocalDate è diverso dall'uso di ChronoLocalDate perché la cronologia o il sistema di calendario non vengono presi in considerazione nel primo.

Poiché la maggior parte delle applicazioni deve utilizzare LocalDate , ChronoLocalDate non è incluso negli esempi. Ulteriore lettura qui .

La maggior parte delle applicazioni dovrebbe dichiarare firme, campi e variabili del metodo come LocalDate, non questa interfaccia [ChronoLocalDate].

LocalDate ha 5 metodi per confrontare le date:

• isAfter (ChronoLocalDate altro)
• isBefore (ChronoLocalDate altro)
• isEqual (ChronoLocalDate altro)
• compareTo (ChronoLocalDate altro)
• uguale (oggetto obj)

In caso di parametro LocalDate , isAfter , isBefore , isEqual , equals e compareTo ora usa questo metodo:

int compareTo0(LocalDate otherDate) {
    int cmp = (year - otherDate.year);
    if (cmp == 0) {
        cmp = (month - otherDate.month);
        if (cmp == 0) {
            cmp = (day - otherDate.day);
        }
    }
    return cmp;
}

equals controllo del metodo se il riferimento al parametro è uguale alla data, mentre isEqual chiama direttamente compareTo0 .

In caso di un'altra istanza di classe di ChronoLocalDate le date vengono confrontate utilizzando Epoch Day . Il conteggio Epoch Day è un semplice conteggio incrementale di giorni in cui il giorno 0 è 1970-01-01 (ISO).

Convertire la data in un determinato formato di stringa

format() della classe SimpleDateFormat consente di convertire un oggetto Date in un determinato oggetto String format utilizzando la stringa di pattern fornita.

Date today = new Date();
    
SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MMM-yy"); //pattern is specified here
System.out.println(dateFormat.format(today)); //25-Feb-16 

I pattern possono essere applicati nuovamente usando applyPattern()

dateFormat.applyPattern("dd-MM-yyyy");
System.out.println(dateFormat.format(today)); //25-02-2016

dateFormat.applyPattern("dd-MM-yyyy HH:mm:ss E");
System.out.println(dateFormat.format(today)); //25-02-2016 06:14:33 Thu

Nota: Qui mm (la lettera minuscola m) indica i minuti e MM (la lettera maiuscola M) indica il mese. Prestare particolare attenzione durante la formattazione degli anni: la lettera maiuscola "Y" ( Y ) indica la "settimana dell'anno" mentre la lettera minuscola "y" ( y ) indica l'anno.

Conversione di stringa in data

parse() dalla classe SimpleDateFormat aiuta a convertire un pattern String in un oggetto Date .

DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.SHORT, Locale.US);
String dateStr = "02/25/2016"; // input String
Date date = dateFormat.parse(dateStr);
System.out.println(date.getYear()); // 116

Esistono 4 stili diversi per il formato di testo, SHORT , MEDIUM (questo è il valore predefinito), LONG e FULL , che dipendono tutti dalle impostazioni locali. Se non viene specificata alcuna locale, viene utilizzata la locale predefinita del sistema.

Una data di uscita di base

Usando il seguente codice con la stringa di formato yyyy/MM/dd hh:mm.ss , riceveremo il seguente output

2016/04/19 11: 45.36

// define the format to use
String formatString = "yyyy/MM/dd hh:mm.ss";

// get a current date object
Date date = Calendar.getInstance().getTime();

// create the formatter
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formatString);

// format the date
String formattedDate = simpleDateFormat.format(date);

// print it
System.out.println(formattedDate);


// single-line version of all above code
System.out.println(new SimpleDateFormat("yyyy/MM/dd hh:mm.ss").format(Calendar.getInstance().getTime()));

Converti la rappresentazione di stringa formattata di data in oggetto Date

Questo metodo può essere utilizzato per convertire una rappresentazione di stringa formattata di una data in un oggetto Date .

    /**
     * Parses the date using the given format.
     *
     * @param formattedDate the formatted date string
     * @param dateFormat the date format which was used to create the string.
     * @return the date
     */
    public static Date parseDate(String formattedDate, String dateFormat) {
        Date date = null;
        SimpleDateFormat objDf = new SimpleDateFormat(dateFormat);
        try {
          date = objDf.parse(formattedDate);
        } catch (ParseException e) {
          // Do what ever needs to be done with exception.
        }
        return date;
    }

Creazione di una data specifica

Mentre la classe Date di Java ha diversi costruttori, noterai che molti sono deprecati. L'unico modo accettabile di creare direttamente un'istanza di Date consiste nell'utilizzare il costruttore vuoto o nel passare un lungo (numero di millisecondi dall'ora di base standard). Né sono a portata di mano se non stai cercando la data corrente o hai già un'altra istanza di Data in mano.

Per creare una nuova data, avrai bisogno di un'istanza di Calendar. Da lì puoi impostare l'istanza di Calendar sulla data di cui hai bisogno.

Calendar c = Calendar.getInstance();

Ciò restituisce una nuova istanza di Calendar impostata sull'ora corrente. Calendar ha molti metodi per modificare la data e l'ora o impostarlo a titolo definitivo. In questo caso, lo imposteremo su una data specifica.

c.set(1974, 6, 2, 8, 0, 0);
Date d = c.getTime();

Il metodo getTime restituisce l'istanza Date di cui abbiamo bisogno. Tieni presente che i metodi di impostazione del calendario impostano solo uno o più campi, ma non li impostano tutti. Cioè, se si imposta l'anno, gli altri campi rimangono invariati.

trappola

In molti casi, questo snippet di codice soddisfa il suo scopo, ma tieni presente che due parti importanti della data / ora non sono definite.

• i parametri (1974, 6, 2, 8, 0, 0) sono interpretati all'interno del fuso orario predefinito, definito da qualche altra parte,
• i millisecondi non sono impostati su zero, ma vengono riempiti dall'orologio di sistema nel momento in cui viene creata l'istanza di Calendar.

Oggetti Java 8 LocalDate e LocalDateTime

Gli oggetti Date e LocalDate non possono essere convertiti esattamente tra loro in quanto un oggetto Date rappresenta sia un giorno che un'ora specifici, mentre un oggetto LocalDate non contiene informazioni sul fuso orario o sul fuso orario. Tuttavia, può essere utile convertire tra i due se ti interessano solo le informazioni sulla data effettiva e non le informazioni sull'ora.

Crea un LocalDate

// Create a default date
LocalDate lDate = LocalDate.now();

// Creates a date from values
lDate = LocalDate.of(2017, 12, 15);
    
// create a date from string
lDate = LocalDate.parse("2017-12-15");

// creates a date from zone
LocalDate.now(ZoneId.systemDefault());

Crea un LocalDateTime

// Create a default date time
LocalDateTime lDateTime = LocalDateTime.now();

// Creates a date time from values
lDateTime = LocalDateTime.of(2017, 12, 15, 11, 30);

// create a date time from string
lDateTime = LocalDateTime.parse("2017-12-05T11:30:30");

// create a date time from zone 
LocalDateTime.now(ZoneId.systemDefault());

LocalDate to Date e viceversa

Date date = Date.from(Instant.now());
ZoneId defaultZoneId = ZoneId.systemDefault();

// Date to LocalDate
LocalDate localDate = date.toInstant().atZone(defaultZoneId).toLocalDate();

// LocalDate to Date
Date.from(localDate.atStartOfDay(defaultZoneId).toInstant());

LocalDateTime to Date e viceversa

Date date = Date.from(Instant.now());
ZoneId defaultZoneId = ZoneId.systemDefault();

// Date to LocalDateTime
LocalDateTime localDateTime =  date.toInstant().atZone(defaultZoneId).toLocalDateTime();

// LocalDateTime to Date
Date out = Date.from(localDateTime.atZone(defaultZoneId).toInstant());

Fusi orari e java.util.Date

Un oggetto java.util.Date non ha un concetto di fuso orario.

• Non c'è modo di impostare un fuso orario per una data
• Non c'è modo di cambiare il fuso orario di un oggetto Date
• Un oggetto Date creato con il new Date() costruttore predefinito new Date() verrà inizializzato con l'ora corrente nel fuso orario predefinito del sistema

Tuttavia, è possibile visualizzare la data rappresentata dal punto nel tempo descritto dall'oggetto Date in un fuso orario diverso, ad es. java.text.SimpleDateFormat :

Date date = new Date();
//print default time zone
System.out.println(TimeZone.getDefault().getDisplayName());
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //note: time zone not in format!
//print date in the original time zone
System.out.println(sdf.format(date));
//current time in London
sdf.setTimeZone(TimeZone.getTimeZone("Europe/London"));
System.out.println(sdf.format(date));

Produzione:

Central European Time
2016-07-21 22:50:56
2016-07-21 21:50:56

Convertire java.util.Date in java.sql.Date

java.util.Date conversione da java.util.Date a java.sql.Date è solitamente necessaria quando un oggetto Date deve essere scritto in un database.

java.sql.Date è un wrapper attorno al valore millisecondo ed è usato da JDBC per identificare un tipo SQL DATE

Nell'esempio seguente, usiamo il costruttore java.util.Date() , che crea un oggetto Date e lo inizializza per rappresentare il tempo al millisecondo più vicino. Questa data viene utilizzata nel metodo convert(java.util.Date utilDate) per restituire un oggetto java.sql.Date

Esempio

public class UtilToSqlConversion {
    
    public static void main(String args[])
    {
        java.util.Date utilDate = new java.util.Date();
        System.out.println("java.util.Date is : " + utilDate);
        java.sql.Date sqlDate = convert(utilDate);
        System.out.println("java.sql.Date is : " + sqlDate);
        DateFormat df = new SimpleDateFormat("dd/MM/YYYY - hh:mm:ss");
        System.out.println("dateFormated date is : " + df.format(utilDate));
    }

    private static java.sql.Date convert(java.util.Date uDate) {
        java.sql.Date sDate = new java.sql.Date(uDate.getTime());
        return sDate;
    }

}

Produzione

java.util.Date is : Fri Jul 22 14:40:35 IST 2016
java.sql.Date is : 2016-07-22
dateFormated date is : 22/07/2016 - 02:40:35

java.util.Date ha informazioni sia sulla data che sull'ora, mentre java.sql.Date ha solo informazioni sulla data

Ora locale

Per utilizzare solo la parte temporale di una data, utilizzare LocalTime. Puoi creare un'istanza di un oggetto LocalTime in un paio di modi

1. LocalTime time = LocalTime.now();
2. time = LocalTime.MIDNIGHT;
3. time = LocalTime.NOON;
4. time = LocalTime.of(12, 12, 45);

LocalTime ha anche un built-in metodo toString che visualizza il formato molto bene.

System.out.println(time); 

puoi anche ottenere, aggiungere e sottrarre ore, minuti, secondi e nanosecondi dall'oggetto LocalTime, ad es

time.plusMinutes(1);
time.getMinutes();
time.minusMinutes(1);

Puoi trasformarlo in un oggetto Date con il seguente codice:

LocalTime lTime = LocalTime.now();
Instant instant = lTime.atDate(LocalDate.of(A_YEAR, A_MONTH, A_DAY)).
        atZone(ZoneId.systemDefault()).toInstant();
Date time = Date.from(instant);

questa classe funziona molto bene all'interno di una classe di timer per simulare una sveglia.