专业的JAVA编程教程与资源

网站首页 > java教程 正文

玩转Java for循环（java循环foreach）

temp10 2024-11-03 15:06:25 java教程 13 ℃ 0 评论

1 for循环介绍

for循环语法格式

for(①初始化语句;②循环条件判断语句;④循环迭代语句){
    ③循环体;
}
  • 循环条件判断语句必须是boolean类型的变量或者表达式

for循环执行流程

玩转Java for循环（java循环foreach）

①②③④②③④②③④

  1. 执行①初始化语句
  2. 执行②循环条件判断语句
    1. 如果②循环条件判断语句执行结果为true，那么就执行③循环体语句，然后执行④循环迭代语句，然后再重复执行②循环条件判断语句、③循环体语句、④循环迭代语句
    2. 如果②循环条件判断语句执行结果为false，那么就立刻结束当前循环


2 for循环使用

需求：使用for循环输出5个Hello World

  1. 编辑ForLoop.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * for循环使用
 * 需求：使用for循环输出5个Hello World
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 15:56
 * @since Java21
 */
public class ForLoop {
    public static void main(String[] args) {
        System.out.println("1.不使用for循环实现输出5个Hello World");

        System.out.println("Hello World");
        System.out.println("Hello World");
        System.out.println("Hello World");
        System.out.println("Hello World");
        System.out.println("Hello World");

        System.out.println("2.使用for循环实现输出5个Hello World");
        for (int i = 0; i < 5; i++) {
            System.out.println("Hello World");
        }
    }
}
  1. 运行ForLoop.java

程序运行结果

3 for循环使用注意事项

3.1 for循环使用注意事项1

for循环中循环条件判断左边的初始化语句和循环条件判断的右边的循环迭代语句可以写到其他地方，但是两边的分号不能省略

for(;循环判断条件;){
    
}
  1. 编辑ForLoopWarning1.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * for循环使用注意事项1
 * for循环中循环条件判断左边的初始化语句和循环条件判断的右边的循环迭代语句可以写到其他地方，但是两边的分号不能省略
 * for(;循环判断条件;){
 * }
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 16:01
 * @since Java21
 */
public class ForLoopWarning1 {
    public static void main(String[] args) {
        //循环初始化语句
        int i = 0;
        //for循环
        for (; i < 5; ) {

            //循环体
            System.out.println("跟光磊学Java从小白到架构师");
            //循环迭代语句
            i++;
        }

        //i是5的时候，循环条件不成立 因此 i = 5
        System.out.println("i = " + i);
    }
}
  1. 运行ForLoopWarning1.java

程序运行结果

3.2 for循环使用注意事项2

循环的初始化语句可以有多条初始化语句，但是要求数据类型一样，并且中间使用逗号隔开，循环迭代语句也可以有多条语句，多条语句中间使用逗号(,)隔开。

  1. 编辑ForLoopWarning2.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * for循环使用注意事项2
 * 循环的初始化语句可以有多条初始化语句，但是要求数据类型一样，并且中间使用逗号隔开，
 * 循环迭代语句也可以有多条语句，多条语句中间使用逗号(,)隔开。
 * @author tony 18601767221@163.com
 * @version 2024/10/17 16:04
 * @since Java21
 */
public class ForLoopWarning2 {
    public static void main(String[] args) {
        for (int i = 0, j = 0; i < 3; i++, j += 2) {
            /*
                i = 0 j = 0
                i = 1 j = 2
                i = 2 j = 4
             */
            System.out.println("i = " + i + " j = " + j);
        }
    }
}
  1. 运行ForLoopWarning2.java

程序运行结果

4 for循环案例

4.1 打印输出26个小写字母

需求：控制台打印输出26个小写字母

  1. 编辑PrintLowercase.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * 打印输出26个小写字母
 * 需求：控制台打印输出26个小写字母
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 16:27
 * @since Java21
 */
