Date And Time In Java – Importance, Local, Current, and Formatting

What is Java Date and Time

The Java Date and Time is a representation of date (year, month, and day (yyyy-MM-dd)).

LocalTime represents a time (hour, minute, second, and nanosecond (HH-mm-ss-ns)).

LocalDateTime is the Date and time that are both shown (yyyy-MM-dd-HH-mm-ss-ns).

Importance of Date and Time in Java

The Date and Time in Java are very important in our lives and are used in every piece of technology in this world.

It is a very important and critical factor in transaction systems, where a single millisecond can cause a change in the system.

Local Date and Time in Java

In Java, the LocalDateTime class is an immutable date-time object that represents a date in the format yyyy-MM-dd-HH-mm-ss. zzz format.

It uses the object class and the ChronoLocalDateTime interface.

We can use LocalDateTime instances whenever we need to show time without a reference to a time zone.

What is the Type of Date in Java

The Date in Java is not only a data types, like int or float, but also a class.

This means it has its own methods it can use.

A Date in Java also has the time, the year, the name of the day of the week, and the time zone.

One of its methods involves getting the time from the Date object.

Without further ado, I will further explain How to Set Date and Time in Java with some basic examples in order for you to easily understand the topic.

Date In Java

A Date In Java is a class that can be found in the java.util package.

This class holds the current date and time.

The Date Class In Java has two constructors, which are listed in the table below.

The methods of the Date Class In Java are listed in the table below.

How to Get Current Date and Time in Java

This is a very simple way in Java to Get The Current Date And Time In Java.

You can print the current date and time with a simple Date object and the toString() method.

Example Java Program To Get Current Date And Time

// program by Glenn Magada Azuelo
import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date using toString()
      System.out.println(date.toString());
   }
}

Output:

Thu Jul 07 02:23:42 GMT 2022

In order for you to test the Java code provided in this lesson, you must test the code in your code editor.

You can test the above example here! ➡Java Online Compiler 

Date Comparison In Java

Here are three ways you can compare two dates in Java.

• You can use getTime() to find out how many milliseconds have passed since midnight on January 1, 1970, for both objects and then compare these two values.

• The before(), after(), and equals methods can be used ( ). Because, for example, the 12th of the month is before the 18th, the new Date (99, 2, 12). before(new Date (99, 2, 18)) returns true.

• You can use the compareTo() method, which is defined by the Comparable interface and is implemented by Date.

Date Formatting Using SimpleDateFormat In Java

The SimpleDateFormat in Java is a concrete class for formatting and parsing dates based on the user’s location.

SimpleDateFormat lets you start by choosing any user-defined pattern for formatting date and time.

Example Java Program In Date Formatting Using SimpleDateFormat

// program by Glenn Magada Azuelo
import java.util.*;
import java.text.*;

public class DateDemo {

   public static void main(String args[]) {
      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

      System.out.println("Current Date: " + ft.format(dNow));
   }
}

Output:

Current Date: Thu 2022.07.07 at 02:44:57 AM GMT

You can test the above example here! ➡Java Online Compiler 

SimpleDateFormat Codes In Java

Use a time pattern string to specify the time format. In this pattern, all ASCII characters are set aside as pattern letters, which are defined as follows:

Date and Time Formatting using Printf in Java

Using the printf method, it’s easy to format the date and time.

As shown in the code below, you can use a two-letter format that starts with t and ends with one of the letters of the table.

Example Program in Date and Time Formatting using Printf

// program by Glenn Magada Azuelo
import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date
      String timeDate = String.format("Current Date/Time : %tc", date );

      System.out.printf(timeDate);
   }
}

Output:

Current Date/Time : Thu Jul 07 02:57:20 GMT 2022

You can test the above example here! ➡Java Online Compiler 

It would be silly to have to put the date in more than once to format each part.

Because of this, a format string can show the index of the argument that needs to be formatted.

The index has to come right after the percent, and it has to end with a $.

Example:

// program created by Glenn Magada Azuelo
import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display time and date
      System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date);
   }
}

Output:

Due date: July 07, 2022

You can test the above example here! ➡Java Online Compiler 

Alternately, you can use the < flag. It means that the same argument as in the previous format specification should be used again.

Example:

// program by Glenn Magada Azuelo
import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display formatted date
      System.out.printf("%s %tB %<te, %<tY", "Due date:", date);
   }
}

Output:

Due date: July 7, 2022

You can test the above example here! ➡Java Online Compiler 

Date and Time Conversion Characters in Java

