# Number of days in particular month of particular year?

Posted on

Problem :

How to know how many days has particular month of particular year?

``````String date = "2010-01-19";
String[] ymd = date.split("-");
int year = Integer.parseInt(ymd);
int month = Integer.parseInt(ymd);
int day = Integer.parseInt(ymd);
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR,year);
calendar.set(Calendar.MONTH,month);
int daysQty = calendar.getDaysNumber(); // Something like this
``````

Solution :

# Java 8 and later

@Warren M. Nocos.
If you are trying to use Java 8’s new Date and Time API, you can use `java.time.YearMonth` class. See Oracle Tutorial.

``````// Get the number of days in that month
YearMonth yearMonthObject = YearMonth.of(1999, 2);
int daysInMonth = yearMonthObject.lengthOfMonth(); //28
``````

Test: try a month in a leap year:

``````yearMonthObject = YearMonth.of(2000, 2);
daysInMonth = yearMonthObject.lengthOfMonth(); //29
``````

# Java 7 and earlier

Create a calendar, set year and month and use `getActualMaximum`

``````int iYear = 1999;
int iMonth = Calendar.FEBRUARY; // 1 (months begin with 0)
int iDay = 1;

// Create a calendar object and set year and month
Calendar mycal = new GregorianCalendar(iYear, iMonth, iDay);

// Get the number of days in that month
int daysInMonth = mycal.getActualMaximum(Calendar.DAY_OF_MONTH); // 28
``````

Test: try a month in a leap year:

``````mycal = new GregorianCalendar(2000, Calendar.FEBRUARY, 1);
daysInMonth= mycal.getActualMaximum(Calendar.DAY_OF_MONTH);      // 29
``````

## Code for java.util.Calendar

If you have to use `java.util.Calendar`, I suspect you want:

``````int days = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
``````

## Code for Joda Time

Personally, however, I’d suggest using Joda Time instead of `java.util.{Calendar, Date}` to start with, in which case you could use:

``````int days = chronology.dayOfMonth().getMaximumValue(date);
``````

Note that rather than parsing the string values individually, it would be better to get whichever date/time API you’re using to parse it. In `java.util.*` you might use `SimpleDateFormat`; in Joda Time you’d use a `DateTimeFormatter`.

You can use `Calendar.getActualMaximum` method:

``````Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, month);
int numDays = calendar.getActualMaximum(Calendar.DATE);
``````

# `java.time.LocalDate`

From Java 1.8, you can use the method `lengthOfMonth` on `java.time.LocalDate`:

``````LocalDate date = LocalDate.of(2010, 1, 19);
int days = date.lengthOfMonth();
``````

This is the mathematical way:

For year (e.g. 2012), month (0 to 11):

``````int daysInMonth = month !== 2 ?
31 - (((month - 1) % 7) % 2) :
28 + (year % 4 == 0 ? 1 : 0) - (year % 100 == 0 ? 1 : 0) + (year % 400 == 0 ? 1 : 0)
``````