public class PrintLowercase {
    public static void main(String[] args) {
        System.out.println("1.实现方式1：");
        //a的ASCII编码值是97
        //z的ASCII编码值是122
        for (int i = 97; i <= 122; i++) {
            System.out.print((char) i + "\t");
        }
        //换行
        System.out.println();

        System.out.println("2.实现方式2：");
        for (char ch = 'a'; ch <= 'z'; ch++) {
            System.out.print(ch + "\t");
        }
        //换行
        System.out.println();

        System.out.println("3.实现方式3：");
        for (int i = 1; i <= 26; i++) {
            System.out.print((char) (i + 96) + "\t");
        }
    }
}
  1. 运行PrintLowercase.java

程序运行结果

4.2 打印输出1到100和100到1

需求：控制台打印输出1到100和100到1，每行显示10个数字

  1. 编辑Print1To100And100To1.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * 打印1到100和100到1
 * 需求：控制台打印输出1到100和100到1，每行显示10个数字
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 16:28
 * @since Java21
 */
public class Print1To100And100To1 {
    public static void main(String[] args) {
        System.out.println("******************1.打印1到100******************");
        for (int i = 1; i <= 100; i++) {
            System.out.print(i + "\t");
            //每行显示10个数字
            if (i % 10 == 0) {
                System.out.println();
            }
        }

        //换行
        System.out.println();
        System.out.println("******************2.打印100到1******************");
        int count = 0;
        for (int i = 100; i >= 1; i--) {
            System.out.print(i + "\t");
            count++;

            //每行显示10个数字
            if (count % 10 == 0) {
                System.out.println();
            }
        }

    }
}
  1. 运行Print1To100And100To1.java

程序运行结果



4.3 打印偶数并统计

需求：打印1到100的偶数，并且统计偶数的个数以及偶数的累加和

  1. 编辑PrintEvenNumberStatistics.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * 打印偶数并统计
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 16:33
 * @since Java21
 */
public class PrintEvenNumberStatistics {
    public static void main(String[] args) {
        //偶数和
        int evenNumberSum = 0;
        //偶数个数
        int evenNumberCount = 0;

        //从1遍历到100
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                //偶数和累加
                evenNumberSum += i;
                //偶数个数累加
                evenNumberCount++;
            }
        }
        System.out.printf("1到100的偶数和是%d，偶数个数是%d", evenNumberSum, evenNumberCount);
    }
}
  1. 运行PrintEvenNumberStatistics.java

程序运行结果

4.4 打印奇数并统计

需求：打印1-100以内的奇数，并且统计奇数的个数以及奇数的累加和

  1. 编辑PrintOddNumberStatistics.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * 打印奇数并统计
 * 需求：打印1-100以内的奇数，并且统计奇数的个数以及奇数的累加和
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 16:35
 * @since Java21
 */
public class PrintOddNumberStatistics {
    public static void main(String[] args) {
        //奇数累加和
        int oddNumberSum = 0;
        //奇数个数
        int oddNumberCount = 0;

        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0) {
                //奇数累加和累加
                oddNumberSum += i;
                //奇数个数累加
                oddNumberCount++;
            }
        }
        System.out.printf("1到100的奇数和是%d，奇数个数是%d", oddNumberSum, oddNumberCount);
    }
}
  1. 运行PrintOddNumberStatistics.java

程序运行结果

4.5 打印满足条件整数并且统计

需求：打印1-100之间所有9的倍数的整数，统计个数以及总和

  1. 编辑PrintStatisticsCountGetSum.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * 打印满足条件整数并且统计个数以及总和
 * 需求：打印1-100之间所有9的倍数的整数，统计个数以及总和
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 16:37
 * @since Java21
 */
public class PrintStatisticsCountGetSum {
    public static void main(String[] args) {
        //被9整除的个数
        int count = 0;
        //被9整除的累加和
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 9 == 0) {
                //被9整除的累加和累加
                sum += i;
                //被9整除的个数累加
                count++;
            }
        }
        System.out.printf("1到100之间所有9的倍数的整数个数是%d个，总和是%d", count, sum);
    }
}
  1. 运行PrintStatisticsCountGetSum.java

