In Java, how do I get the difference in seconds between 2 dates?

Question

The Java class library has a class named DateTime. DateTime has this method:

int daysBetween(DateTime other)

which returns the number of days between this and the parameter. It doesn't have a method

int secondsBetween(DateTime other)

which I happen to need. Is there a class which is similar to DateTime but has such a method?

This might help :http://www.xmission.com/~goodhill/dates/deltaDates.html — Prasoon Saurav, Dec 28 '09 at 16:30
If you're on java 8 you have a few more options see https://stackoverflow.com/q/25747499/32453 — rogerdpack, Dec 08 '17 at 17:39

Scott Stanchfield · Accepted Answer · 2013-03-08T19:50:01.930

203

Not familiar with DateTime...

If you have two Dates you can call getTime on them to get millseconds, get the diff and divide by 1000. For example

Date d1 = ...;
Date d2 = ...;
long seconds = (d2.getTime()-d1.getTime())/1000;

If you have Calendar objects you can call

c.getTimeInMillis()

and do the same

edited Mar 08 '13 at 19:50

answered Dec 28 '09 at 16:31

Scott Stanchfield

29,742
9
47
65

2

When time difference is not so high - int seconds = (int) ((d2.getTime()-d1.getTime())/1000); – Xdg Mar 07 '13 at 15:38
@sebrock - fixed to show type as long - casting to int will work for smaller amounts – Scott Stanchfield Mar 08 '13 at 19:50
1

@Xdg I was designing an interface lately and came across the same 'problem', but `Integer.MAX_VALUE` can represent almost 70 years in seconds. That was sufficient for me. – mike Aug 09 '13 at 17:23
I am looking for answer using LocalDateTime. – JohnMerlino Jun 07 '14 at 23:59

Ole V.V. · Answer 2 · 2017-12-08T21:30:25.693

I should like to provide the modern answer. The other answers were fine when this question was asked, but time moves on. Today I recommend you use java.time, the modern Java date and time API.

    ZonedDateTime aDateTime = ZonedDateTime.of(2017, 12, 8, 19, 25, 48, 991000000, ZoneId.of("Europe/Sarajevo"));
    ZonedDateTime otherDateTime = ZonedDateTime.of(2017, 12, 8, 20, 10, 38, 238000000, ZoneId.of("Europe/Sarajevo"));

    long diff = ChronoUnit.SECONDS.between(aDateTime, otherDateTime);
    System.out.println("Difference: " + diff + " seconds");

This prints:

Difference: 2689 seconds

ChronoUnit.SECONDS.between() works with two ZonedDateTime objects or two OffsetDateTimes, two LocalDateTimes, etc.

If you need anything else than just the seconds, you should consider using the Duration class:

    Duration dur = Duration.between(aDateTime, otherDateTime);
    System.out.println("Duration: " + dur);
    System.out.println("Difference: " + dur.getSeconds() + " seconds");

This prints:

Duration: PT44M49.247S
Difference: 2689 seconds

The former of the two lines prints the duration in ISO 8601 format, the output means a duration of 44 minutes and 49.247 seconds.

Why java.time?

The Date class used in several of the other answers is now long outdated. Joda-Time also used in a couple (and possibly in the question) is now in maintenance mode, no major enhancements are planned, and the developers officially recommend migrating to java.time, also known as JSR-310.

Question: Can I use the modern API with my Java version?

If using at least Java 6, you can.

In Java 8 and later the new API comes built-in.
In Java 6 and 7 get the ThreeTen Backport, the backport of the new classes (ThreeTen for JSR 310).
On Android, use the Android edition of ThreeTen Backport. It’s called ThreeTenABP, and there’s a thorough explanation in this question: How to use ThreeTenABP in Android Project.

Very underrated answer. Jodatime's calculations here are a little messy. However `ChronoUnit.SECONDS.between(oldDate.toInstant(), newDate.toInstant())` is rather easy to remember. — fIwJlxSzApHEZIl, Apr 04 '18 at 22:51

