失眠网 > Java 8日期– LocalDate LocalDateTime 即时

Java 8日期– LocalDate LocalDateTime 即时

时间：2020-02-01 10:33:06

Java 8 Date Time APIis one of the most sought after change for developers. Java has been missing a consistent approach for Date and Time from start and Java 8 Date Time API is a welcome addition to the core Java APIs.

Java 8日期时间API是开发人员最需要的变更之一。 Java从一开始就缺少一致的Date和Time方法，而Java 8 Date Time API是对核心Java API的欢迎添加。

为什么我们需要新的Java日期时间API？ (Why do we need new Java Date Time API?)

Before we start looking at the Java 8 Date Time API, let’s see why do we need a new API for this. There have been several problems with the existing date and time related classes in java, some of them are:

在开始研究Java 8 Date Time API之前，让我们看看为什么需要一个新的API。 Java中与日期和时间相关的现有类存在多个问题，其中一些是：

Java Date Time classes are not defined consistently, we have Date Class in bothjava.utilas well asjava.sqlpackages. Again formatting and parsing classes are defined injava.textpackage.Java日期时间类的定义不一致，我们在java.util和java.sql包java.util都有Date类。再次在java.text包中定义了格式化和解析类。java.util.Datecontains both date and time, whereasjava.sql.Datecontains only date. Having this injava.sqlpackage doesn’t make sense. Also both the classes have same name, that is a very bad design itself.java.util.Date包含日期和时间，而java.sql.Date仅包含日期。在java.sql软件包中包含此名称没有任何意义。而且这两个类都具有相同的名称，这本身就是一个很糟糕的设计。 There are no clearly defined classes for time, timestamp, formatting and parsing. We havejava.text.DateFormatabstract class for parsing and formatting need. UsuallySimpleDateFormatclass is used for parsing and formatting.没有明确定义的时间，时间戳，格式和解析类。我们有java.text.DateFormat抽象类，用于解析和格式化需求。通常，SimpleDateFormat类用于解析和格式化。 All the Date classes are mutable, so they arenot thread safe. It’s one of the biggest problem with Java Date and Calendar classes.所有的Date类都是可变的，因此它们不是线程安全的。这是Java Date和Calendar类的最大问题之一。 Date class doesn’t provide internationalization, there is no timezone support. Sojava.util.Calendarandjava.util.TimeZoneclasses were introduced, but they also have all the problems listed above.日期类不提供国际化，没有时区支持。因此引入了java.util.Calendar和java.util.TimeZone类，但是它们也具有上面列出的所有问题。

There are some other issues with the methods defined in Date and Calendar classes but above problems make it clear that a robust Date Time API was needed in Java. That’s why Joda Time played a key role as a quality replacement for Java Date Time requirements.

Date和Calendar类中定义的方法还有其他一些问题，但以上问题清楚表明Java中需要强大的Date Time API。因此， Joda Time在替代Java Date Time要求方面起着重要作用。

Java 8日期 (Java 8 Date)

Java 8 Date Time API is JSR-310 implementation. It is designed to overcome all the flaws in the legacy date time implementations. Some of the design principles of new Date Time API are:

Java 8日期时间API是JSR-310的实现。它旨在克服传统日期时间实现中的所有缺陷。新的Date Time API的一些设计原则是：

Immutability: All the classes in the new Date Time API are immutable and good for multithreaded environments.不变性：新的Date Time API中的所有类都是不变的，并且适用于多线程环境。Separation of Concerns: The new API separates clearly between human readable date time and machine time (unix timestamp). It defines separate classes for Date, Time, DateTime, Timestamp, Timezone etc.关注点分离：新的API明确区分了人类可读的日期时间和机器时间（unix时间戳）。它为日期，时间，日期时间，时间戳，时区等定义了单独的类。Clarity: The methods are clearly defined and perform the same action in all the classes. For example, to get the current instance we havenow()method. There are format() and parse() methods defined in all these classes rather than having a separate class for them.

All the classes use Factory Pattern and Strategy Pattern for better handling. Once you have used the methods in one of the class, working with other classes won’t be hard.

清晰度：方法已明确定义，并在所有类中执行相同的操作。例如，要获取当前实例，我们具有now()方法。在所有这些类中定义了format（）和parse（）方法，而不是为它们提供单独的类。