程序运行结果

4.6 打印指定的表达式

需求：打印如下指定表达式

0 + 5  = 5 
1 + 4  = 5 
2 + 3  = 5 
3 + 2  = 5 
4 + 1  = 5

分析：

  • 第一个操作数从0开始，依次递增，最大4
  • 第二个操作数从5开始，依次递减，最小是1
  • 第三个操作数=第一个操作数+第二个参数
  1. 编辑PrintExpression.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * 打印指定的表达式
 * 0 + 5  = 5
 * 1 + 4  = 5
 * 2 + 3  = 5
 * 3 + 2  = 5
 * 4 + 1  = 5
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 16:39
 * @since Java21
 */
public class PrintExpression {

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            //第一个操作数从0开始，依次递增，最大4
            int left = i;
            //第二个操作数从5开始，依次递减，最小是1
            int right = 5 - i;
            //第三个操作数=第一个操作数+第二个参数
            int result = left + right;
            System.out.printf("%d + %d = %d\n", left, right, result);
        }
    }
}
  1. 运行PrintExpression.java

程序运行结果


4.7 打印满足条件的字符串

需求：打印100-150之间的数

  • 如果这个数被3整除打印 foo
  • 如果这个数被5整除打印biz
  • 如果这个数被7整除打印baz


  1. 编辑PrintFooBizBaz.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * 打印满足条件的字符串
 * 需求：打印100-150之间的数
 * ● 如果这个数被3整除打印foo
 * ● 如果这个数被5整除打印biz
 * ● 如果这个数被7整除打印baz
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 18:03
 * @since Java21
 */
public class PrintFooBizBaz {
    public static void main(String[] args) {
        for (int i = 100; i <= 150; i++) {
            System.out.print(i + "\t");
            if (i % 3 == 0) {
                System.out.print("foo\t");
            }
            if (i % 5 == 0) {
                System.out.print("biz\t");
            }
            if (i % 7 == 0) {
                System.out.print("baz\t");
            }
            //换行
            System.out.println();
        }
    }
}
  1. 运行PrintFooBizBaz.java

程序运行结果

4.8 统计满足条件的数字

需求：键盘输入两个数字表示一个范围，统计该范围中既能被3整除又能被5整除数字的数量

  1. 编辑StatisticsBetweenAndCount.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

import java.util.Scanner;

/**
 * 统计满足条件的数字
 * 需求：键盘输入两个数字表示一个范围，统计该范围中既能被3整除又能被5整除数字的数量
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 18:12
 * @since Java21
 */
public class StatisticsBetweenAndCount {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入，也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入开始的数字");
        int startNumber = scanner.nextInt();
        System.out.println("请输入结束的数字");
        int endNumber = scanner.nextInt();
        int count = 0;
        for (int i = startNumber; i <= endNumber; i++) {
            if (i % 3 == 0 && i % 5 == 0) {
                count++;
            }
        }
        System.out.printf("%d到%d之间既能被3整除又能被5整除数字的数量是%d", startNumber, endNumber, count);
        //关闭Scanner
        scanner.close();
    }
}
  1. 运行StatisticsBetweenAndCount.java

程序运行结果

4.9 计算指定表达式的值

需求：计算 1-1/2+1/3-1/4...+1/99-1/100的和

分析：

  • 一共有100项，分子为1，分母从1到100
  • 分母是奇数时做加法
  • 分母是偶数时做减法
  • 要把表达式的1写成1.0才能得到比较精确的值，因为1/2和1/4等等都等于0
  1. 编辑CalculatorExpression.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * 计算指定表达式的值
 * 需求：计算 1-1/2+1/3-1/4...+1/99-1/100的和
 * 分析：
 * ● 一共有100项，分子为1，分母从1到100
 * ● 分母是奇数时做加法
 * ● 分母是偶数时做减法
 * ● 要把表达式的1写成1.0才能得到比较精确的值，因为1/2和1/4等等都等于0
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 18:14
 * @since Java21
 */
