How to calculate the next minute and next 5 minute intevals given a ZonedDateTime

Question

I have a instance of a ZonedDatetime.

ZonedDateTime.now(ZoneId.of("America/New_York"))

I basically need a function that will take an instance of a ZonedDateTime and return the next 1 minute and 5 minute values.

So if the current time is:

2021-10-24T19:46:10.649817

The next minute will be 19:47:00 and the next 5 minute will be 19:50:00

The next 5 minute interval is always like:

1:00
1:05
1:10
1:15
1:20
1:25
...
1:50
1:55
2:00

i.e. the next 5 minute interval is not based on exactly 5 minutes from now, but rather the next 5 minutes based on starting from the beginning of the hour. Same goes for the next 1 minute interval in the future.

def nextIntervals(zdt: ZonedDateTime): (ZonedDateTime, ZonedDateTime) = {
  ???
}

What problem exactly are you facing? What did you try, that didn't work? — php_nub_qq, Oct 24 '21 at 23:59
Just wondering if there is some way to do this w/o having to hard code the values like 0, 5, 10, 15, 20, 25, 30, ...60 and also for the 1 minute intervals. I'm drawing a blank on this! — Blankman, Oct 25 '21 at 00:13

php_nub_qq · Accepted Answer · 2021-10-25T00:33:15.883

It is fairly simple to do so without hardcoding the values. Unfortunately I'm not familiar with scala so I'll give you some pseudo code, I believe you'll be able to easily translate it.

nextIntervals(zdt) {
  timestamp = zdt.toUnixTimestamp();

  return [
    new ZonedDateTime(timestamp + (60 - timestamp % 60)),
    new ZonedDateTime(timestamp + (300 - timestamp % 300))
  ]
}

The above code assumes that ZonedDateTime can be instantiated by giving it a unix timestamp, measured in seconds. And also that it can be converted to a unix timestamp.

The idea is pretty simple: the remainder of the modulus will be the time that has elapsed since the last required period (in your case 1 minute or 5 minutes). Take that away from the period itself and you have the time that's left until the next period. Add that to the current time and you have the exact datetime.

Edit:

Here's a working javascript example

function nextIntervals(date) {
  let t = date.getTime();

  return [
    60e3,
    300e3,
  ].map(i => new Date(t + i - t % i));
}

console.log(nextIntervals(new Date));

Arvind Kumar Avinash · Answer 2 · 2021-10-25T21:03:30.243

You can use the following functions to meet your requirements:

Demo:

import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoUnit;

public class Main {
    public static void main(String[] args) {
        ZonedDateTime now = ZonedDateTime.now(ZoneId.of("America/New_York"));

        ZonedDateTime nextMinute = now.plusMinutes(1).truncatedTo(ChronoUnit.MINUTES);

        ZonedDateTime nextMultipleOfFiveMin = now.truncatedTo(ChronoUnit.MINUTES)
                                                .minusMinutes(now.getMinute() % 5)
                                                .plusMinutes(5);

        System.out.println(now);
        System.out.println(nextMinute);
        System.out.println(nextMultipleOfFiveMin);
    }
}

Output from a sample run:

2021-10-25T16:59:22.662943-04:00[America/New_York]
2021-10-25T17:00-04:00[America/New_York]
2021-10-25T17:00-04:00[America/New_York]

Output from another sample run after a while:

2021-10-25T17:05:09.596952-04:00[America/New_York]
2021-10-25T17:06-04:00[America/New_York]
2021-10-25T17:10-04:00[America/New_York]

ONLINE DEMO

Learn more about the modern Date-Time API from Trail: Date Time. Check this answer and this answer to learn how to use java.time API with JDBC.

Note: The java.util Date-Time API and their formatting API, SimpleDateFormat are outdated and error-prone. It is recommended to stop using them completely and switch to the modern Date-Time API^*.

^{* If you are working for an Android project and your Android API level is still not compliant with Java-8, check Java 8+ APIs available through desugaring. Note that Android 8.0 Oreo already provides support for java.time.}

score 1 · Answer 3 · edited Oct 26 '21 at 07:32

We do need a little bit of hand-coded math to handle the 5-minute interval case. Excuse my Java syntax.

ZonedDateTime now = ZonedDateTime.now(ZoneId.of("America/New_York"));
System.out.println("Now: " + now);

// Truncate to the previous 5 minutes
ZonedDateTime zdt = now.truncatedTo(ChronoUnit.MINUTES);
zdt = zdt.withMinute(zdt.getMinute() / 5 * 5);

for (int i = 0; i <= 12; i++) {
    zdt = zdt.plusMinutes(5);
    System.out.println(zdt);
}

Example output:

Now: 2021-10-25T15:23:31.357567-04:00[America/New_York]
2021-10-25T15:25-04:00[America/New_York]
2021-10-25T15:30-04:00[America/New_York]
2021-10-25T15:35-04:00[America/New_York]
2021-10-25T15:40-04:00[America/New_York]
2021-10-25T15:45-04:00[America/New_York]
2021-10-25T15:50-04:00[America/New_York]
2021-10-25T15:55-04:00[America/New_York]
2021-10-25T16:00-04:00[America/New_York]
2021-10-25T16:05-04:00[America/New_York]
2021-10-25T16:10-04:00[America/New_York]
2021-10-25T16:15-04:00[America/New_York]
2021-10-25T16:20-04:00[America/New_York]
2021-10-25T16:25-04:00[America/New_York]

The trick to truncate to a whole multiple of 5 minutes is to divide by 5, obtain a whole number and discard any remainder, and multiply by 5 again.

The 1-minute interval is similar, only a bit simpler: we don’t need to do any math ourselves, java.time takes care of it all.

How to calculate the next minute and next 5 minute intevals given a ZonedDateTime

3 Answers3