所有的类都使用Factory Pattern和Strategy Pattern以获得更好的处理。一旦在一个类中使用了方法，与其他类一起工作就不会很困难。

Utility operations: All the new Date Time API classes comes with methods to perform common tasks, such as plus, minus, format, parsing, getting separate part in date/time etc.实用程序操作：所有新的Date Time API类都带有执行常见任务的方法，例如加号，减号，格式，解析，获取日期/时间中的单独部分等。Extendable: The new Date Time API works on ISO-8601 calendar system but we can use it with other non ISO calendars as well.可扩展：新的日期时间API可在ISO-8601日历系统上使用，但我们也可以将其与其他非ISO日历一起使用。

Java 8日期时间API软件包 (Java 8 Date Time API Packages)

Java 8 Date Time API consists of following packages.

Java 8日期时间API包含以下软件包。

java.time Package: This is the base package of new Java Date Time API. All the major base classes are part of this package, such asLocalDate,LocalTime,LocalDateTime,Instant,Period,Durationetc. All of these classes are immutable and thread safe. Most of the times, these classes will be sufficient for handling common requirements.java.time软件包：这是新的Java Date Time API的基本软件包。所有主要基类均是该程序包的一部分，例如LocalDate，LocalTime，LocalDateTime，Instant，Period，Duration等。所有这些类都是不可变的，并且是线程安全的。在大多数情况下，这些类足以应付常见要求。java.time.chrono Package: This package defines generic APIs for non ISO calendar systems. We can extendAbstractChronologyclass to create our own calendar system.java.time.chrono软件包：该软件包为非ISO日历系统定义了通用API。我们可以扩展AbstractChronology类来创建我们自己的日历系统。java.time.format Package: This package contains classes used for formatting and parsing date time objects. Most of the times, we would not be directly using them because principle classes in java.time package provide formatting and parsing methods.java.time.format软件包：该软件包包含用于格式化和解析日期时间对象的类。大多数时候，我们不会直接使用它们，因为java.time包中的主体类提供了格式化和解析方法。java.time.temporal Package: This package contains temporal objects and we can use it for find out specific date or time related to date/time object. For example, we can use these to find out the first or last day of the month. You can identify these methods easily because they always have format “withXXX”.java.time.temporal包：该包包含时态对象，我们可以使用它来查找与日期/时间对象相关的特定日期或时间。例如，我们可以使用这些来找出该月的第一天或最后一天。您可以轻松识别这些方法，因为它们始终使用“ withXXX”格式。java.time.zone Package: This package contains classes for supporting different time zones and their rules.java.time.zone软件包：该软件包包含用于支持不同时区及其规则的类。

Java 8日期时间API示例 (Java 8 Date Time API Examples)

We have looked into most of the important parts of Java Date Time API. It’s time now to look into most important classes of Date Time API with examples.

我们已经研究了Java Date Time API的大多数重要部分。现在是时候通过示例研究Date Time API的最重要类了。

本地日期 (LocalDate)

LocalDateis an immutable class that represents Date with default format of yyyy-MM-dd. We can usenow()method to get the current date. We can also provide input arguments for year, month and date to create LocalDate instance. This class provides overloaded method for now() where we can pass ZoneId for getting date in specific time zone. This class provides the same functionality asjava.sql.Date. Let’s look at a simple example for it’s usage.