score 10 · Answer 3 · answered Feb 28 '13 at 19:04

10

You should do

org.joda.time.Seconds.secondBetween(date1, date2)

answered Feb 28 '13 at 19:04

Pascal-Louis Perez

181
2
3

3

Welcome to StackOverflow, and thanks for contributing. This would be a stronger post if you explained why this is the way to go. – Phil Feb 28 '13 at 19:22
Also it is Seconds.secondsBetween(date1, date2) – divonas May 28 '15 at 08:11
5

@divonas makes no difference. His notation explicitly refers to joda – Tim Feb 11 '16 at 16:14
1

The correct method name is 'second**s**Between'. That said this is the cleanest way I found with org.joda.time.DateTime. – thisismydesign Sep 29 '16 at 13:55
1

If you want the results as an int you should call getSeconds() on the result.`Seconds.secondsBetween(start, end).getSeconds()` – thisismydesign Sep 29 '16 at 14:02
1

I think there's a java 8 way of doing this now that doesn't require jodatime. I'm on the lookout for it. – fIwJlxSzApHEZIl Nov 07 '17 at 18:31

score 7 · Answer 4 · answered Dec 28 '09 at 16:31

7

That should do it:

Date a = ...;
Date b = ...;

Math.abs(a.getTime()-b.getTime())/1000;

Here the relevant documentation: Date.getTime(). Be aware that this will only work for dates after January 1, 1970, 00:00:00 GMT

answered Dec 28 '09 at 16:31

Johannes Weiss

52,533
16
102
136

Hmm, why would this only work for dates after Jan 1, 1970? Before that the values are negative, but arithmetic works on negative numbers. – Jay Dec 28 '09 at 17:24

score 6 · Answer 5 · answered Aug 08 '13 at 12:50

6

You can use org.apache.commons.lang.time.DateUtils to make it cleaner:

(firstDate.getTime() - secondDate.getTime()) / DateUtils.MILLIS_PER_SECOND

answered Aug 08 '13 at 12:50

shem

4,686
2
32
43

`DateUtils.MILLIS_PER_SECOND` +1 for that – hornet2319 Aug 18 '22 at 15:15

score 5 · Answer 6 · answered Dec 28 '09 at 16:30

There is no such class as DateTime in the standard Java SE API. Although there is one in joda-time, even that does not have a daysBetween method.

Using the standard Java API, the easiest way to get seconds between two java.util.Date objects would be to subtract their timestamps and divide by 1000:

int secondsBetween = (date1.getTime() - date2.getTime()) / 1000;

score 5 · Answer 7 · edited May 23 '17 at 12:18

It is not recommended to use java.util.Date or System.currentTimeMillis() to measure elapsed times. These dates are not guaranteed to be monotonic and will changes occur when the system clock is modified (eg when corrected from server). In probability this will happen rarely, but why not code a better solution rather than worrying about possibly negative or very large changes?

Instead I would recommend using System.nanoTime().

long t1 = System.nanoTime();
long t2 = System.nanoTime();

long elapsedTimeInSeconds = (t2 - t1) / 1000000000;

EDIT

For more information about monoticity see the answer to a related question I asked, where possible nanoTime uses a monotonic clock. I have tested but only using Windows XP, Java 1.6 and modifying the clock whereby nanoTime was monotonic and currentTimeMillis wasn't.

Also from Java's Real time doc's:

Q: 50. Is the time returned via the real-time clock of better resolution than that returned by System.nanoTime()?

The real-time clock and System.nanoTime() are both based on the same system call and thus the same clock.

With Java RTS, all time-based APIs (for example, Timers, Periodic Threads, Deadline Monitoring, and so forth) are based on the high-resolution timer. And, together with real-time priorities, they can ensure that the appropriate code will be executed at the right time for real-time constraints. In contrast, ordinary Java SE APIs offer just a few methods capable of handling high-resolution times, with no guarantee of execution at a given time. Using System.nanoTime() between various points in the code to perform elapsed time measurements should always be accurate.

