Java LocalTime

In the last lesson you learned about Java LocalDate, which holds a date with no time attached. But many things are about the clock, not the calendar, like a shop that opens at 9 or an alarm at 6:30. For exactly this, Java gives you LocalTime, which lives in the java.time package.

🤔 What is LocalTime?

A LocalTime is a time of day on its own. Think of a wall clock with no calendar next to it.

• Holds hour, minute, second, and nanosecond. Nothing else.
• No date and no time zone, so 14:30 is just half past two in the afternoon.
• It does not know if that is today, tomorrow, or in Tokyo.
• Reach for it for times that repeat every day: opening hours, a daily reminder, a bus that leaves at the same minute.

🛠️ Creating a LocalTime

There are two main ways to make one. To get the time right now from the system clock, use LocalTime.now().

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime rightNow = LocalTime.now();
        System.out.println(rightNow);
    }
}

This prints whatever time it is on your machine when you run it, down to the nanosecond. Your output will look something like the line below, but with your own time.

10:15:42.123456

To build a specific time instead of the current one, use LocalTime.of(). You pass the hour and minute, and Java hands back that exact time.

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime opening = LocalTime.of(9, 0);
        LocalTime classTime = LocalTime.of(14, 30);
        LocalTime precise = LocalTime.of(14, 30, 15);

        System.out.println(opening);
        System.out.println(classTime);
        System.out.println(precise);
    }
}

A few things to notice:

• The hour uses the 24-hour clock, so 14 means 2 in the afternoon.
• of comes in different sizes: hour and minute, hour-minute-second, or one that takes nanoseconds too.
• Pick the size that matches how precise you need to be.

09:00
14:30
14:30:15

🔍 Reading the parts of a time

Once you have a LocalTime, you often want just one piece of it. Java gives you a simple getter for each part. This example pulls every part out of one time.

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime t = LocalTime.of(14, 30, 15);

        System.out.println("Hour: " + t.getHour());
        System.out.println("Minute: " + t.getMinute());
        System.out.println("Second: " + t.getSecond());
        System.out.println("Nano: " + t.getNano());
    }
}

• Each getter returns a plain int. So getHour() gives 14, getMinute() gives 30.
• We did not set a nanosecond, so getNano() is 0.
• Handy for decisions based on the time, like “if the hour is before 12, say good morning”.

Hour: 14
Minute: 30
Second: 15
Nano: 0

➕ Adding and subtracting time

Here is the most important rule of the whole lesson. A LocalTime is immutable, meaning once created it can never change. So plusHours does not edit your time. It builds a brand new LocalTime and hands it back, and the original stays exactly as it was. This example adds and subtracts, and proves the original never moves.

import java.time.LocalTime;

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

        LocalTime later = start.plusHours(2);
        LocalTime earlier = start.minusMinutes(15);

        System.out.println("Original: " + start);
        System.out.println("Plus 2 hours: " + later);
        System.out.println("Minus 15 minutes: " + earlier);
    }
}

Look at the last three lines together:

• The original start still prints 09:00, even after plusHours and minusMinutes.
• Those methods did not touch start. Each returned a new time, caught in later and earlier.
• Forget to catch the returned value and it looks like nothing happened. The number one mistake here.

Original: 09:00
Plus 2 hours: 11:00
Minus 15 minutes: 08:45

There is a matching method for every part: plusHours/minusHours, plusMinutes/minusMinutes, plusSeconds/minusSeconds. Because each returns a new LocalTime, you can chain them to read left to right.

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime t = LocalTime.of(10, 0)
                .plusHours(1)
                .plusMinutes(30);

        System.out.println(t);
    }
}

• Each step works on the result of the step before it: 10:00 becomes 11:00, then 11:30.
• The time wraps around the clock by itself. Push past midnight and it rolls over to the early morning, with no error.

11:30

🟰 Comparing two times

To check which of two times comes first, use isBefore and isAfter. Both return a plain true or false. To check if two times are exactly the same, use equals. This example compares an opening time with the current moment.

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        LocalTime opening = LocalTime.of(9, 0);
        LocalTime closing = LocalTime.of(17, 0);
        LocalTime now = LocalTime.of(14, 30);

        System.out.println(now.isAfter(opening));
        System.out.println(now.isBefore(closing));
        System.out.println(opening.equals(LocalTime.of(9, 0)));
    }
}

Reading the results:

• isAfter returns true because 14:30 comes after 9:00.
• isBefore returns true because 14:30 comes before 17:00.
• equals returns true because both 9:00 times hold the same value.
• Together, the first two checks ask “is the shop open right now?”.

true
true
true

📌 The built-in constants

LocalTime ships with a few constants, fixed values you use directly off the class name, so you do not build common times by hand. This example prints all three.

import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        System.out.println("MIN: " + LocalTime.MIN);
        System.out.println("MAX: " + LocalTime.MAX);
        System.out.println("NOON: " + LocalTime.NOON);
    }
}

• LocalTime.MIN is the start of the day, 00:00, midnight.
• LocalTime.MAX is one nanosecond before midnight, the last instant before the next day.
• LocalTime.NOON is 12:00, the middle of the day.
• Useful as boundaries, like “everything between MIN and NOON to get the morning”.

MIN: 00:00
MAX: 23:59:59.999999999
NOON: 12:00

⏱️ How long between two times

Often you want the gap between two times. How long until the bus? How long is the meeting? For this you use Duration.between, which measures the length from one moment to another. This example finds the gap between a start and an end.