public class CalculatorExpression {
    public static void main(String[] args) {
        //累加和
        double sum = 0;
        //一共100项
        for (int i = 1; i <= 100; i++) {
            //分母是偶数做减法
            if (i % 2 == 0) {
                sum -= 1.0 / i;
            }
            //分母是奇数做加法
            else {
                sum += 1.0 / i;
            }
        }
        System.out.println("表达式1-1/2+1/3-1/4...+1/99-1/100的和计算的结果是" + sum);

    }
}
  1. 运行CalculatorExpression.java

程序运行结果

4.10 求三位数水仙花数

需求：控制台打印输出三位数的水仙花数

分析：水仙花数指的是每个位上的数字的 3次幂之和等于它本身

三位的水仙花数共有4个：153，370，371，407


  1. 编辑NarcissisticNumber.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * 求三位数水仙花数
 * 需求：控制台打印输出三位数的水仙花数
 * 分析：水仙花数指的是每个位上的数字的 3次幂之和等于它本身
 * 三位的水仙花数共有4个：153，370，371，407
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 18:18
 * @since Java21
 */
public class NarcissisticNumber {
    public static void main(String[] args) {
        System.out.print("三位的水仙花数是");
        for (int i = 100; i < 1000; i++) {
            //获取每个数的个位、十位、百位
            int unit = i / 1 % 10;
            int decade = i / 10 % 10;
            int hundred = i / 100 % 10;
            //水仙花数：每个位上的数字的 3次幂之和等于它本身
            int sum = unit * unit * unit + decade * decade * decade + hundred * hundred * hundred;
            if (i == sum) {
                //三位的水仙花数共有4个：153，370，371，407
                System.out.print(i + " ");
            }
        }
    }
}
  1. 运行NarcissisticNumber.java

程序运行结果

4.11 打印符号条件的四位整数

需求：循环结构for语句打印符合条件的四位整数

条件1： 打印出四位整数中 个位+十位=百位+千位，其中个位为偶数，千位为奇数的数字，并且打印出符合条件的数字

条件2：符合条件的数字，每行显示5个，使用空格隔开


  1. 编辑PrintThousandNumber.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * 打印符号条件的四位整数
 * 需求：循环结构for语句打印符合条件的四位整数
 * 条件1： 打印出四位整数中 个位+十位=百位+千位，其中个位为偶数，千位为奇数的数字，并且打印出符合条件的数字
 * 条件2：符合条件的数字，每行显示5个，使用空格隔开
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 18:20
 * @since Java21
 */
public class PrintThousandNumber {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 1000; i <= 9999; i++) {
            //个位
            int unit = i / 1 % 10;
            //十位
            int decade = i / 10 % 10;
            //百位
            int hundred = i / 100 % 10;
            //千位
            int thousand = i / 1000 % 10;
            //个位+十位=百位+千位，其中个位为偶数，千位为奇数的数字
            if (unit + decade == hundred + thousand && unit % 2 == 0 && thousand % 2 != 0) {
                System.out.print(i + " ");
                count++;
                //每打印5个数字就换行
                if (count % 5 == 0) {
                    System.out.println();
                }
            }
        }
    }
}
  1. 运行PrintThousandNumber.java

程序运行结果

4.12 求五位数的回文数

需求：求五位数的回文数，并统计回文数的数量

分析：

五位数：10000-99999之间的整数

回文数：一个数字从左往右读和从右往左读还是同一个数字，例如12321就是一个回文数，12345不是回文数

回文数的特征：个位等于万位，十位等于千位


  1. 编辑PalindromeNumber.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

