Java 中的闰年程序

2025年3月31日 | 阅读 7 分钟

在本教程中，我们将讨论如何识别给定年份是否为闰年。但在继续之前，我们将先讨论闰年。

闰年

闰年，也称为二月年或闰日年，比其他年份多一天（总共 366 天）。通常，它每 4 年出现一次。2008 年、2012 年、2016 年等是闰年的例子。

验证规则

世纪年（以 00 结尾的年份）只有在能被 400 整除时才是闰年。例如，1700 年不是闰年，因为它不能被 400 整除。2000 年是闰年，因为它能被 400 整除。
如果一个非世纪年能被 4 整除，那么它就是闰年。

例如，1996 年是闰年，1999 年不是闰年，因为前者能被 4 整除，而后者不能被 4 整除。

实现：不使用 Scanner 类

观察上述规则的实现。

文件名： LeapYear.java

public class LeapYear 
{

// a method that checks whether the 
// year y is a leap year or not
boolean isLeapYr(int y)
{
// if condition that handles
// the century year
if((y % 100) == 0)
{
    if((y % 400) == 0)
    {
        return true;
    }
    else
    {
        return false;
    }

}

// if condition that handles the
// non century year
if((y % 4) == 0)
{
    return true;
}

return false;
}

// main method
public static void main(String argvs[])
{
// creating an object of the class LeapYear
LeapYear obj = new LeapYear();

// input 1
int year = 1996;

if(obj.isLeapYr(year))
{
    System.out.println("The year " + year + " is a leap year.");
}
else
{
    System.out.println("The year " + year + " is not a leap year.");
}

System.out.println();

// input 2
year = 1999;

if(obj.isLeapYr(year))
{
    System.out.println("The year " + year + " is a leap year.");
}
else
{
    System.out.println("The year " + year + " is not a leap year.");
}

System.out.println();

// input 3
year = 1700;

if(obj.isLeapYr(year))
{
    System.out.println("The year " + year + " is a leap year.");
}
else
{
    System.out.println("The year " + year + " is not a leap year.");
}

System.out.println();

// input 4
year = 2000;

if(obj.isLeapYr(year))
{
    System.out.println("The year " + year + " is a leap year.");
}
else
{
    System.out.println("The year " + year + " is not a leap year.");
}




}
}

输出

The year 1996 is a leap year.

The year 1999 is not a leap year.

The year 1700 is not a leap year.

The year 2000 is a leap year.

复杂度分析：程序的 O(1) 时间复杂度。程序的 O(1) 空间复杂度。

实现：使用 Scanner 类

在这里，用户可以灵活地输入自己选择的年份，然后程序会测试输入的数字是否为闰年。此外，我们还可以使用一个 if 语句来完成我们的工作，而不是多个 if 语句。其实现已在下面的程序中说明。

文件名： LeapYear1.java

// importing the Scanner Class
import java.util.Scanner;

public class LeapYear1 
{

// a method that checks whether the 
// year y is a leap year or not
boolean isLeapYr(int y)
{
// if condition that handles
// the century year as well as the non-century year
if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
{
return true;
}

return false;
}

// main method
public static void main(String argvs[])
{
// creating an object of the class LeapYear1
LeapYear1 obj = new LeapYear1();

// we are taking input using the Scanner Class

Scanner scnObj = new Scanner(System.in);

System.out.println("Enter Year ");

// input 1
int year = scnObj.nextInt();

if(obj.isLeapYr(year))
{
    System.out.println("The year " + year + " is a leap year.");
}
else
{
    System.out.println("The year " + year + " is not a leap year.");
}

System.out.println();

System.out.println("Enter Year ");

// input 2
year = scnObj.nextInt();

if(obj.isLeapYr(year))
{
    System.out.println("The year " + year + " is a leap year.");
}
else
{
    System.out.println("The year " + year + " is not a leap year.");
}

System.out.println();

System.out.println("Enter Year ");

// input 3
year = scnObj.nextInt();

if(obj.isLeapYr(year))
{
    System.out.println("The year " + year + " is a leap year.");
}
else
{
    System.out.println("The year " + year + " is not a leap year.");
}

System.out.println();

System.out.println("Enter Year ");

// input 4
year = scnObj.nextInt();

if(obj.isLeapYr(year))
{
    System.out.println("The year " + year + " is a leap year.");
}
else
{
    System.out.println("The year " + year + " is not a leap year.");
}




}
}

输出

Enter Year
1996
The year 1996 is a leap year.

Enter Year
1999
The year 1999 is not a leap year.

Enter Year
1700
The year 1700 is not a leap year.

Enter Year
2000
The year 2000 is a leap year.

复杂度分析：程序的 O(1) 时间复杂度。程序的 O(1) 空间复杂度。

实现：查找范围内的闰年

我们还可以借助 for 循环查找给定范围内的闰年。观察下面的程序。

文件名： LeapYear2.java