package com.journaldev.java8.time;import java.time.LocalDate;import java.time.Month;import java.time.ZoneId;/*** LocalDate Examples* @author pankaj**/public class LocalDateExample {public static void main(String[] args) {//Current DateLocalDate today = LocalDate.now();System.out.println("Current Date="+today);//Creating LocalDate by providing input argumentsLocalDate firstDay_ = LocalDate.of(, Month.JANUARY, 1);System.out.println("Specific Date="+firstDay_);//Try creating date by providing invalid inputs//LocalDate feb29_ = LocalDate.of(, Month.FEBRUARY, 29);//Exception in thread "main" java.time.DateTimeException: //Invalid date 'February 29' as '' is not a leap year//Current date in "Asia/Kolkata", you can get it from ZoneId javadocLocalDate todayKolkata = LocalDate.now(ZoneId.of("Asia/Kolkata"));System.out.println("Current Date in IST="+todayKolkata);//java.time.zone.ZoneRulesException: Unknown time-zone ID: IST//LocalDate todayIST = LocalDate.now(ZoneId.of("IST"));//Getting date from the base date i.e 01/01/1970LocalDate dateFromBase = LocalDate.ofEpochDay(365);System.out.println("365th day from base date= "+dateFromBase);LocalDate hundredDay = LocalDate.ofYearDay(, 100);System.out.println("100th day of ="+hundredDay);}}

LocalDate methods explanation is provided in comments, when we run this program, we get following output.

LocalDate是一个不可变的类，它以默认格式yyyy-MM-dd表示Date。我们可以使用now()方法获取当前日期。我们还可以提供年份，月份和日期的输入参数来创建LocalDate实例。此类为now（）提供了重载的方法，其中我们可以传递ZoneId来获取特定时区中的日期。此类提供与java.sql.Date相同的功能。让我们看一个简单的用法示例。

注释中提供了LocalDate方法的说明，当我们运行该程序时，我们将得到以下输出。

当地时间 (LocalTime)

LocalTime is an immutable class whose instance represents a time in the human readable format. It’s default format is hh:mm:ss.zzz. Just like LocalDate, this class provides time zone support and creating instance by passing hour, minute and second as input arguments. Let’s look at it’s usage with a simple program.

package com.journaldev.java8.time;import java.time.LocalTime;import java.time.ZoneId;/*** LocalTime Examples* @author pankaj**/public class LocalTimeExample {public static void main(String[] args) {//Current TimeLocalTime time = LocalTime.now();System.out.println("Current Time="+time);//Creating LocalTime by providing input argumentsLocalTime specificTime = LocalTime.of(12,20,25,40);System.out.println("Specific Time of Day="+specificTime);//Try creating time by providing invalid inputs//LocalTime invalidTime = LocalTime.of(25,20);//Exception in thread "main" java.time.DateTimeException: //Invalid value for HourOfDay (valid values 0 - 23): 25//Current date in "Asia/Kolkata", you can get it from ZoneId javadocLocalTime timeKolkata = LocalTime.now(ZoneId.of("Asia/Kolkata"));System.out.println("Current Time in IST="+timeKolkata);//java.time.zone.ZoneRulesException: Unknown time-zone ID: IST//LocalTime todayIST = LocalTime.now(ZoneId.of("IST"));//Getting date from the base date i.e 01/01/1970LocalTime specificSecondTime = LocalTime.ofSecondOfDay(10000);System.out.println("10000th second time= "+specificSecondTime);}}

When we run above program for LocalTime examples, we get following output.

LocalTime是一个不可变的类，其实例以人类可读的格式表示时间。默认格式为hh：mm：ss.zzz。与LocalDate一样，此类提供时区支持并通过传递小时，分钟和秒作为输入参数来创建实例。让我们看一下它与一个简单程序的用法。

当我们为LocalTime示例运行上述程序时，将得到以下输出。

LocalDateTime (LocalDateTime)

LocalDateTimeis an immutable date-time object that represents a date-time, with default format as yyyy-MM-dd-HH-mm-ss.zzz. It provides a factory method that takesLocalDateandLocalTimeinput arguments to createLocalDateTimeinstance. Let’s look it’s usage with a simple example.

package com.journaldev.java8.time;import java.time.LocalDate;import java.time.LocalDateTime;import java.time.LocalTime;import java.time.Month;import java.time.ZoneId;import java.time.ZoneOffset;public class LocalDateTimeExample {public static void main(String[] args) {//Current DateLocalDateTime today = LocalDateTime.now();System.out.println("Current DateTime="+today);//Current Date using LocalDate and LocalTimetoday = LocalDateTime.of(LocalDate.now(), LocalTime.now());System.out.println("Current DateTime="+today);//Creating LocalDateTime by providing input argumentsLocalDateTime specificDate = LocalDateTime.of(, Month.JANUARY, 1, 10, 10, 30);System.out.println("Specific Date="+specificDate);//Try creating date by providing invalid inputs//LocalDateTime feb29_ = LocalDateTime.of(, Month.FEBRUARY, 28, 25,1,1);//Exception in thread "main" java.time.DateTimeException: //Invalid value for HourOfDay (valid values 0 - 23): 25//Current date in "Asia/Kolkata", you can get it from ZoneId javadocLocalDateTime todayKolkata = LocalDateTime.now(ZoneId.of("Asia/Kolkata"));System.out.println("Current Date in IST="+todayKolkata);//java.time.zone.ZoneRulesException: Unknown time-zone ID: IST//LocalDateTime todayIST = LocalDateTime.now(ZoneId.of("IST"));//Getting date from the base date i.e 01/01/1970LocalDateTime dateFromBase = LocalDateTime.ofEpochSecond(10000, 0, ZoneOffset.UTC);System.out.println("10000th second time from 01/01/1970= "+dateFromBase);}}

In all the three examples, we have seen that if we provide invalid arguments for creating Date/Time, then it throwsjava.time.DateTimeExceptionthat is a RuntimeException, so we don’t need to explicitly catch it.

We have also seen that we can get Date/Time data by passingZoneId, you can get the list of supported ZoneId values from it’s javadoc. When we run above class, we get following output.

LocalDateTime是一个不可变的日期时间对象，代表日期时间，默认格式为yyyy-MM-dd-HH-mm-ss.zzz。它提供了一个工厂方法，该方法使用LocalDate和LocalTime输入参数来创建LocalDateTime实例。让我们用一个简单的例子来看看它的用法。

在所有三个示例中，我们已经看到，如果提供创建日期/时间的无效参数，则它将抛出java.time.DateTimeException，这是RuntimeException，因此我们不需要显式捕获它。

我们还看到，可以通过传递ZoneId来获取日期/时间数据，您可以从其javadoc中获取受支持的ZoneId值的列表。当我们在类上运行时，将得到以下输出。

瞬间 (Instant)

Instant class is used to work with machine readable time format, it stores date time in unix timestamp. Let’s see it’s usage with a simple program.

package com.journaldev.java8.time;import java.time.Duration;import java.time.Instant;public class InstantExample {public static void main(String[] args) {//Current timestampInstant timestamp = Instant.now();System.out.println("Current Timestamp = "+timestamp);//Instant from timestampInstant specificTime = Instant.ofEpochMilli(timestamp.toEpochMilli());System.out.println("Specific Time = "+specificTime);//Duration exampleDuration thirtyDay = Duration.ofDays(30);System.out.println(thirtyDay);}}

Output of above program is:

Instant类用于以机器可读的时间格式工作，它将日期时间存储在unix时间戳中。让我们看看它在一个简单程序中的用法。

上面程序的输出是：

Java 8 Date API实用程序 (Java 8 Date API Utilities)

As mentioned earlier, most of the Date Time principle classes provide various utility methods such as plus/minus days, weeks, months etc. There are some other utility methods for adjusting the date usingTemporalAdjusterand to calculate the period between two dates.

package com.journaldev.java8.time;import java.time.LocalDate;import java.time.LocalTime;import java.time.Period;import java.time.temporal.TemporalAdjusters;public class DateAPIUtilities {public static void main(String[] args) {LocalDate today = LocalDate.now();//Get the Year, check if it's leap yearSystem.out.println("Year "+today.getYear()+" is Leap Year? "+today.isLeapYear());//Compare two LocalDate for before and afterSystem.out.println("Today is before 01/01/? "+today.isBefore(LocalDate.of(,1,1)));//Create LocalDateTime from LocalDateSystem.out.println("Current Time="+today.atTime(LocalTime.now()));//plus and minus operationsSystem.out.println("10 days after today will be "+today.plusDays(10));System.out.println("3 weeks after today will be "+today.plusWeeks(3));System.out.println("20 months after today will be "+today.plusMonths(20));System.out.println("10 days before today will be "+today.minusDays(10));System.out.println("3 weeks before today will be "+today.minusWeeks(3));System.out.println("20 months before today will be "+today.minusMonths(20));//Temporal adjusters for adjusting the datesSystem.out.println("First date of this month= "+today.with(TemporalAdjusters.firstDayOfMonth()));LocalDate lastDayOfYear = today.with(TemporalAdjusters.lastDayOfYear());System.out.println("Last date of this year= "+lastDayOfYear);Period period = today.until(lastDayOfYear);System.out.println("Period Format= "+period);System.out.println("Months remaining in the year= "+period.getMonths());}}

Output of above program is:

如前所述，大多数“日期时间”原理类提供了各种实用方法，例如加/减日，周，月等。还有一些其他实用方法可使用TemporalAdjuster调整日期并计算两个日期之间的时间间隔。

上面程序的输出是：

Java 8日期解析和格式化 (Java 8 Date Parsing and Formatting)

It’s very common to format date into different formats and then parse a String to get the Date Time objects. Let’s see it with simple examples.

package com.journaldev.java8.time;import java.time.Instant;import java.time.LocalDate;import java.time.LocalDateTime;import java.time.format.DateTimeFormatter;public class DateParseFormatExample {public static void main(String[] args) {//Format examplesLocalDate date = LocalDate.now();//default formatSystem.out.println("Default format of LocalDate="+date);//specific formatSystem.out.println(date.format(DateTimeFormatter.ofPattern("d::MMM::uuuu")));System.out.println(date.format(DateTimeFormatter.BASIC_ISO_DATE));LocalDateTime dateTime = LocalDateTime.now();//default formatSystem.out.println("Default format of LocalDateTime="+dateTime);//specific formatSystem.out.println(dateTime.format(DateTimeFormatter.ofPattern("d::MMM::uuuu HH::mm::ss")));System.out.println(dateTime.format(DateTimeFormatter.BASIC_ISO_DATE));Instant timestamp = Instant.now();//default formatSystem.out.println("Default format of Instant="+timestamp);//Parse examplesLocalDateTime dt = LocalDateTime.parse("27::Apr:: 21::39::48",DateTimeFormatter.ofPattern("d::MMM::uuuu HH::mm::ss"));System.out.println("Default format after parsing = "+dt);}}

When we run above program, we get following output.

将日期格式化为不同的格式，然后解析一个字符串以获取日期时间对象是很常见的。让我们用简单的例子看一下。

当我们运行上面的程序时，我们得到以下输出。

Java 8 Date API旧版日期时间支持 (Java 8 Date API Legacy Date Time Support)

Legacy Date/Time classes are used in almost all the applications, so having backward compatibility is a must. That’s why there are several utility methods through which we can convert Legacy classes to new classes and vice versa. Let’s see this with a simple example.

package com.journaldev.java8.time;import java.time.Instant;import java.time.LocalDateTime;import java.time.ZoneId;import java.time.ZonedDateTime;import java.util.Calendar;import java.util.Date;import java.util.GregorianCalendar;import java.util.TimeZone;public class DateAPILegacySupport {public static void main(String[] args) {//Date to InstantInstant timestamp = new Date().toInstant();//Now we can convert Instant to LocalDateTime or other similar classesLocalDateTime date = LocalDateTime.ofInstant(timestamp, ZoneId.of(ZoneId.SHORT_IDS.get("PST")));System.out.println("Date = "+date);//Calendar to InstantInstant time = Calendar.getInstance().toInstant();System.out.println(time);//TimeZone to ZoneIdZoneId defaultZone = TimeZone.getDefault().toZoneId();System.out.println(defaultZone);//ZonedDateTime from specific CalendarZonedDateTime gregorianCalendarDateTime = new GregorianCalendar().toZonedDateTime();System.out.println(gregorianCalendarDateTime);//Date API to Legacy classesDate dt = Date.from(Instant.now());System.out.println(dt);TimeZone tz = TimeZone.getTimeZone(defaultZone);System.out.println(tz);GregorianCalendar gc = GregorianCalendar.from(gregorianCalendarDateTime);System.out.println(gc);}}

When we run above application, we get following output.

As you can see that legacyTimeZoneandGregorianCalendarclasses toString() methods are too verbose and not user friendly.

传统日期/时间类几乎用于所有应用程序中，因此必须具有向后兼容性。这就是为什么有几种实用程序方法可用来将Legacy类转换为新类，反之亦然的原因。让我们用一个简单的例子来看一下。

当我们在应用程序之上运行时，我们得到以下输出。

如您所见，传统的TimeZone和GregorianCalendar类的toString（）方法过于冗长且不友好。

That’s all for Java 8 Date Time API, I like this new API a lot. Some of the most used classes will be LocalDate and LocalDateTime for this new API. It’s very easy to work with and having similar methods that does a particular job makes it easy to find. It will take some time from moving legacy classes to new Date Time classes, but I believe it will be worthy of the time.

Java 8 Date Time API就是这样，我非常喜欢这个新API。一些最常用的类是此新API的LocalDate和LocalDateTime。使用起来非常容易，并且具有执行特定工作的类似方法可以很容易地找到它。从传统类到新的日期时间类需要花费一些时间，但我相信这是值得的。

GitHub Repository.GitHub Repository下载所有示例代码。