Shulou(Shulou.com)06/02 Report--

What is the Java8 date / time API Guide? I believe many inexperienced people don't know what to do about it. Therefore, this article summarizes the causes and solutions of the problem. Through this article, I hope you can solve this problem.

Java 8 date / time (Date/Time) API is one of the most sought after changes for developers. Java doesn't have a consistent approach to date and time from the start, so date / time API is another popular item in addition to Java's core API.

Why do we need a new Java date / time API?

Before we start looking at Java 8 date / time API, let's take a look at why we need such a new API. There are many problems with existing date and time related classes in Java, including:

The definition of the date / time class for Java is inconsistent, there are date classes in both java.util and java.sql packages, and the classes used for formatting and parsing are defined in the java.text package.

Java.util.Date contains both date and time, while java.sql.Date contains only date, so it doesn't make sense to include it in the java.sql package. In addition, both classes have the same name, which in itself is a very bad design.

There are no clearly defined classes for time, timestamp, formatting, and parsing. For formatting and parsing requirements, we have java.text.DateFormat abstract classes, but typically, SimpleDateFormat classes are used for such requirements.

All date classes are mutable, so they are not thread-safe, which is one of the problems with Java date classes.

Date classes do not provide internationalization and no time zone support, so Java introduces java.util.Calendar and java.util.TimeZone classes, but they also have all the above problems.

There are other problems with the methods defined in existing date and calendar classes, but the above problems have made it clear that Java needs a robust date / time class. This is why Joda Time plays an important role in high-quality replacement in Java date / time requirements.

Java 8 date / time API

Java 8 date / time API is an implementation of JSR-310, and its implementation goal is to overcome all the shortcomings in the old date / time implementation. Some of the design principles of the new date / time API are:

Immutability: in the new date / time API, all classes are immutable, which is good for multithreaded environments.

Separation of concerns: the new API clearly separates human-readable date time from machine time (unix timestamp), defining different classes for date (Date), time (Time), date time (DateTime), time stamp (unix timestamp), and time zone.

Clarity: in all classes, methods are clearly defined to perform the same behavior. For example, to get the current instance, we can use the now () method, with format () and parse () methods defined in all classes, instead of having a separate class as before. To better handle the problem, all classes use factory and policy patterns, and once you use the methods of one of these classes, it is not difficult to work with other classes.

Utility: all new date / time API classes implement a series of methods to accomplish common tasks, such as addition, subtraction, formatting, parsing, extracting separate parts from date / time, and so on.

Extensibility: the new date / time API works on the ISO-8601 calendar system, but we can also apply it to non-IOS calendars.

Java date / time API package

Java date / time API contains the following corresponding packages.

Java.time package: this is the base package for the new Java date / time API. All the major basic classes are part of this package, such as: LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration, etc. All of these classes are immutable and thread-safe, and in the vast majority of cases, they can effectively handle some common requirements.

Java.time.chrono package: this package defines some generalized API for non-ISO calendar systems, and we can extend the AbstractChronology class to create our own calendar system.

Java.time.format package: this package contains classes that can format and parse date-time objects, and in most cases we should not use them directly, because the corresponding classes in the java.time package already provide methods for formatting and parsing.

Java.time.temporal package: this package contains temporal objects that we can use to find out a specific date or time about the date / time object, for example, the * day or day of a month. You can easily recognize these methods because they all have a "withXXX" format.

Java.time.zone package: this package contains classes that support different time zones and related rules.

Java date / time API example

Now that we've gone through most of the important parts of the Java date / time API, it's time to take a closer look at some of the most important classes based on the examples.

1. Java.time.LocalDate:LocalDate is an immutable class that represents the date in the default format (yyyy-MM-dd). We can use the now () method to get the current time, or we can provide input parameters for the year, month, and date to create a LocalDate instance. This class provides an overloaded method for the now () method, and we can pass in ZoneId to get the date of the specified time zone. This class provides the same functionality as java.sql.Date, and let's look at a simple example of how to use this class.

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 Date LocalDate today = LocalDate.now (); System.out.println ("Current Date=" + today) / / Creating LocalDate by providing input arguments LocalDate firstDay_2014 = LocalDate.of (2014, Month.JANUARY, 1); System.out.println ("Specific Date=" + firstDay_2014); / / Try creating date by providing invalid inputs / / LocalDate feb29_2014 = LocalDate.of (2014, Month.FEBRUARY, 29) / / Exception in thread "main" java.time.DateTimeException: / / Invalid date 'February 29' as' 2014'is not a leap year / / Current date in "Asia/Kolkata", you can get it from ZoneId javadoc LocalDate 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 01and1970 LocalDate dateFromBase = LocalDate.ofEpochDay; System.out.println ("365th day from base date=" + dateFromBase); LocalDate hundredDay2014 = LocalDate.ofYearDay (2014) System.out.println ("100th day of 2014 =" + hundredDay2014);}}