public class LeapYear2
{

// a method that checks whether the 
// year y is a leap year or not
boolean isLeapYr(int y)
{
// if condition that handles
// the century year as well as the non-century year
if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
{
return true;
}

return false;
}

// main method
public static void main(String argvs[])
{
// creating an object of the class LeapYear2
LeapYear2 obj = new LeapYear2();

// we will be finding the leap years
// within the range r1 and r2 (r1 and r2 inclusive)
int r1 = 2000;
int r2 = 2150;

System.out.println("Finding leap years within the range " + r1 + " and " + r2);
for(int i = r1; i <= r2; i++)
{
    if(obj.isLeapYr(i))
    {
        System.out.print(i + " ");
    }
}




}
}

输出

Finding leap years within the range 2000 and 2150
2000 2004 2008 2012 2016 2020 2024 2028 2032 2036 2040 2044 2048 2052 2056 2060 2064 2068 2072 2076 2080 2084 2088 2092 2096 2104 2108 2112 2116 2120 2124 2128 2132 2136 2140 2144 2148

复杂度分析：程序的空间和时间复杂度与前一个程序相同。

实现：使用字符串查找范围

我们还可以将年份转换为字符串并检查闰年。请看以下代码。

文件名： LeapYear3.java

public class LeapYear3
{

// a method that checks whether the 
// year y is a leap year or not
boolean isLeapYr(String y)
{
int size = y.length();
int temp = 0;


// handling the case when years contain 4 or more than 4 digits
if(size >= 4)
{
    char ch1 = y.charAt(size - 1);
    char ch2 = y.charAt(size - 2);
    char ch3 = y.charAt(size - 3);
    char ch4 = y.charAt(size - 4);
    
    // for handling the century years
    if((ch1 == '0') && (ch2 == '0'))
    {
        
        String st1 = "" + ch4 + ch3;
        temp = Integer.parseInt(st1);
    }
    
    // for handling the non- century years
    else
    {
        String st1 = "" + ch2 + ch1;
        temp = Integer.parseInt(st1);
    }
}
// handling the case when years contain 3 digits
else if(size == 3)
{
    char ch1 = y.charAt(size - 1);
    char ch2 = y.charAt(size - 2);
    char ch3 = y.charAt(size - 3);
    
    // for handling the century years
    if((ch1 == '0') && (ch2 == '0'))
    {
        
        String st1 = "" + ch3;
        temp = Integer.parseInt(st1);
    }
    // for handling the non-century years
    else
    {
        String st1 = "" + ch2 + ch1;
        temp = Integer.parseInt(st1);
    }    
}

else if(size == 2)
{
char ch1 = y.charAt(size - 1);
char ch2 = y.charAt(size - 2);    
String st1 = "" + ch2 + ch1;
temp = Integer.parseInt(st1);
}

else
{
char ch1 = y.charAt(size - 1);
String st1 = "" + ch1;
temp = Integer.parseInt(st1);    
}

return ((temp % 4) == 0);
}

// main method
public static void main(String argvs[])
{
// creating an object of the class LeapYear3
LeapYear3 obj = new LeapYear3();

// we will be finding the leap years
// within the range r1 and r2 (r1 and r2 inclusive)
int r1 = 2000;
int r2 = 2150;

System.out.println("Finding leap years within the range " + r1 + " and " + r2);
for(int i = r1; i <= r2; i++)
{
    if(obj.isLeapYr(String.valueOf(i)))
    {
        System.out.print(i + " ");
    }
}




}
}

输出

Finding leap years within the range 2000 and 2150
2000 2004 2008 2012 2016 2020 2024 2028 2032 2036 2040 2044 2048 2052 2056 2060 2064 2068 2072 2076 2080 2084 2088 2092 2096 2104 2108 2112 2116 2120 2124 2128 2132 2136 2140 2144 2148

复杂度分析：该程序将整数转换为字符串，这需要 O(D) 的时间。此外，程序使用变量 *y* 存储该字符串，这也需要 O(D) 的空间。因此，程序的时间和空间复杂度均为 O(D)，其中 D 是我们正在检查闰年的年份中数字的总位数。

注意：与其它实现相比，使用字符串的实现耗费空间和时间最多。但是，如果包含年份的输入数组类型为 String，则此方法可能很有用。

下一主题Java 在线编译器 GDB

Java 中的闰年程序

闰年

验证规则

实现：不使用 Scanner 类

实现：使用 Scanner 类

实现：查找范围内的闰年

实现：使用字符串查找范围

注意：与其它实现相比，使用字符串的实现耗费空间和时间最多。但是，如果包含年份的输入数组类型为 String，则此方法可能很有用。

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的闰年程序

闰年

验证规则

实现：不使用 Scanner 类

实现：使用 Scanner 类

实现：查找范围内的闰年

实现：使用字符串查找范围

注意：与其它实现相比，使用字符串的实现耗费空间和时间最多。但是，如果包含年份的输入数组类型为 String，则此方法可能很有用。

相关帖子

如何在 Windows 中安装多个 JDK

使用 forEach 循环在 Java 中展平数组流

Java 中函数和方法的区别

Java 中 ToIntFunction 接口及示例

Advantages of Inheritance in Java

DecimalFormat getPositiveSuffix() method in Java

Java 中的递归构造函数调用

Java 中的用户线程与守护线程

Java NLP

Java EE

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器