Hmm, interesting post. What makes you say that nanoTime is not subject to clock updates? I don't see anything in the Java documentation about this. I'm not saying you're wrong, I'm must wondering if you have a reference or have performed experiments to back this up. — Jay, Dec 28 '09 at 17:26

score 4 · Answer 8 · answered Dec 29 '09 at 00:49

If you're using Joda (which may be coming as jsr 310 in JDK 7, separate open source api until then) then there is a Seconds class with a secondsBetween method.

Here's the javadoc link: http://joda-time.sourceforge.net/api-release/org/joda/time/Seconds.html#secondsBetween(org.joda.time.ReadableInstant,%20org.joda.time.ReadableInstant)

score 1 · Answer 9 · answered May 02 '22 at 15:18

1

For java 8+ you can use

ChronoUnit.SECONDS.between(temporal1,temporal2)

answered May 02 '22 at 15:18

Andrew Taran

71
1
4

Yes. That’s what I already recommend in [my answer](https://stackoverflow.com/a/47720172/5772882). – Ole V.V. May 02 '22 at 16:15
oh, sorry, didn't notice that – Andrew Taran May 03 '22 at 06:19
2

It may be easier to spot in a short answer like yours than in a long one like mine. I suggest we both let our answers stand. – Ole V.V. May 03 '22 at 06:23

Brian Agnew · Answer 10 · 2009-12-28T16:42:50.670

0

Which class ? Do you mean the Joda DateTime class ? If so, you can simply call getMillis() on each, and perform the appropriate subtraction/scaling.

I would recommend Joda for date/time work, btw, due to it's useful and intuitive API, and its thread-safety for formatting/parsing options.

edited Dec 28 '09 at 16:42

answered Dec 28 '09 at 16:30

Brian Agnew

268,207
37
334
440

That's not a standard library (neither is Joda), nor is it particularly well-know (unlike Joda) – Brian Agnew Dec 28 '09 at 16:40

Fabio Kenji · Answer 11 · 2009-12-28T19:28:41.453

Just a pointer: If you're calculating the difference between two java.util.Date the approach of subtracting both dates and dividing it by 1000 is reasonable, but take special care if you get your java.util.Date reference from a Calendar object. If you do so, you need to take account of daylight savings of your TimeZone since one of the dates you're using might take place on a DST period.

That is explained on Prasoon's link, I recommend taking some time to read it.

score 0 · Answer 12 · edited Aug 02 '17 at 10:10

0

Use this method:

private Long secondsBetween(Date first, Date second){
    return (second.getTime() - first.getTime())/1000;
}

edited Aug 02 '17 at 10:10

Mattew Eon

1,722
1
21
38

answered Apr 16 '15 at 13:42

Mauro Midolo

1,841
3
14
34

2

Add some explanation to your answer please. – Alex Char Apr 16 '15 at 14:22
Its clear that you need to send two Dates, i mean, Date initialDate = new Date() and Date finalDate = new Date() so if you send initialDate and finalDate you can get the difference in secods... both of them will be "convertt" to Long with the method getTIme and finally you will get the difference divided by 1000 to get the seconds... great answer by the way! – Raul Guerrero Nov 16 '20 at 02:16

score 0 · Answer 13 · answered May 29 '22 at 23:53

0

Use time unit class.

long timeDifferentInSeconds = TimeUnit.MILLISECONDS.toSeconds(currentDate.getTime()) - TimeUnit.MILLISECONDS.toSeconds(previousDate.getTime());

answered May 29 '22 at 23:53

Abdullah Ismail

415
5
6

In Java, how do I get the difference in seconds between 2 dates?

13 Answers13

Why java.time?

Question: Can I use the modern API with my Java version?

Linked

Related