How can I represent and operate on time values greater than 24:00 in Java?

My first thought is to store that as a Duration object. You could easily use the getters on that class to construct the HH:mm string when you want to display the value, or use something like the Apache Commons DurationFormatUtils.

The LocalDate and LocalDateTime classes support operations like adding and subtracting Durations.

No that does not exist

I am convinced that no class in the three-ten family or commonly used class from elsewhere supports what you want. The closest my search could get was the DayCycles class of the Time4J library (link at the bottom). It consists of a time of day (a PlainTime) and a count of days relative to an unspecified date, so what you ask for; but it’s specifically for returning the result of adding or subtracting time from a PlainTime and doesn’t offer any functionality of its own.

Spin your own

I wouldn’t think that developing your own class that could interoperate with java.time would be too hard. Likely base it off java.time.Duration as Mark B suggests, depending on more precise requirements.

Parsing and formatting may be the hardest part if you have demanding requirements for these. Possibly it’s worth taking inspiration from the source code for the Joda-Time library since this includes facilities for formatting and parsing durations.

Another source of inspiration would be the source of java.time.LocalTime.

Here are the very first few bits:

public class SpecializedTime {

    private Duration timeSince0000;
    
    private SpecializedTime(Duration timeSince0000) {
        this.timeSince0000 = timeSince0000;
    }

    static SpecializedTime parse(String text, DateTimeFormatter formatter) {
        ParsePosition position = new ParsePosition(0);
        TemporalAccessor parsed = formatter.parseUnresolved(text, position);
        if (position.getErrorIndex() != -1) {
            throw new DateTimeParseException("Parse error", text, position.getErrorIndex());
        }
        if (position.getIndex() != text.length()) {
            throw new DateTimeParseException("Unparsed text", text, position.getIndex());
        }
        if (! parsed.isSupported(ChronoField.HOUR_OF_DAY)) {
            throw new DateTimeParseException("Cannot resolve", text, 0);
        }
        
        Duration time = Duration.ofHours(parsed.getLong(ChronoField.HOUR_OF_DAY));
        if (parsed.isSupported(ChronoField.MINUTE_OF_HOUR)) {
            int minuteOfHour = parsed.get(ChronoField.MINUTE_OF_HOUR);
            // Should validate, 0..59
            time = time.plusMinutes(minuteOfHour);
        }
        // Same for seconds and nanoseconds
        
        return new SpecializedTime(time);
    }
    
    @Override
    public String toString() {
        return String.format("%02d:%02d", timeSince0000.toHours(), timeSince0000.toMinutesPart());
    }

}

Demonstration:

        DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("H:m");
        SpecializedTime st = SpecializedTime.parse("25:15", timeFormatter);
        System.out.println(st);

Output:

25:15

Link

Documentation of DayCycles form Time4J

There is not currently a type which directly models this concept in ThreeTen-Extra or in the core Java libraries. However, a feature request now exists in ThreeTen-Extra requesting this functionality (threeten-extra#169).

ThreeTen-Extra project maintainer Stephen Colebourne has commented that this would be a sensible addition to the library, so it's seems to be mostly a matter of when or whether anybody steps up to implement the feature.

Stephen Colebourne also suggested a few ways of implementing this feature within the library. One of these suggested approaches could be used as part of a custom solution to this problem.

It could be a combination of LocalTime and a number of days, or something closer to LocalTime. Various design options.