«Back to Home

Core Java
Topics

New Date And Time API

A new Date-Time API is introduced to cover the drawbacks of old date-time API like
  • java.util.Date is not thread safe. Thus, concurrency issue arises, while using the date but the new date-time API is immutable and does not have setter methods.

  • Old API had less direct methods for the date operations but new API provides various utility methods for such operations.

  • We need to write a lot of code to deal with timezone issues but the new API has been developed keeping domain-specific design in mind.
A new date-time API is under the package java.time. There are some important classes, introduced in java.time package.
  • Local − Simplify date-time API with no complexity of timezone handling.

  • Zoned − Specialize date-time API to deal with different timezones.
Local Data-Time API

LocalDate/LocalTime class and LocalDateTime class make the development simple, where the timezones are not required.
 
Let’s see an example of Local Data-Time, given below.
 
Code
  1. import java.time.LocalDate;  
  2. import java.time.LocalTime;  
  3. import java.time.LocalDateTime;  
  4. import java.time.Month;  
  5. public class LocalDateTimeExample {  
  6.     public static void main(String args[]) {  
  7.         LocalDateTimeExample dt = new LocalDateTimeExample();  
  8.         dt.testLocalDateTime();  
  9.     }  
  10.     public void testLocalDateTime() {  
  11.         LocalDateTime cTime = LocalDateTime.now();  
  12.         System.out.println("Current DateTime: " + cTime);  
  13.         LocalDate date1 = cTime.toLocalDate();  
  14.         System.out.println("date1: " + date1);  
  15.         Month month = cTime.getMonth();  
  16.         int day = cTime.getDayOfMonth();  
  17.         int seconds = cTime.getSecond();  
  18.         System.out.println("Month: " + month + "day: " + day + "seconds: " + seconds);  
  19.         LocalDateTime date2 = cTime.withDayOfMonth(10).withYear(2016);  
  20.         System.out.println("date2: " + date2);  
  21.         LocalDate date3 = LocalDate.of(2016, Month.DECEMBER, 5);  
  22.         System.out.println("date3: " + date3);  
  23.     }  
  24. }  
1

Output

2

Zoned Date-Time API

Zoned date-time API is used, if time zone is to be considered.
 
Let’s see an example of Zoned date-time, given below.
 
Code
  1. import java.time.ZonedDateTime;  
  2. import java.time.ZoneId;  
  3. public class ZonedDateTimeExample {  
  4.     public static void main(String args[]) {  
  5.         ZonedDateTimeExample dt = new ZonedDateTimeExample();  
  6.         dt.testZonedDateTime();  
  7.     }  
  8.     public void testZonedDateTime() {  
  9.         ZonedDateTime d1 = ZonedDateTime.parse("2016-11-03T10:15:30+05:30[Asia/Karachi]");  
  10.         System.out.println("date1: " + d1);  
  11.         ZoneId id = ZoneId.of("Europe/Paris");  
  12.         System.out.println("ZoneId: " + id);  
  13.         ZoneId cZone = ZoneId.systemDefault();  
  14.         System.out.println("CurrentZone: " + cZone);  
  15.     }  
  16. }  
3

Output

4

Chrono Units Enum

java.time.temporal.ChronoUnit enum added new to replace the integer values, used in old API to represent day, month, etc.
 
Let’s see an example of Chrono Units Enum, given below.
 
Code
  1. import java.time.LocalDate;  
  2. import java.time.temporal.ChronoUnit;  
  3. public class ChronoUnitExample {  
  4.     public static void main(String args[]) {  
  5.         ChronoUnitExample cu = new ChronoUnitExample();  
  6.         cu.testChromoUnits();  
  7.     }  
  8.     public void testChromoUnits() {  
  9.         LocalDate today = LocalDate.now();  
  10.         System.out.println("Today : " + today);  
  11.         LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS);  
  12.         System.out.println("Next week: " + nextWeek);  
  13.         LocalDate nextMonth = today.plus(1, ChronoUnit.MONTHS);  
  14.         System.out.println("Next month: " + nextMonth);  
  15.     }  
  16. }  
5

Output

6

Period & Duration

In Java 8, two classes are dealt with the time differences.
 