The detailed explanation of the sample method is included in the comments, and when we run the program, we get the following output:

Current Date=2014-04-28 Specific Date=2014-01-01 Current Date in IST=2014-04-29 365th day from base date= 1971-01-01 100th day of 2014-04-10

2. Java.time.LocalTime:LocalTime is an immutable class, and its instance represents a time that conforms to the human-readable format, which is hh:mm:ss.zzz by default. Like LocalDate, this class also provides time zone support, and you can also pass in input parameters such as hours, minutes, and seconds to create instances. Let's take a look at a simple program to demonstrate how to use this class.

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 Time LocalTime time = LocalTime.now (); System.out.println ("Current Time=" + time); / / Creating LocalTime by providing input arguments LocalTime specificTime = LocalTime.of System.out.println ("Specific Time of Day=" + specificTime); / / Try creating time by providing invalid inputs / / LocalTime invalidTime = LocalTime.of (25penny 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 javadoc LocalTime 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 01and1970 LocalTime specificSecondTime = LocalTime.ofSecondOfDay (10000); System.out.println ("10000th second time=" + specificSecondTime);}}

When you run the above program, you can see the following output.

Current Time=15:51:45.240 Specific Time of Day=12:20:25.000000040 Current Time in IST=04:21:45.276 10000th second time= 02:46:40

3. Java.time.LocalDateTime:LocalDateTime is an immutable date-time object that represents a set of dates-times. The default format is yyyy-MM-dd-HH-mm-ss.zzz. It provides a factory method that receives LocalDate and LocalTime input parameters and creates an LocalDateTime instance. Let's look at 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 Date LocalDateTime today = LocalDateTime.now (); System.out.println ("Current DateTime=" + today) / / Current Date using LocalDate and LocalTime today = LocalDateTime.of (LocalDate.now (), LocalTime.now ()); System.out.println ("Current DateTime=" + today); / / Creating LocalDateTime by providing input arguments LocalDateTime specificDate = LocalDateTime.of (2014, Month.JANUARY, 1,10,10,30); System.out.println ("Specific Date=" + specificDate) / / Try creating date by providing invalid inputs / / LocalDateTime feb29_2014 = LocalDateTime.of (2014, Month.FEBRUARY, 28,25); / / 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 javadoc LocalDateTime 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 LocalDateTime dateFromBase 1970 LocalDateTime dateFromBase = LocalDateTime.ofEpochSecond (1970, 0, ZoneOffset.UTC); System.out.println ("10000th second time from 01 LocalDateTime.ofEpochSecond 1970 =" + dateFromBase) }}

In all three examples, we have seen that if we provide invalid parameters to create the date / time, then the system throws a java.time.DateTimeException, which is a run-time exception that we do not need to catch explicitly.

We also see that you can get date / time data by passing ZoneId, and you can get a list of supported Zoneid from its Javadoc. When you run the above class, you can get the following output.

Current DateTime=2014-04-28T16:00:49.455 Current DateTime=2014-04-28T16:00:49.493 Specific Date=2014-01-01T10:10:30 Current Date in IST=2014-04-29T04:30:49.493 10000th second time from 01 28T16:00:49.493 Specific Date=2014 1970 = 1970-01-01T02:46:40

4. The java.time.Instant:Instant class is used in a machine-readable time format. It stores date and time in the form of Unix timestamps. Let's look at 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 timestamp Instant timestamp = Instant.now (); System.out.println ("Current Timestamp =" + timestamp); / / Instant from timestamp Instant specificTime = Instant.ofEpochMilli (timestamp.toEpochMilli ()); System.out.println ("Specific Time =" + specificTime) / / Duration example Duration thirtyDay = Duration.ofDays (30); System.out.println (thirtyDay);}} the output of the above program is: Current Timestamp = 2014-04-28T23:20:08.489Z Specific Time = 2014-04-28T23:20:08.489Z PT720H