Here are the characters for converting date-time.

There are other useful Date and time classes. Refer to the Java Standard documentation for more information.

Parsing Strings into Dates in Java

The SimpleDateFormat class has some extra methods, such as the parse() method, which tries to parse a string using the format stored in the given SimpleDateFormat object.

Example Java Program using Parse() Method into Dates

// program by Glenn Magada Azuelo
import java.util.*;
import java.text.*;
  
public class DateDemo {

   public static void main(String args[]) {
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd"); 
      String input = args.length == 0 ? "1818-11-11" : args[0]; 

      System.out.print(input + " Parses as "); 
      Date t;
      try {
         t = ft.parse(input); 
         System.out.println(t); 
      } catch (ParseException e) { 
         System.out.println("Unparseable using " + ft); 
      }
   }
}

Output:

1818-11-11 Parses as Wed Nov 11 00:00:00 GMT 1818

You can test the above example here! ➡Java Online Compiler 

Sleeping For a While in Java

You can sleep for a while in Java for as little as one millisecond or as long as your computer lasts.

For instance, the following code would put the computer to sleep for 3 seconds.

Sleeping For a While in Java Example Program

// program by Glenn Magada Azuelo
import java.util.*;
public class SleepDemo {

   public static void main(String args[]) {
      try { 
         System.out.println(new Date( ) + "\n"); 
         Thread.sleep(5*60*10); 
         System.out.println(new Date( ) + "\n"); 
      } catch (Exception e) {
         System.out.println("Got an exception!"); 
      }
   }
}

Output:

Thu Jul 07 07:10:53 GMT 2022 Thu Jul 07 07:10:56 GMT 2022

You can test the above example here! ➡Java Online Compiler 

Measuring Elapsed Time In Java

In Java, we use the System.time() method to figure out how long an operation took in seconds. method called currentTimeMillis().

So let’s rewrite the example from above.

// program by Glenn Magada Azuelo
import java.util.*;
public class DiffDemo {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\n");
         
         Thread.sleep(5*60*10);
         System.out.println(new Date( ) + "\n");
         
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}

Output:

Thu Jul 07 07:22:36 GMT 2022
Thu Jul 07 07:22:39 GMT 2022
Difference is : 3060

GregorianCalendar in Java

GregorianCalendar In Java is a hybrid calendar that works with both the Julian and Gregorian calendars.

It only has one break, which is set to the date when the Gregorian calendar started to be used.

The java. util.

The Calendar class’s getInstance() method gives back a GregorianCalendar with the current date and time in the default locale and time zone.

AD and BC are the two parts of the Gregorian calendar. Based on the Gregorian calendar, these are the two times.

GregorianCalendar objects also have a number of ways to make them.

Here is a list of a few useful support methods that the GregorianCalendar Class In Java.

GregorianCalendar in Java Example Program

//program by Glenn Magada Azuelo
import java.util.*;
public class GregorianCalendarDemo {

   public static void main(String args[]) {
      String months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", 
         "Oct", "Nov", "Dec"};
      
      int year;
      // Create a Gregorian calendar initialized
      // with the current date and time in the
      // default locale and timezone.
      
      GregorianCalendar gcalendar = new GregorianCalendar();
      
      // Display current time and date information.
      System.out.print("Date: ");
      System.out.print(months[gcalendar.get(Calendar.MONTH)]);
      System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
      System.out.println(year = gcalendar.get(Calendar.YEAR));
      System.out.print("Time: ");
      System.out.print(gcalendar.get(Calendar.HOUR) + ":");
      System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
      System.out.println(gcalendar.get(Calendar.SECOND));

      // Test if the current year is a leap year
      if(gcalendar.isLeapYear(year)) {
         System.out.println("The current year is a leap year");
      }else {
         System.out.println("The current year is not a leap year");
      }
   }
}

Output:

Date: Jul 7 2022
Time: 7:46:56
The current year is not a leap year

You can test the above example here! ➡Java Online Compiler 

Conclusion

In conclusion, we have discussed Java Date and Time, covering key concepts such as LocalTime, LocalDateTime, the importance of Date and Time in Java, and the different types of Date in Java.

It delved into the Date class, its constructors, and methods, including examples of how to get the current date and time.

This article covered a range of topics to enhance understanding and application of Date and Time in Java programming.

What’s Next

The next section talks about Regular Expressions In Java programming. At the end of the session, you’ll know what regular expressions are all about in Java.

< PREVIOUS

Java Arrays

NEXT >

Java Regular Expression