Java calculate days in year

问题:

Is there a method in any native Java class to calculate how many days were/will be in a specific year? As in, was it a Leap year (366 days) or a normal year (365 days)?

Or do I need to write it myself?

I'm calculating the number of days between two dates, for example, how many days left until my birthday. I want to take into account the February 29 of Leap year. I have it all done except that 29th.

回答1:

The GregorianCalendar standar class has an isLeapyear() method. If all you've got is a year number (say, 2008), then construct a date using this constructor, and then check the isLeapYear() method afterwards.

回答2:

Another way to do it is to ask the Calendar class for the actual maximum days in a given year:

Calendar cal = Calendar.getInstance();
cal.setTime(new Date());

int numOfDays = cal.getActualMaximum(Calendar.DAY_OF_YEAR);
System.out.println(numOfDays);

This will return 366 for a bisestile year, 365 for a normal one.

Note, I used getActualMaximum instead of getMaximum, which will always returns 366.

回答3:

tl;dr

Year.of( 2015 )
    .length()

java.time

In Java 8 and later we have the java.time package. (Tutorial)

length

The Year class represents a single year value. You can interrogate its length.

int daysInYear = Year.of( 2015 ).length();

isLeap

You can also ask if a year is a Leap year or not.

Boolean isLeapYear = Year.isLeap( 2015 );

As an example, get the number of days in year using Java’s ternary operator, such as:

minVal = (a < b) ? a : b;

In our case, we want number of days of year. That is 365 for non-Leap years, and 366 for Leap year.

int daysInYear = ( Year.isLeap( 2015 ) ) ? 366 : 365 ;

Day-of-year

You can get the day-of-year number of a date. That number runs from 1 to 365, or 366 in a leap year.

int dayOfYear = LocalDate.now( ZoneId.of( "America/Montreal" ).getDayOfYear() ;

Going the other direction, get a date for a day-of-year.

Year.now( ZoneId.of( "America/Montreal" ) ).atDay( 159 ) ;

You could determine elapsed days by comparing these day-of-year numbers when dealing with a single year. But there is an easier way; read on.

Elapsed days

Use the ChronoUnit enum to calculate elapsed days.

LocalDate start = LocalDate.of( 2017 , 2 , 23 ) ;
LocalDate stop = LocalDate.of( 2017 , 3 , 11 ) ;
int daysBetween = ChronoUnit.DAYS.between( start , stop );

Automatically handles Leap Year.

---

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.

Where to obtain the java.time classes?

• Java SE 8, Java SE 9, 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
  • The ThreeTenABP project adapts ThreeTen-Backport (mentioned above) for Android specifically.
  • See How to use ThreeTenABP….

The ThreeTen-Extra project extends java.time with additional classes. This project is a proving ground for possible future additions to java.time. You may find some useful classes here such as Interval, YearWeek, YearQuarter, and more.

回答4:

For DateTime calculations I highly recommend using the JodaTime library. For what you need, in particular, it would be a one liner:

Days.daysBetween(date1, date2).getDays();

I hope this helps.

回答5:

GregorianCalendar.isLeapYear(int year)

回答6:

You can look at the Wikipedia page for some very nice pseudocode:

if year modulo 400 is 0
       then is_leap_year
else if year modulo 100 is 0
       then not_leap_year
else if year modulo 4 is 0
       then is_leap_year
else
       not_leap_year

I'm sure you can figure out how to implement that logic in Java. :-)

回答7:

You exact use case might be best solved with Joda and this specific example.

回答8:

You can use the TimeUnit class. For your specific needs this should do:

public static int daysBetween(Date a, Date b) {
    final long dMs = a.getTime() - b.getTime();
    return TimeUnit.DAYS.convert(dMs, TimeUnit.MILLISECONDS);
}

Honestly, I don't see where leap years play any role in this calculation, though. Maybe I missed some aspect of your question?

Edit: Stupid me, the leap years magic happens in the Date.getTime(). Anyway, you don't have to deal with it this way.