/**
 * 求五位数的回文数
 * 需求：求五位数的回文数，并统计回文数的数量
 * 分析：
 * 五位数：10000-99999之间的整数
 * 回文数：一个数字从左往右读和从右往左读还是同一个数字，例如12321就是一个回文数，12345不是回文数
 * 回文数的特征：个位等于万位，十位等于千位
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 18:23
 * @since Java21
 */
public class PalindromeNumber {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 10000; i < 99999; i++) {
            //获取五位数的个位、十位、千位、万位
            int unit = i / 1 % 10;
            int decade = i / 10 % 10;
            int thousand = i / 1000 % 10;
            int tenThousand = i / 100000 % 10;
            // 回文数的特征：个位等于万位，十位等于千位
            if (unit == tenThousand && decade == thousand) {
                System.out.print(i + " ");
                count++;
                //每行打印5个
                if (count % 5 == 0) {
                    System.out.println();
                }
            }
        }
        System.out.println("五位数的回文数个数是" + count);
    }
}
  1. 运行PalindromeNumber.java

程序运行结果

4.13 求最大公约数

需求：提示用户从键盘输入两个整数，然后求这两个整数的最大公约数

分析：

公约数：两个整数同时能整除的数

例如 12 可以被1，2，3，4，6，12整除

20可以被1，2，4，5，10，20整除

12和20的公约数是1，2，4 最大公约数是4


  1. 编辑GreatestCommonDivisor.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

import java.util.Scanner;

/**
 * 求最大公约数
 * 需求：提示用户从键盘输入两个整数，然后求这两个整数的最大公约数
 * 分析：
 * 公约数：两个整数同时能整除的数
 * 例如 12 可以被1，2，3，4，6，12整除
 * 20可以被1，2，4，5，10，20整除
 * 12和20的公约数是1，2，4 最大公约数是4
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 18:25
 * @since Java21
 */
public class GreatestCommonDivisor {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入，也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int number1 = scanner.nextInt();
        System.out.println("请输入第二个整数");
        int number2 = scanner.nextInt();

        /*
            12 可以被1，2，3，4，6，12整除
            20可以被1，2，4，5，10，20整除
            12和20的公约数是1，2，4 最大公约数是4
         */
        //1. 先求出两个数的最小值，因为最大的公约数小于等于两个数的最小值
        int min = number1 < number2 ? number1 : number2;

        //2.求公约数
        System.out.printf("%d和%d的公约数是", number1, number2);
        for (int i = min; i > 0; i--) {
            if (number1 % i == 0 && number2 % i == 0) {
                System.out.print(i + " ");
            }
        }
        //换行
        System.out.println();

        //3.求最大公约数
        System.out.println("******************实现方式1******************");
        int greatestCommonDivisor = 0;
        for (int i = 1; i <= min; i++) {
            if (number1 % i == 0 && number2 % i == 0) {
                greatestCommonDivisor = i;
            }
        }

        System.out.printf("%d和%d的最大公约数是%d\n", number1, number2, greatestCommonDivisor);

        System.out.println("******************实现方式2******************");
        for (int i = min; i >= 1; i--) {
            if (number1 % i == 0 && number2 % i == 0) {
                System.out.printf("%d和%d的最大公约数是%d\n", number1, number2, i);
                break;
            }
        }
        //关闭Scanner
        scanner.close();
    }
}
  1. 运行GreatestCommonDivisor.java

程序运行结果

4.14 求最小公倍数

需求：提示用户从键盘输入两个整数，然后求这两个整数的最小公倍数

分析：

公倍数 ：同时是两个整数的倍数

例如 12的倍数12，24，36，48，60…

20的倍数20，40，60，80…

12和20的最小公倍数是60


  1. 编辑LowestCommonMultiple.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

import java.util.Scanner;