Period – This class deals with date base and time.
 
Duration − This class deal with time base and amount of time.
 
Let’s see an example, given below.
 
Code
  1. import java.time.temporal.ChronoUnit;  
  2. import java.time.LocalDate;  
  3. import java.time.LocalTime;  
  4. import java.time.Duration;  
  5. import java.time.Period;  
  6.   
  7. public class PeriodDurationExample {  
  8.     public static void main(String args[]) {  
  9.         PeriodDurationExample pd = new PeriodDurationExample();  
  10.         pd.testPeriod();  
  11.         pd.testDuration();  
  12.     }  
  13.     public void testPeriod() {  
  14.         LocalDate d1 = LocalDate.now();  
  15.         System.out.println("Current date: " + d1);  
  16.         LocalDate d2 = d1.plus(1, ChronoUnit.YEARS);  
  17.         System.out.println("Next Year: " + d2);  
  18.         Period period = Period.between(d2, d1);  
  19.         System.out.println("Period: " + period);  
  20.     }  
  21.     public void testDuration() {  
  22.         LocalTime t1 = LocalTime.now();  
  23.         Duration fourHours = Duration.ofHours(4);  
  24.         LocalTime t2 = t1.plus(fourHours);  
  25.         Duration d = Duration.between(t1, t2);  
  26.         System.out.println("Duration: " + d);  
  27.     }  
  28. }  
7

Output

8

Temporal Adjusters

Temporal Adjuster performs the date mathematics.
 
For example, get the "Third Monday of the Month" or "Next Friday".
 
Let’s see an example of Temporal Adjuster, given below.
 
Code
  1. import java.time.LocalDate;  
  2. import java.time.temporal.TemporalAdjusters;  
  3. import java.time.DayOfWeek;  
  4.   
  5. public class TemporalAdjustersExample {  
  6.     public static void main(String args[]) {  
  7.         TemporalAdjustersExample ta = new TemporalAdjustersExample();  
  8.         ta.testAdjusters();  
  9.     }  
  10.     public void testAdjusters() {  
  11.         LocalDate d1 = LocalDate.now();  
  12.         System.out.println("Current date: " + d1);  
  13.         LocalDate nextFri = d1.with(TemporalAdjusters.next(DayOfWeek.FRIDAY));  
  14.         System.out.println("Next Friday on : " + nextFri);  
  15.         LocalDate firstInYear = LocalDate.of(d1.getYear(), d1.getMonth(), 1);  
  16.         LocalDate secondSun = firstInYear.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY)).with(TemporalAdjusters.next(DayOfWeek.SUNDAY));  
  17.         System.out.println("Second Sunday on : " + secondSun);  
  18.     }  
  19. }  
9
 
Output

10

Backward Compatibility

A toInstant() method is used to add to the original date and calendar objects, which can be used to convert them to the new Date-Time API and ofInstant(Insant,ZoneId) method is used to get a LocalDateTime or ZonedDateTime object.
 
Let’s see an example of backward compatibility, given below.
 
Code
  1. import java.time.LocalDateTime;  
  2. import java.time.ZonedDateTime;  
  3. import java.util.Date;  
  4. import java.time.Instant;  
  5. import java.time.ZoneId;  
  6. public class BackwardCompatibilityExample {  
  7.     public static void main(String args[]) {  
  8.         BackwardCompatibilityExample bc = new BackwardCompatibilityExample();  
  9.         bc.testBackwardCompatability();  
  10.     }  
  11.     public void testBackwardCompatability() {  
  12.         Date today = new Date();  
  13.         System.out.println("Today: " + today);  
  14.         Instant i = today.toInstant();  
  15.         ZoneId currentZone = ZoneId.systemDefault();  
  16.         LocalDateTime local = LocalDateTime.ofInstant(i, currentZone);  
  17.         System.out.println("Local date: " + local);  
  18.         ZonedDateTime zoned = ZonedDateTime.ofInstant(i, currentZone);  
  19.         System.out.println("Zoned date: " + zoned);  
  20.     }  
  21. }  
11

Output

12

Summary

Thus, we learnt that a new Date-Time API is introduced to cover the drawbacks of old date-time API and also learnt how to use it in Java.