Detaillierte Einführung in die neuen Datums- und Uhrzeitklassen in Java 8

In diesem Artikel geht es hauptsächlich um den eigentlichen Kampf gegen das neue Datum und Zeit API in Java8. Die neuen Date- und Time-Klassen sind das Ergebnis lang erwarteter Anfragen der Java-Entwickler-Community. Die Date-Klasse, die vor Java8 existierte, wurde immer kritisiert, und viele Leute entscheiden sich für die Verwendung der Datumsbibliothek Joda-Time eines Drittanbieters. Die Datums- und Uhrzeit-API in Java8 wurde vom Autor von jodatime entwickelt und implementiert alle Inhalte von JSR310. Diese neuen APIs befinden sich im Paket java.time.

Da Joda-Time und Date4j von Drittanbietern bereits leistungsstark genug sind, warum muss Java8 sie dann erneut implementieren? Ein Grund dafür ist, dass diese Drittanbieter-Bibliotheken wie der Standard Kompatibilitätsprobleme haben JSF-Datum Der Konverter ist nicht mit der Joda-Time-API kompatibel. Sie müssen bei jeder Verwendung einen eigenen Konverter schreiben. Bei JSR310 sind alle seine Bestimmungen in Java8 implementiert.

Die Designprinzipien hinter der neuen Date- und Time-Klasse:

Unveränderliche Klasse

Vor Java8, die Date-Klasse war Es ist eine veränderliche Klasse. Wenn wir es in einer Multithread-Umgebung verwenden, sollten Programmierer bestätigen, dass das Date-Objekt threadsicher ist. Die Datums- und Uhrzeit-APIs von Java 8 stellen threadsichere, unveränderliche Klassen bereit. Programmierer müssen sich nicht mit Parallelitätsproblemen befassen.

DomäneModellGesteuerterDesignansatz

Die neuen Datums- und Zeitkategorien folgen „Domain Driven Design“. Für Entwickler ist es einfach, die Funktionalität von Methoden und Klassen zu verstehen.

Als nächstes werfen wir einen Blick auf die neue Datums- und Uhrzeit-API:

java.time.LocalDate:

LocalDate liefert nur das Datum, aber keine Uhrzeit Information. Es ist unveränderlich und threadsicher.

package org.smarttechie;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
/**
* This class demonstrates JAVA 8 data and time API
* @author Siva Prasad Rao Janapati
* */
public class DateTimeDemonstration {
/**
* @param args
*/
public static void main(String[] args) {
   //Create date LocalDate localDate = LocalDate.now();
    System.out.println("The local date is :: " + localDate); 
   //Find the length of the month. That is, how many days are there for this month.
   System.out.println("The number of days available for this month:: " + localDate.lengthOfMonth()); 
   //Know the month name
   System.out.println("What is the month name? :: " + localDate.getMonth().name()); 
   //add 2 days to the today's date.
   System.out.println(localDate.plus(2, ChronoUnit.DAYS)); 
   //substract 2 days from today
   System.out.println(localDate.minus(2, ChronoUnit.DAYS)); 
   //Convert the string to date
   System.out.println(localDate.parse("2017-04-07"));
  }
}

java.time.LocalTime:

LocalTime stellt nur Zeit-, aber keine Datumsinformationen bereit. Es ist eine unveränderliche Klasse und Thread-sicher.

package org.smarttechie;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;
/**
* This class demonstrates JAVA 8 data and time API
* @author Siva Prasad Rao Janapati
* */
public class DateTimeDemonstration {
/**
* @param args
*/
public static void main(String[] args) {
   //Get local time
   LocalTime localTime = LocalTime.now();
   System.out.println(localTime);
  //Get the hour of the day
  System.out.println("The hour of the day:: " + localTime.getHour());
  //add 2 hours to the time.
  System.out.println(localTime.plus(2, ChronoUnit.HOURS));
  //add 6 minutes to the time.
  System.out.println(localTime.plusMinutes(6));
  //substract 2 hours from current time
  System.out.println(localTime.minus(2, ChronoUnit.HOURS));
 }
}

java.time.LocalDateTime:

LocalDateTime stellt Zeit- und Datumsinformationen bereit, es ist eine unveränderliche Klasse und Thread-sicher

package orr.smarttechie;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
/**
* This class demonstrates JAVA 8 data and time API
* @author Siva Prasad Rao Janapati
*
*/
public class DateTimeDemonstration {
/**
* @param args
*/
public static void main(String[] args) {
    //Get LocalDateTime object
    LocalDateTime localDateTime = LocalDateTime.now();
    System.out.println(localDateTime);
    //Find the length of month. That is, how many days are there for this month.
    System.out.println("The number of days available for this month:: " + localDateTime.getMonth().length(true));
    //Know the month name
    System.out.println("What is the month name? :: " + localDateTime.getMonth().name());
    //add 2 days to today's date.
    System.out.println(localDateTime.plus(2, ChronoUnit.DAYS));
    //substract 2 days from today
    System.out.println(localDateTime.minus(2, ChronoUnit.DAYS));
  }
}

java.time.Year:

Year liefert Jahresinformationen, ist unveränderlich und Thread-sicher.

package orr.smarttechie;
import java.time.Year;
import java.time.temporal.ChronoUnit;
/**
* This class demonstrates JAVA 8 data and time API
* @author Siva Prasad Rao Janapati
*
*/
public class DateTimeDemonstration {
/**
* @param args
*/
public static void main(String[] args) {
   //Get year
   Year year = Year.now();
   System.out.println("Year ::" + year);
   //know the year is leap year or not
   System.out.println("Is year[" +year+"] leap year?"+ year.isLeap());
  }
}

java.time.Duration:

Die Dauer wird verwendet, um zu berechnen, wie viele Sekunden und Millisekunden zwischen zwei angegebenen Daten liegen. Dies ist nicht möglich Thread-sicher

java.time.Period:

Period wird verwendet, um zu berechnen, wie viele Tage, Monate oder mehr zwischen zwei angegebenen Daten liegen. Wie viele Jahre sind es ist unveränderlich, klassen- und threadsicher

package orr.smarttechie;
import java.time.LocalDate;
import java.time.Period;
import java.time.temporal.ChronoUnit;
/**
* This class demonstrates JAVA 8 data and time API
* @author Siva Prasad Rao Janapati
*
*/
public class DateTimeDemonstration {
/**
* @param args
*/
public static void main(String[] args) {
   LocalDate localDate = LocalDate.now();
   Period period = Period.between(localDate, localDate.plus(2, ChronoUnit.DAYS));
   System.out.println(period.getDays());
  }
}

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in die neuen Datums- und Uhrzeitklassen in Java 8. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!