/**
 * 求最小公倍数
 * 需求：提示用户从键盘输入两个整数，然后求这两个整数的最小公倍数
 * 分析：
 * 公倍数 ：同时是两个整数的倍数
 * 例如 12的倍数12，24，36，48，60…
 * 20的倍数20，40，60，80…
 * 12和20的最小公倍数是60
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 18:30
 * @since Java21
 */
public class LowestCommonMultiple {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入，也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int number1 = scanner.nextInt();
        System.out.println("请输入第二个整数");
        int number2 = scanner.nextInt();

        /*
            公倍数 ：同时是两个整数的倍数
            例如 12的倍数12，24，36，48，60…
            20的倍数20，40，60，80…
            12和20的最小公倍数是60
         */

        int start = number1 * number2;
        int end = number1 > number2 ? number1 : number2;
        //2.求公倍数
        System.out.printf("%d和%d的公倍数是", number1, number2);
        for (int i = start; i >= end; i--) {
            if (i % number1 == 0 && i % number2 == 0) {
                System.out.print(i + " ");
            }
        }
        //换行
        System.out.println();
        //3.求最小公倍数
        System.out.print("实现方式1：");
        int lowestCommonMultiple = start;
        for (int i = start; i >= end; i--) {
            if (i % number1 == 0 && i % number2 == 0) {
                lowestCommonMultiple = i;
            }
        }
        System.out.printf("%d和%d的最小公倍数是%d\n", number1, number2, lowestCommonMultiple);

        System.out.print("实现方式2：");
        for (int i = end; i <= start; i++) {
            if (i % number1 == 0 && i % number2 == 0) {
                System.out.printf("%d和%d的最小公倍数是%d\n", number1, number2, i);
                //结束for循环
                break;
            }
        }

        //关闭Scanner
        scanner.close();

    }
}
  1. 运行LowestCommonMultiple.java

程序运行结果

4.15 打印指定年份每个月的天数以及总天数

需求：打印指定年份每个月的天数以及总天数

分析：

1,3,5,7,8,10,12 31天

4,6,9,11 30天

2 平年28天 闰年29天

闰年条件1：年份可以被4整除，但是不可以被100整除

闰年条件2：年份可以被400整除

闰年满足条件1或者条件2即可


  1. 编辑PrintDays.java
package net.ittimeline.java.core.foundational.control.loop.forloop;

import java.util.Scanner;

/**
 * 打印指定年份每个月的天数以及总天数
 * 需求：打印指定年份每个月的天数以及总天数
 * 分析：
 * 1,3,5,7,8,10,12 31天
 * 4,6,9,11 30天
 * 2 平年28天 闰年29天
 * 闰年条件1：年份可以被4整除，但是不可以被100整除
 * 闰年条件2：年份可以被400整除
 * 闰年满足条件1或者条件2即可
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/17 18:36
 * @since Java21
 */
public class PrintDays {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入，也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入年份");
        int year = scanner.nextInt();
        //平年28天 闰年29天
        int february = 28;
        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
            february = 29;
        }

        //一年的总天数
        int totalDays = 0;
        //每个月的天数
        int dayOfMonth = 0;
        //一年有12个月
        for (int i = 1; i <= 12; i++) {
            // 1,3,5,7,8,10,12 31天
            if (i == 1 || i == 3 || i == 5 || i == 7 || i == 8 || i == 10 || i == 12) {
                dayOfMonth = 31;
            }
            // 4,6,9,11 30天
            else if (i == 4 || i == 6 || i == 9 || i == 11) {
                dayOfMonth = 30;
            } else {
                dayOfMonth = february;
            }
            System.out.printf("%d月有%d天\n", i, dayOfMonth);
            totalDays += dayOfMonth;
        }
        System.out.printf("%d年一共有%d天\n", year, totalDays);
        //关闭Scanner
        scanner.close();
    }
}
  1. 运行PrintDays.java

程序运行结果

Tags：

猜你喜欢

本文暂时没有评论，来添加一个吧(●'◡'●)

欢迎 你 发表评论:

最近发表
标签列表