Get milliseconds until midnight

Use a Calendar to compute it :

        Calendar c = Calendar.getInstance();
        c.add(Calendar.DAY_OF_MONTH, 1);
        c.set(Calendar.HOUR_OF_DAY, 0);
        c.set(Calendar.MINUTE, 0);
        c.set(Calendar.SECOND, 0);
        c.set(Calendar.MILLISECOND, 0);
        long howMany = (c.getTimeInMillis()-System.currentTimeMillis());

tl;dr

java.time.Duration
.between( now , tomorrowStart )
.toMillis()

java.time

Java 8 and later comes with the java.time framework built-in. These new classes supplant the old date-time classes (java.util.Date/.Calendar) bundled with Java. Also supplants Joda-Time, developed by the same people. Much of the java.time functionality is back-ported to Java 6 & 7, and further adapted to Android (see below).

A time zone is crucial in determining a date. For any given moment, the date varies around the globe by zone. For example, a few minutes after midnight in Paris France is a new day while still “yesterday” in Montréal Québec.

Specify a proper time zone name in the format of continent/region, such as America/Montreal, Africa/Casablanca, or Pacific/Auckland. Never use the 3-4 letter abbreviation such as EST or IST as they are not true time zones, not standardized, and not even unique(!).

ZoneId z = ZoneId.of( "America/Montreal" );
ZonedDateTime now = ZonedDateTime.now( z );

We want to get the number of milliseconds running up to, but not including, the first moment of the next day.

We must go through the LocalDate class to get at the first moment of a day. So here we start with a ZonedDateTime to get a LocalDate, and after that get another ZonedDateTime. The key is calling atStartOfDay on the LocalDate.

LocalDate tomorrow = now.toLocalDate().plusDays(1);
ZonedDateTime tomorrowStart = tomorrow.atStartOfDay( z );

Notice that we do not hard-code a time-of-day at 00:00:00. Because of anomalies such as Daylight Saving Time (DST), the day does may start at another time such as 01:00:00. Let java.time determine the first moment.

Now we can calculate elapsed time. In java.time we use the Duration class. The java.time framework has a finer resolution of nanoseconds rather than the coarser milliseconds used by both java.util.Date and Joda-Time. But Duration includes a handy getMillis method, as the Question requested.

Duration duration = Duration.between( now , tomorrowStart );
long millisecondsUntilTomorrow = duration.toMillis();

See this code run live at IdeOne.com.

now.toString(): 2017-05-02T12:13:59.379-04:00[America/Montreal]

tomorrowStart.toString(): 2017-05-03T00:00-04:00[America/Montreal]

millisecondsUntilTomorrow: 42360621

About java.time

The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date, Calendar, & SimpleDateFormat.

The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.

To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.

You may exchange java.time objects directly with your database. Use a JDBC driver compliant with JDBC 4.2 or later. No need for strings, no need for java.sql.* classes.

Where to obtain the java.time classes?

  • Java SE 8, Java SE 9, Java SE 10, and later
  • Built-in.
  • Part of the standard Java API with a bundled implementation.
  • Java 9 adds some minor features and fixes.
  • Java SE 6 and Java SE 7
  • Much of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport.
  • Android
  • Later versions of Android bundle implementations of the java.time classes.
  • For earlier Android (<26), the ThreeTenABP project adapts ThreeTen-Backport (mentioned above). See How to use ThreeTenABP….

Joda-Time

UPDATE: The Joda-Time project is now in maintenance mode, with the team advising migration to the java.time classes. I leave this section intact for the sake of history, but recommend using java.time and ThreeTenABP as discussed above.

In Android you should be using the Joda-Time library rather than the notoriously troublesome Java.util.Date/.Calendar classes.

Joda-Time offers a milliseconds-of-day command. But we don't really need that here.

Instead we just need a Duration object to represent the span of time until first moment of next day.

Time zone is critical here to determine when "tomorrow" starts. Generally better to specify than rely implicitly on the JVM’s current default time zone which can change at any moment. Or if you really want the JVM’s default, ask for that explicitly with call to DateTimeZone.getDefault to make your code self-documenting.

Could be a two-liner.

DateTime now = DateTime.now( DateTimeZone.forID( "America/Montreal" ) );
long milliSecondsUntilTomorrow = new Duration( now , now.plusDays( 1 ).withTimeAtStartOfDay() ).getMillis();

Let's take that apart.

DateTimeZone zone = DateTimeZone.forID( "America/Montreal" ); // Or, DateTimeZone.getDefault()
DateTime now = DateTime.now( zone );
DateTime tomorrow = now.plusDays( 1 ).withTimeAtStartOfDay();  // FYI the day does not *always* start at 00:00:00.0 time.
Duration untilTomorrow = new Duration( now , tomorrow );
long millisecondsUntilTomorrow = untilTomorrow.getMillis();

Dump to console.

System.out.println( "From now : " + now + " until tomorrow : " + tomorrow + " is " + millisecondsUntilTomorrow + " ms." );

When run.

From now : 2015-09-20T19:45:43.432-04:00 until tomorrow : 2015-09-21T00:00:00.000-04:00 is 15256568 ms.

Tags:

Java

Date

Android

Milliseconds

Recent Posts