5. Date API tool: as we mentioned earlier, most date / time API classes implement a series of tool methods, such as days plus / minus, weeks, months, and so on. There are other tool methods that can use TemporalAdjuster to adjust the date and calculate the period between two days.

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 year System.out.println ("Year" + today.getYear () + "isLeapYear?" + today.isLeapYear ()) / / Compare two LocalDate for before and after System.out.println ("Today is before 01 days after today will be 2015?" + today.isBefore (LocalDate.of (2015); / / Create LocalDateTime from LocalDate System.out.println ("Current Time=" + today.atTime (LocalTime.now (); / / plus and minus operations System.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 dates System.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 ());}

The output of the above program is:

Year 2014 is Leap Year? False Today is before 01/01/2015? True Current Time=2014-04-28T16:23:53.154 10 days after today will be 2014-05-08 3 weeks after today will be 2014-05-19 20 months after today will be 2015-12-28 10 days before today will be 2014-04-18 3 weeks before today will be 2014-04-07 20 months before today will be 2012-08-28 First date of this month= 2014-04-01 Last date of this year= 2014-12-31 Period Format= P8M3D Months remaining in the year= 8

6. Parsing and formatting: it is common to convert a date format to a different format, and then parse a string to get a date-time object. Let's take a look at a simple example.

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 examples LocalDate date = LocalDate.now (); / / default format System.out.println ("Default format of LocalDate=" + date) / / specific format System.out.println (date.format (DateTimeFormatter.ofPattern ("d::MMM::uuuu"); System.out.println (date.format (DateTimeFormatter.BASIC_ISO_DATE)); LocalDateTime dateTime = LocalDateTime.now (); / / default format System.out.println ("Default format of LocalDateTime=" + dateTime) / / specific format System.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 format System.out.println ("Default format of Instant=" + timestamp) / / Parse examples LocalDateTime dt = LocalDateTime.parse ("27::Apr::2014 21 DateTimeFormatter.ofPattern 39 d::MMM::uuuu HH::mm::ss 48", DateTimeFormatter.ofPattern ("d::MMM::uuuu HH::mm::ss")); System.out.println ("Default format after parsing =" + dt);}}

When you run the above program, you can see the following output.

7. Old date-time support: old date / time classes are already used in almost all applications, so backward compatibility is necessary. This is why there are several tool methods that help us convert old classes into new ones, and vice versa. Let's take a look at 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 toInstant Instant timestamp = new Date () .toInstant () / / Now we can convert Instant to LocalDateTime or other similar classes LocalDateTime date = LocalDateTime.ofInstant (timestamp, ZoneId.of (ZoneId.SHORT_IDS.get ("PST")); System.out.println ("Date =" + date); / / Calendar toInstant Instant time = Calendar.getInstance () .toInstant (); System.out.println (time) / / TimeZone toZoneId ZoneId defaultZone = TimeZone.getDefault () .toZoneId (); System.out.println (defaultZone); / / ZonedDateTime from specific Calendar ZonedDateTime gregorianCalendarDateTime = new GregorianCalendar () .toZonedDateTime (); System.out.println (gregorianCalendarDateTime); / / Date API to Legacy classes Date 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 you run the above program, you can see the following output.

Date = 2014-04-28T16:28:54.340 2014-04-28T23:28:54.395Z America/Los_Angeles 2014-04-28T16:28:54.404-07:00 [America/Los_Angeles] Mon Apr 28 16:28:54 PDT 2014 sun.util.calendar.ZoneInfo [id= "America/Los_Angeles", offset=-28800000,dstSavings=3600000,useDaylight=true,transitions=185,lastRule= java.util.SimpleTimeZone [id = America/Los_Angeles,offset=-28800000,dstSavings=3600000,useDaylight=true,startYear=0,startMode=3,startMonth=2,startDay=8,startDayOfWeek=1,startTime=7200000,startTimeMode=0,endMode=3,endMonth=10,endDay=1,endDayOfWeek=1,endTime=7200000 EndTimeMode=0]] java.util.GregorianCalendar [time=1398727734404,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo [id= "America/Los_Angeles", offset=-28800000,dstSavings=3600000,useDaylight=true,transitions=185,lastRule= java.util.SimpleTimeZone [id = America/Los_Angeles,offset=-28800000,dstSavings=3600000,useDaylight=true,startYear=0,startMode=3,startMonth=2,startDay=8,startDayOfWeek=1,startTime=7200000,startTimeMode=0,endMode=3,endMonth=10,endDay=1,endDayOfWeek=1,endTime=7200000,endTimeMode=0]], firstDayOfWeek=2,minimalDaysInFirstWeek=4,ERA=1,YEAR=2014,MONTH=3,WEEK_OF_YEAR=18,WEEK_OF_MONTH=5,DAY_OF_MONTH=28,DAY_OF_YEAR=118,DAY_OF_WEEK=2 DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=4,HOUR_OF_DAY=16,MINUTE=28,SECOND=54,MILLISECOND=404,ZONE_OFFSET=-28800000,DST_OFFSET=3600000]

As you can see, the toString () method of the old TimeZone and GregorianCalendar classes is too verbose and not friendly at all.

This is what all the Java 8 date / time API is all about. I like this API very much, it's easy to use, and it takes some work to make similar methods easy to find, although it takes some time to move from the old class to the new date-time class, but I believe it's worth it.

After reading the above, have you mastered what the Java8 date / time API guide is? If you want to learn more skills or want to know more about it, you are welcome to follow the industry information channel, thank you for reading!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.