import java.time.LocalTime;
import java.time.Duration;

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

        Duration gap = Duration.between(start, end);

        System.out.println("Hours: " + gap.toHours());
        System.out.println("Total minutes: " + gap.toMinutes());
    }
}

• Duration.between(start, end) returns a Duration holding the whole length, here two and a half hours.
• toHours() gives the whole hours, 2. toMinutes() gives the total minutes, 150.
• toHours drops the leftover 30 minutes because it only counts complete hours.
• For the full picture, ask for total minutes or total seconds.

Hours: 2
Total minutes: 150

🎨 Formatting a time for people

The default printout like 14:30 is fine for code, but people often want a friendlier look, like 02:30 PM. For this you use a DateTimeFormatter, a recipe that says how the time should look. This example shows the same time in two styles.

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        LocalTime t = LocalTime.of(14, 30);

        DateTimeFormatter f24 = DateTimeFormatter.ofPattern("HH:mm");
        DateTimeFormatter f12 = DateTimeFormatter.ofPattern("hh:mm a");

        System.out.println(t.format(f24));
        System.out.println(t.format(f12));
    }
}

The pattern string is where the magic happens:

• Capital HH means the hour on the 24-hour clock. Small hh means the 12-hour clock.
• mm is the minute. a adds the AM or PM marker.
• So the first format prints 14:30, the second prints 02:30 PM.
• The case of the letters matters a lot. More in the mistakes section.

14:30
02:30 PM

📥 Parsing text into a time

Going the other way, you often read a time from a file or a form as plain text and need to turn it into a real LocalTime. That is parsing, and you use LocalTime.parse. This example reads two text strings into times.

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        LocalTime t1 = LocalTime.parse("08:45");

        DateTimeFormatter f = DateTimeFormatter.ofPattern("hh:mm a");
        LocalTime t2 = LocalTime.parse("02:30 PM", f);

        System.out.println(t1);
        System.out.println(t2.plusHours(1));
    }
}

• The first parse takes plain 08:45 with no formatter, the standard shape LocalTime already understands.
• The second is 12-hour style with a PM marker, so we hand parse the matching formatter to read it.
• Once parsed, t2 is a real LocalTime, so we can do time math, like adding an hour to get 15:30.

08:45
15:30

⚠️ Common Mistakes

A handful of LocalTime slip-ups catch nearly everyone.

Treating LocalTime as if it changes. The immutability trap. Plus and minus methods return a new time, and people forget to keep it.

LocalTime t = LocalTime.of(9, 0);

t.plusHours(2);              // ❌ result thrown away, t is still 09:00
t = t.plusHours(2);         // ✅ keep the returned value, now t is 11:00

Mixing up the 24-hour and 12-hour clock. Two in the afternoon is 14, not 2, on the 24-hour clock that of uses.

LocalTime afternoon = LocalTime.of(2, 30);    // ❌ this is 2:30 in the morning
LocalTime afternoon2 = LocalTime.of(14, 30);  // ✅ 14 is 2:30 in the afternoon

Using the wrong case in the format pattern. Capital HH is the 24-hour clock, small hh is the 12-hour clock. Swapping them gives the wrong look.

DateTimeFormatter f1 = DateTimeFormatter.ofPattern("hh:mm");   // ❌ 14:30 prints as 02:30, no AM/PM
DateTimeFormatter f2 = DateTimeFormatter.ofPattern("HH:mm");   // ✅ 14:30 prints as 14:30

Passing an hour above 23. There is no hour 24. To move into the next day, add hours and let it wrap, do not pass 24.

LocalTime t1 = LocalTime.of(24, 0);          // ❌ DateTimeException, no such hour
LocalTime t2 = LocalTime.of(0, 0);           // ✅ midnight is 0, not 24

✅ Best Practices

Good habits that keep your time code clean and correct.

• Always catch the returned value. Since LocalTime never changes in place, assign the result, like t = t.plusHours(1);. If you do not, nothing seems to happen.
• Use the 24-hour clock when you build a time. LocalTime.of(14, 30) is clear and leaves no doubt about morning or afternoon.
• Reach for the constants. Use LocalTime.MIN, LocalTime.NOON, and LocalTime.MAX as clean boundaries instead of building those values yourself.
• Compare with isBefore and isAfter. They read like plain English and make “is it open right now?” checks easy to follow.
• Use Duration.between for gaps. It is the right tool for the length between two times, and toMinutes or toSeconds give you the full amount.
• Match your formatter to your text when parsing. If the text is in 12-hour style with AM or PM, parse it with a matching DateTimeFormatter.

🧩 What You’ve Learned

Nicely done. You can now work with the clock side of time in Java.

• ✅ LocalTime holds a time of day, hour, minute, second, and nano, with no date and no zone.
• ✅ Create one with LocalTime.now() for the current time, or LocalTime.of(14, 30) for an exact time on the 24-hour clock.
• ✅ Read parts with getHour(), getMinute(), and getSecond(), each returning a plain int.
• ✅ LocalTime is immutable, so plusHours and minusMinutes return a new time and you must catch it.
• ✅ Compare with isBefore and isAfter, and use the constants MIN, MAX, and NOON for boundaries.
• ✅ Measure a gap with Duration.between, and use DateTimeFormatter to format and parse times.

🚀 What’s Next?

You can handle a date on its own, and now a time on its own. The natural next step is to join them, so you can say “this exact moment, on this exact day”. That is what LocalDateTime is for. Let’s put the two halves together.

Java LocalDateTime