How to find minute of the year at a given point of time in java?

How to find minute of the year in java at any particular time.

It is required to be used in V2X messages as per the below definition:

MinuteOfTheYear ::= INTEGER (0..527040)

Time is tricky. This question cannot be answered without further detail.

Let's go through the terms:

> How to find minute of the year in java at a particular time.

Define 'time'. Do you mean: Some instant in the universe, or do you mean: Some readout on a wallclock? These two are not the same.

If I clap my hands right now, then I (living in The Netherlands), would say it is 14 minutes past 5 in the afternoon. But at that exact moment in time, someone in New York would claim that it is 14 minutes past 11 in the morning.

When you say 'time' do you mean more like 'when I clap my hands' or more like '5 past eleven on the 14th of march'?

> How to find minute of the year in java at a particular time.

The same applies here - 'minute of the year' implies you wish to know the difference between 'the very first minute of year X' and 'this moment in time', where X is the same year as said moment in time. This too involves timezones.

Said differently: If we go by moment-in-time, and I clap my hands at 5 minutes past the fireworks in london, the answer is '5'. Except someone in New York, at that exact same time, is still waiting (almost) 6 hours for new years; they'd answer your question with 525245; a wildly different answer.

I meant the wallclock time thing

In that case, your input is something like: Friday, 24th of July, 17:15:00, and you'd want to know the answer by defining 'new years' as being in the same zone.

Unfortunately, this is not an answerable question without knowing where on the planet we are. Some timezones move the clock around. Some do not. In europe, asking right now, you have to take into account that someplace in march, the clocks were moved forward (or was it back, I can never remember), that makes 60 minutes worth of difference. But in locales which don't do daylight savings, that never happened. Therefore: Impossible to answer without telling me WHERE.

I meant the instant-in-time thing

In that case, your input is something like '1595603962356 milliseconds since the epoch'. There is no such thing as 'start of the year' in millis since epoch without knowing where on the planet we live. Again, where is important.

I meant: Right now!

That boils down to the previous case; you'd get the current instant-in-time via System.currentTimeMillis() or Instant.now()

And... Right here!

Ah, well, 'right here' is where the java code runs. If we're talking servers and clients that may not be correct (the client could be elsewhere).

ZoneId.systemDefault() gets you the zone ID as identified by the server as 'the local zone id'.

Code please!

First, you must obtain an instant in time, localized in some location:

// inputs
Instant now = Instant.now();
ZoneId zone = ZoneId.systemDefault();

// alternative inputs:
Instant now = Instant.ofEpochMilli(1595603962356);
ZoneId zone = ZoneId.of("Europe/Amsterdam");

// convert to human style
ZonedDateTime zdt = now.atZone(zone);

// obtain first instant in time in this year
ZonedDateTime start = ZonedDateTime.of(zdt.getYear(), 1, 1, 0, 0, 0, 0, zone);

// find the difference, in minutes
int answer = (int) ChronoUnit.MINUTES.between(start, zdt);

System.out.println(answer);

Here's an example for 'right now, right here':

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoUnit;
public class RightNowRightHere {
    public static void main(String[] args) {
        Instant now = Instant.now();
        ZoneId zone = ZoneId.systemDefault();
        ZonedDateTime zdt = now.atZone(zone);
        ZonedDateTime start = ZonedDateTime.of(zdt.getYear(), 1, 1, 0, 0, 0, 0, zone);
        int answer = (int) ChronoUnit.MINUTES.between(start, zdt);
        System.out.println(answer);
    }
}

prints 296188 for me.

The thoughtful Answer by rzwitserloot is correct, and worth studying. But I suspect your use-case is specific to UTC rather than a particular time zone.

UTC specifically

Capture the current moment as seen in UTC.

OffsetDateTime now = OffsetDateTime.now( ZoneOffset.UTC ) ;

Extract the year. Use that to determine the first day of year.

Year year = Year.of( now.getYear() ) ;
LocalDate ld = year.atDay( 1 ) ;

Combine with the time 00:00:00 and UTC (offset of zero hours-minutes-seconds) to determine the first moment of the year.

OffsetDateTime startOfYear = OffsetDateTime.of( ld , LocalTime.MIN , ZoneOffset.UTC ) ;

Calculate the time elapsed between the start of year and now. The Duration class represents a span-of-time unattached to the timeline on the scale of generic 24-long days not attached to the calendar, hours, minutes, seconds, and fractional second.

Duration d = Duration.between(  startOfYear , now ) ;

Extract a total number of minutes across the entire span of time.

long minutes = d.toMinutes() ;

We could collapse that code.

long minutes =
        Duration.between(                               // Passing a pair of `OffsetDateTime` objects.
            OffsetDateTime.of(                          // Passing date, time, offset.
                Year.of( now.getYear() ).atDay( 1 ) ,   // Returns a `LocalDate` object.
                LocalTime.MIN ,                         // A constant `LocalTime` object.
                ZoneOffset.UTC                          // A constant `ZoneOffset` object. Represents an offset of zero hours-minutes-seconds.
            )                                           // Returns a `OffsetDateTime` object, the first of our pair of `OffsetDateTime` objects being passed to `Duration.between`. 
            , 
            now                                         // The `OffsetDateTime` object we instantiate above, capturing the current moment. The second of our pair of `OffsetDateTime` objects being passed to `Duration.between`. 
        )                                               // Returns a `Duration` object.
        .toMinutes()                                    // Returns a `long`, the total number of minutes across the entire span-of-time. Not to be confused with `Duration::toMinutesPart`. 
;

Well, my suggested solution is to build two methods, the first method multiplying by an argument of number (year number like 1) multiplied by the number of minutes every 365 days (one year):

public static long MinutesOfTheYear(final long year) {
return (year * 525600l);
/* For example, to calculate the number of minutes in a year, do the following:
long year = 1;
System.out.println( MinutesOfTheYear(year) );
Output:
525600l (Number of minutes a year)
*/
}

And the second method, which accepts a Calendar object with a specified date as a parameter, and then converts it to minutes relative to the specified year, month, and day:

public static long MinutesOfTheYear(final java.util.Calendar calendar) {
int DaysOfTheMonth = 0;
switch (calendar.get(java.util.Calendar.MONTH) -1) {
case 1:
// (January)
case 3:
// (March)
case 5:
// (May)
case 6:
// (June)
case 7:
// (July)
case 8:
// (August)
case 10:
// (October)
case 12:
// (December)
DaysOfTheMonth = 31;
break;
case 2:
// (February) 28 or 29
DaysOfTheMonth = 28;
break;
case 4:
// (April)
case 9:
// (September)
case 11:
// (November)
DaysOfTheMonth = 30;
break;
}
return ( 525600l ) + ( ( DaysOfTheMonth ) * 1440l )
+ ( calendar.get(java.util.Calendar.DAY_OF_MONTH) * 1440l );
/* Also to calculate the number of minutes of a particular date (year plus month and day):
java.util.Calendar calendar = java.util.Calendar.getInstance();
//** Give the desired date to the Calendar object (this class replaces the Date class, which became obsolete in Java version 1.1): **
calendar.set( year, month, day );
System.out.println( calendar );
Output:
year (525600l) + month (month * 43800l) + day (date * 1440l)
*/
}

Good luck!