``````if (month == 4 || month == 6 || month == 9 || month == 11) {
daysInMonth = 30;
} else if (month == 2) {
daysInMonth = (leapYear) ? 29 : 28;
else {
daysInMonth = 31;
}
``````

Simple as that,no need to import anything

``````public static int getMonthDays(int month, int year) {
int daysInMonth ;
if (month == 4 || month == 6 || month == 9 || month == 11) {
daysInMonth = 30;
}
else {
if (month == 2) {
daysInMonth = (year % 4 == 0) ? 29 : 28;
} else {
daysInMonth = 31;
}
}
return daysInMonth;
}
``````

I would go for a solution like this:

``````int monthNr = getMonth();
final Month monthEnum = Month.of(monthNr);
int daysInMonth;
if (monthNr == 2) {
int year = getYear();
final boolean leapYear = IsoChronology.INSTANCE.isLeapYear(year);
daysInMonth = monthEnum.length(leapYear);
} else {
daysInMonth = monthEnum.maxLength();
}
``````

If the month isn’t February (92% of the cases), it depends on the month only and it is more efficient not to involve the year. This way, you don’t have to call logic to know whether it is a leap year and you don’t need to get the year in 92% of the cases.
And it is still clean and very readable code.

Lets make it as simple if you don’t want to hardcode the value of year and month and you want to take the value from current date and time:

``````Date d = new Date();
String myDate = new SimpleDateFormat("dd/MM/yyyy").format(d);
int iDayFromDate = Integer.parseInt(myDate.substring(0, 2));
int iMonthFromDate = Integer.parseInt(myDate.substring(3, 5));
int iYearfromDate = Integer.parseInt(myDate.substring(6, 10));

YearMonth CurrentYear = YearMonth.of(iYearfromDate, iMonthFromDate);
int lengthOfCurrentMonth = CurrentYear.lengthOfMonth();
System.out.println("Total number of days in current month is " + lengthOfCurrentMonth );
``````

In Java8 you can use get ValueRange from a field of a date.

``````LocalDateTime dateTime = LocalDateTime.now();

ChronoField chronoField = ChronoField.MONTH_OF_YEAR;
long max = dateTime.range(chronoField).getMaximum();
``````

This allows you to parameterize on the field.

``````// 1 means Sunday ,2 means Monday .... 7 means Saturday
//month starts with 0 (January)

MonthDisplayHelper monthDisplayHelper = new MonthDisplayHelper(2019,4);
int numbeOfDaysInMonth = monthDisplayHelper.getNumberOfDaysInMonth();
``````

Following method will provide you the no of days in a particular month

``````public static int getNoOfDaysInAMonth(String date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return (cal.getActualMaximum(Calendar.DATE));
}
``````

``````import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/*
* 44. Return the number of days in a month
* , where month and year are given as input.
*/
public class ex44 {
public static void dateReturn(int m,int y)
{
int m1=m;
int y1=y;
String str=" "+ m1+"-"+y1;
System.out.println(str);
SimpleDateFormat sd=new SimpleDateFormat("MM-yyyy");

try {
Date d=sd.parse(str);
System.out.println(d);
Calendar c=Calendar.getInstance();
c.setTime(d);
System.out.println(c.getActualMaximum(Calendar.DAY_OF_MONTH));
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
public static void main(String[] args) {
dateReturn(2,2012);

}

}
``````

``````public class Main {

private static LocalDate local=LocalDate.now();
public static void main(String[] args) {

int month=local.lengthOfMonth();
System.out.println(month);

}
}
``````

The use of outdated `Calendar` API should be avoided.

In Java8 or higher version, this can be done with `YearMonth`.

Example code:

``````int year = 2011;
int month = 2;
YearMonth yearMonth = YearMonth.of(year, month);
int lengthOfMonth = yearMonth.lengthOfMonth();
System.out.println(lengthOfMonth);
``````

You can use Calendar.getActualMaximum method:

``````Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, month-1);
int numDays = calendar.getActualMaximum(Calendar.DATE);
``````

And month-1 is Because of month takes its original number of month while in method takes argument as below in Calendar.class

``````public int getActualMaximum(int field) {
throw new RuntimeException("Stub!");
}
``````

And the (int field) is like as below.

``````public static final int JANUARY = 0;
public static final int NOVEMBER = 10;
public static final int DECEMBER = 11;
``````

An optimal and performant variance:

``````public static int daysInMonth(int month, int year) {
if (month != 2) {
return 31 - (month - 1) % 7 % 2;
}
else {
if ((year & 3) == 0 && ((year % 25) != 0 || (year & 15) == 0)) { // leap year
return 29;
} else {
return 28;
}
}
}
``````

For more details on the leap algorithm check here

Number of days in particular year – Java 8+ solution

``````Year.now().length()
``````

An alternative solution is to use a `Calendar` object. Get the current date and set the day so it is the first of the month. Then add one month and take away one day to get the last day of the current month. Finally fetch the day to get the number of days in the month.

``````Calendar today = getInstance(TimeZone.getTimeZone("UTC"));

Calendar currMonthLastDay = getInstance(TimeZone.getTimeZone("UTC"));
currMonthLastDay.clear();
currMonthLastDay.set(YEAR, today.get(YEAR));
currMonthLastDay.set(MONTH, today.get(MONTH));
currMonthLastDay.set(DAY_OF_MONTH, 1);

Integer daysInMonth = currMonthLastDay.get(DAY_OF_MONTH);
``````

``````String  MonthOfName = "";
int number_Of_DaysInMonth = 0;

//year,month
numberOfMonth(2018,11); // calling this method to assign values to the variables MonthOfName and number_Of_DaysInMonth

System.out.print("Number Of Days: "+number_Of_DaysInMonth+"   name of the month: "+  MonthOfName );

public void numberOfMonth(int year, int month) {
switch (month) {
case 1:
MonthOfName = "January";
number_Of_DaysInMonth = 31;
break;
case 2:
MonthOfName = "February";
if ((year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0))) {
number_Of_DaysInMonth = 29;
} else {
number_Of_DaysInMonth = 28;
}
break;
case 3:
MonthOfName = "March";
number_Of_DaysInMonth = 31;
break;
case 4:
MonthOfName = "April";
number_Of_DaysInMonth = 30;
break;
case 5:
MonthOfName = "May";
number_Of_DaysInMonth = 31;
break;
case 6:
MonthOfName = "June";
number_Of_DaysInMonth = 30;
break;
case 7:
MonthOfName = "July";
number_Of_DaysInMonth = 31;
break;
case 8:
MonthOfName = "August";
number_Of_DaysInMonth = 31;
break;
case 9:
MonthOfName = "September";
number_Of_DaysInMonth = 30;
break;
case 10:
MonthOfName = "October";
number_Of_DaysInMonth = 31;
break;
case 11:
MonthOfName = "November";
number_Of_DaysInMonth = 30;
break;
case 12:
MonthOfName = "December";
number_Of_DaysInMonth = 31;
}
}
``````

This worked fine for me.

This is a Sample Output

``````import java.util.*;

public class DaysInMonth {

public static void main(String args []) {

Scanner input = new Scanner(System.in);
System.out.print("Enter a year:");

int year = input.nextInt(); //Moved here to get input after the question is asked

System.out.print("Enter a month:");
int month = input.nextInt(); //Moved here to get input after the question is asked

int days = 0; //changed so that it just initializes the variable to zero
boolean isLeapYear = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);

switch (month) {
case 1:
days = 31;
break;
case 2:
if (isLeapYear)
days = 29;
else
days = 28;
break;
case 3:
days = 31;
break;
case 4:
days = 30;
break;
case 5:
days = 31;
break;
case 6:
days = 30;
break;
case 7:
days = 31;
break;
case 8:
days = 31;
break;
case 9:
days = 30;
break;
case 10:
days = 31;
break;
case 11:
days = 30;
break;
case 12:
days = 31;
break;
default:
String response = "Have a Look at what you've done and try again";
System.out.println(response);
System.exit(0);
}

String response = "There are " + days + " Days in Month " + month + " of Year " + year + ".n";
System.out.println(response); // new line to show the result to the screen.
}
} //abhinavsthakur00@gmail.com
``````

``````String date = "11-02-2000";
String[] input = date.split("-");
int day = Integer.valueOf(input);
int month = Integer.valueOf(input);
int year = Integer.valueOf(input);
Calendar cal=Calendar.getInstance();
cal.set(Calendar.YEAR,year);
cal.set(Calendar.MONTH,month-1);
cal.set(Calendar.DATE, day);
//since month number starts from 0 (i.e jan 0, feb 1),
//we are subtracting original month by 1
int days = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
System.out.println(days);
``````