Java Program to Find if a Given Year is a Leap Year

Leap Year contains 366 days, which comes once every four years. In this article, we will learn how to write the leap year program in Java.

Facts for Leap Year

Every leap year corresponds to these facts : 

• A century year is a year ending with 00. A century year is a leap year only if it is divisible by 400.
• A leap year (except a century year) can be identified if it is exactly divisible by 4.
• A century year should be divisible by 4 and 100 both.
• A non-century year should be divisible only by 4.

Methods for Leap Year Program in Java

There are certain methods for leap year programs in Java are mentioned below:

1. Without Using Scanner Class
2. Using Scanner Class
3. Using Ternary Operator
4. Using In-built isLeap() Method

1. Without Using Scanner Class

As the name suggests here the user is bound not to select a year of his choice.

Below is the Java program to implement the approach:

Java

// Java program to find a leap year
// Importing Classes/Files
import java.io.*;

// Class for leap-year dealing
public class GeeksforGeeks {
    // Method to check leap year
    public static void isLeapYear(int year)
    {
        // flag to take a non-leap year by default
        boolean is_leap_year = false;

        // If year is divisible by 4
        if (year % 4 == 0) {
            is_leap_year = true;

            // To identify whether it is a
            // century year or not
            if (year % 100 == 0) {
                // Checking if year is divisible by 400
                // therefore century leap year
                if (year % 400 == 0)
                    is_leap_year = true;
                else
                    is_leap_year = false;
            }
        }

        // We land here when corresponding if fails
        // If year is not divisible by 4
        else

            // Flag dealing-  Non leap-year
            is_leap_year = false;

        if (!is_leap_year)
            System.out.println(year + " : Non Leap-year");
        else
            System.out.println(year + " : Leap-year");
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Calling our function by
        // passing century year not divisible by 400
        isLeapYear(2000);

        // Calling our function by
        // passing Non-century year
        isLeapYear(2002);
    }
}

Output

2000 : Leap-year
2002 : Non Leap-year

The complexity of  the above method

Time Complexity: O(1)

Auxiliary Space: O(1)

2000 is a century year divisible by 100 and 4. 2002 is not divisible by 4, therefore not a leap year. 

2. Using Scanner Class

Here the user is provided the flexibility to enter the year of their own choice as Scanner Class is imported here rest of the if-else blocks are also combined in a single statement to check if the input year is a leap year.

Below is the Java program to implement the approach:

Java

// Java program to check Leap-year
// by taking input from user

// Importing Classes/Files
import java.io.*;
// Importing Scanner Class
import java.util.Scanner;

// Class to check leap-year or not
public class GFG {

    // Driver code
    public static void main(String[] args)
    {
        // Considering any random year
        int year;

        // Taking input from user using Scanner Class
        // scn is an object made of Scanner Class
        Scanner scn = new Scanner(System.in);
        year = scn.nextInt();

        // 1st condition check- It is century leap year
        // 2nd condition check- It is leap year and not
        // century year
        if ((year % 400 == 0)
            || ((year % 4 == 0) && (year % 100 != 0))) {

            // Both conditions true- Print leap year
            System.out.println(year + " : Leap Year");
        }

        else {
            // Any condition fails- Print Non-leap year
            System.out.println(year + " : Non - Leap Year");
        }
    }
}

Input:

2012

Output:

2012 : Leap Year

The complexity of  the above method

Time Complexity: O(1)

Auxiliary Space: O(1)

3. Using Ternary Operator

Ternary Operator is used to reduce the if-else statements. The ternary operator takes three operands, a boolean condition, an expression to execute if the condition is true, and an expression to execute if false.

Below is the Java program to implement the approach:

Java

// Java program to find a leap year

// Importing Classes/Files
import java.io.*;

// Class for leap-year dealing
public class GeeksforGeeks {

    // Method to check leap year
    public static void isLeapYear(int year)
    {
        // flag to take a non-leap year by default
        boolean is_leap_year = false;

        is_leap_year = (year % 4 == 0 && year % 100 != 0
                        || year % 400 == 0)
                           ? true
                           : false;
        if (!is_leap_year)
            System.out.println(year + " : Non Leap-year");
        else
            System.out.println(year + " : Leap-year");
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Calling our function by
        // passing century year not divisible by 400
        isLeapYear(2000);

        // Calling our function by
        // passing Non-century year
        isLeapYear(2002);
    }
}

Output

2000 : Leap-year
2002 : Non Leap-year

The complexity of  the above method

Time Complexity: O(1)

Auxiliary Space: O(1)

4. Using In-built isLeap() Method

Java has an in-built isLeap() method to check if the input year is a leap year or not.

Below is the Java program to implement the approach:

Java

// Java program to find a leap year

// Importing Classes/Files
import java.io.*;
import java.time.*;
import java.util.*;

// Class for leap-year dealing
public class GeeksforGeeks {

    // Method to check leap year
    public static void isLeapYear(int year)
    {
        // flag to take a non-leap year by default
        boolean is_leap_year = false;

        Year checkyear = Year.of(year);

        is_leap_year = checkyear.isLeap();

        if (!is_leap_year)
            System.out.println(year + " : Non Leap-year");
        else
            System.out.println(year + " : Leap-year");
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Calling our function by
        // passing century year not divisible by 400
        isLeapYear(2000);

        // Calling our function by
        // passing Non-century year
        isLeapYear(2002);
    }
}

Output

2000 : Leap-year
2002 : Non Leap-year

The complexity of  the above method

Time Complexity: O(1)

Auxiliary Space: O(1)