Date & Time Functions in Java

Working with dates and times is a daily requirement — logging events, calculating ages, generating invoices. Java 8 introduced the powerful java.time package with classes like LocalDate, LocalTime, LocalDateTime and Duration that are immutable, thread-safe and easy to use.

• Import: import java.time.*;
• Now: LocalDateTime.now()
• Create date: LocalDate.of(2024, 5, 15)
• Format: DateTimeFormatter.ofPattern("dd-MM-yyyy")

Let's start with a hands-on example. The program below shows the core idea behind Date Time Functions in just a few lines of Java. Read it line by line and observe how Java executes each statement in order.

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;

class Main
{
    public static void main(String args[])
    {
        LocalDate     date  = LocalDate.now();
        LocalTime     time  = LocalTime.now();
        LocalDateTime dt    = LocalDateTime.now();

        System.out.println("Date: " + date);
        System.out.println("Time: " + time);
        System.out.println("Both: " + dt);
    }
}

The following examples progress from simple to more practical patterns. Try each in your IDE, change the inputs and observe the output. This is the fastest way to internalize the concept.

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

class Main
{
    public static void main(String args[])
    {
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter fmt = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm");

        System.out.println(now.format(fmt));
    }
}

import java.time.LocalDate;

class Main
{
    public static void main(String args[])
    {
        LocalDate d = LocalDate.parse("2024-08-25");

        System.out.println("Year: " + d.getYear());
        System.out.println("Month: " + d.getMonth());
        System.out.println("Day: " + d.getDayOfMonth());
    }
}

import java.time.LocalDate;

class Main
{
    public static void main(String args[])
    {
        LocalDate today = LocalDate.now();
        LocalDate later = today.plusDays(15);
        LocalDate before = today.minusMonths(2);

        System.out.println(today);
        System.out.println(later);
        System.out.println(before);
    }
}

import java.time.*;

class Main
{
    public static void main(String args[])
    {
        LocalDate dob = LocalDate.of(2000, 1, 15);
        LocalDate today = LocalDate.now();

        Period age = Period.between(dob, today);

        System.out.println("Age = " + age.getYears() + " years");
    }
}

import java.time.*;

class Main
{
    public static void main(String args[])
    {
        LocalTime t1 = LocalTime.of(9, 0);
        LocalTime t2 = LocalTime.of(11, 30);

        Duration d = Duration.between(t1, t2);

        System.out.println("Minutes = " + d.toMinutes());
    }
}

• Prefer java.time over the old java.util.Date / Calendar.
• All java.time classes are immutable — methods return new instances.
• Use DateTimeFormatter for both formatting and parsing.
• Period measures dates; Duration measures time amounts.
• Always specify a timezone for global apps — use ZonedDateTime.

Reading is not enough — practice solidifies knowledge. Try every question below in your own editor before peeking at any solution.

• Q1. Print today's date in dd/MM/yyyy format.
• Q2. Calculate your age in years and days from your DOB.
• Q3. Determine if a year is a leap year using LocalDate.isLeapYear().
• Q4. Find the day of the week for any date.
• Q5. Compute how many days between two dates.

These are the most common questions asked in Java interviews on this topic. Memorize the concept, not just the answer — interviewers often follow up with edge cases.

Even experienced developers slip on the same pitfalls. Watch out for these classic mistakes while working with Date Time Functions in Java:

• Forgetting the semicolon ; at the end of statements while using Date Time Functions.
• Mixing up similar method names — read Java docs before using new APIs related to Date Time Functions.
• Ignoring compiler warnings — they often hint at bugs that will appear later in production.
• Hard-coding values that should come from configuration files or environment variables.
• Not handling edge cases: empty inputs, very large inputs, negative numbers and null references.
• Skipping unit tests — small tests prevent big regressions, especially around control flow.