【04】JAVASE-循环语句【从零开始学JAVA】

用户4919348

发布于 2024-05-25 13:56:09

810

发布于 2024-05-25 13:56:09

文章被收录于专栏：波波烤鸭

Java零基础系列课程-JavaSE基础篇

Lecture：波哥

Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机，Java 仍是企业和开发人员的首选开发平台。

四、循环语句

循环语句就是重复执行某块代码，能够大大提高我们的效率

/**
	 * 输出一个 好好学习，天天向上 这个信息到控制台上
	 * 输出两遍
	 *    10遍呢
	 *    100遍
	 *    10000遍？
	 * @param args
	 */
	public static void main(String[] args) {
		/*System.out.println("好好学习，天天向上");
		System.out.println("好好学习，天天向上");
		System.out.println("好好学习，天天向上");
		System.out.println("好好学习，天天向上");
		System.out.println("好好学习，天天向上");
		System.out.println("好好学习，天天向上");
		System.out.println("好好学习，天天向上");
		System.out.println("好好学习，天天向上");
		System.out.println("好好学习，天天向上");
		System.out.println("好好学习，天天向上");*/
		for(int i = 0 ; i < 10000 ; i ++){
			System.out.println("好好学习，天天向上 : " + i);
		}

	}

1.for循环

1.1 for循环的语法格式

for( 表达式1 ; 表达式2 ; 表达式3 ) 
{
   // 循环体语句  
}

语法格式说明：

for( 初始化语句 ; 循环条件语句 ; 控制条件语句 ) 
{
   // 循环体语句  
}

表达式	说明
表达式1	初始化语句，完成变量的初始化操作初始化语句只会在第一次执行一次
表达式2	循环条件语句，boolean类型，返回true进入循环体，返回false结束循环
表达式3	控制条件语句，在循环体执行完成后执行的代码，负责修正变量，改变循环条件的

1.2 for循环的执行流程

1.3 课堂案例

控制台输出数据1-10
计算1到100的和，用for语句实现
求1~100之间不能被3整除的数的和

案例代码

/**
	 * 控制台输出数据1-10
	 * @param args
	 */
public static void main(String[] args) {
    // 添加注释的快捷键 多行注释 ctrl + shift + /
    /*for (int i = 0 ; i < 10 ; i ++) {
			System.out.println(i+1);
		}*/
    //		循环案例的实现  单行注释 Ctrl+/
    for (int i = 1 ; i <= 10 ; i ++) {
        System.out.println(i);
    }

}

/**
	 * 计算1到100的和，用for语句实现
	 * @param args
	 */
public static void main(String[] args) {
    // 在for循环之外创建一个变量 来接收我们的数据 相当于一个 容器
    int total = 0 ; // 保存计算结果
    for ( int i = 1 ; i <= 100 ; i ++) {
        total += i; // 将变量的结果累加到到total中
    }
    System.out.println(total);

}

package com.bobo.fordemo;

public class ForDemo04 {

	/**
	 * 求1~100之间不能被3整除的数的和
	 *    1.先找到所有不能被3整除的数
	 *    2.将找到的数累加即可
	 * @param args
	 */
	public static void main(String[] args) {
		int total = 0;
		for( int i = 1 ; i <= 100 ; i ++){
			if (i % 3 != 0) {
				// 表示不能被3整除
				// System.out.println(i);
				total += i;
			}
		}
		System.out.println("1~100之间不能被3整除的数的和：" + total);
	}

}

扩展案例：

1.求n的阶乘 9 * 8 * 7 * … * 1

package com.bobo.fordemo;

import java.util.Scanner;

public class ForDemo05 {

	/**
	 * 求n的阶乘 9 * 8 * 7 * ... * 1
	 * 5的阶乘
	 *     5 * 4 * 3 * 2 * 1
	 *     1 * 2 * 3 * 4 * 5
	 *     其实和 1 到 N的整合的和  效果是一样
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println("输入阶乘的值：" );
		int num = in.nextInt();
		
		int total = 1 ; // 记录阶乘结果的变量
		for( int i = 1 ; i <= num; i++){
			total *= i;
		}
		
		System.out.println(num + "的阶乘是：" + total);

	}

}

2.实现如下的效果

请输入一个值：
根据这个值可以输出如下的加法表：
0 + 6 = 6
1 + 5 = 6
2 + 4 = 6
3 + 3 = 6
4 + 2 = 6
5 + 1 = 6
6 + 0 = 6

package com.bobo.fordemo;

import java.util.Scanner;

public class ForDemo06 {

	/**
	 * 请输入一个值：
		根据这个值可以输出如下的加法表：
		0 + 6 = 6
		1 + 5 = 6
		2 + 4 = 6
		3 + 3 = 6
		4 + 2 = 6
		5 + 1 = 6
		6 + 0 = 6
		
		i + (6-i) = 6
		循环N次，每次循环打印一条输出语句
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println("请输入一个1-9之间的数字" );
		int num = in.nextInt();
		for (int i = 0 ; i <= num ; i++) {
			System.out.println(i + " + " + (num - i ) + " = " + num);
		}
		
		System.out.println("------------");
		// 第二种方式 通过多个变量来控制
		for (int i = 0, j = num ; i <= num ;i++,j--) {
			System.out.println(i + " + " + j + " = " + num);
		}
		
		System.out.println("------------");
		// 第二种方式 通过多个变量来控制
		for (int i = 0, j = num ; j >= 0 ;i++,j--) {
			System.out.println(i + " + " + j + " = " + num);
		}
	}

}

3.在控制台输出所有5位数的回文数字

注意：回文数如 12321,13531 等等… 11111

package com.bobo.fordemo;

public class ForDemo07 {

	/**
	 * 在控制台输出所有5位数的回文数字
  		注意：回文数如 12321,13531 等等... 11111
  		
  		解决思路：
  		   1.遍历找出所有的5位数
  		   2.分离出遍历的数字的  万位  千位   十位  个位
  		   3.判断如果 万位和个位相等 同时 千位和十位相等 说明是我们要找的数字
	 * @param args
	 */
	public static void main(String[] args) {
		for(int i = 10000; i < 100000 ; i ++ ){
			int ge = i / 1 % 10;
			int shi = i / 10 % 10;
			int qian = i / 1000 % 10;
			int wan = i / 10000 % 10;
			if (ge == wan && shi == qian) {
				System.out.println(i);
			}
		}

	}

}

4.在控制台输出1000以内的所有的水仙花数，并统计水仙花数的个数。

注意：水仙花数指的是其各位数的立方和等于该数本身的三位数

153 = 1^3 + 5^ + 3^ = 153

package com.bobo.fordemo;

public class ForDemo08 {

	/**
	 * ctrl + d 快速删除一行
	 * 
	 * 在控制台输出1000以内的所有的水仙花数，并统计水仙花数的个数。
		注意：水仙花数指的是其各位数的立方和等于该数本身的三位数
		153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 =153
		
		解决思路：
		   1.遍历出所有的数字
		   2.对遍历的数字，拆分出 个位 十位 百位
		   3.判断 个位的立方+ 十位的立方 + 百位的立方 是否等于遍历的数字本身
	       4.是  输出这个结果  统计变量+1
	       5.不是 不做任何处理
	 * @param args
	 */
	public static void main(String[] args) {
		int count = 0 ; // 统计水仙花数的个数
		for (int i = 0 ; i <= 1000; i ++) {
			int ge = i / 1 % 10;
			int shi = i / 10 % 10;
			int bai = i / 100 % 10;
			/*if(ge * ge * ge + shi * shi * shi + bai* bai * bai == i){
				System.out.println(i);
				count ++;
			}*/
			if (Math.pow(ge, 3) + Math.pow(shi, 3) + Math.pow(bai, 3) == i) {
				System.out.println(i);
				count ++;
			} 
		}
		
		System.out.println("1000以内的水仙花数是：" + count);
	}

}

1.4 for循环的注意事项

1.4.1 大括号可以省略

如果循环体大括号省略，循环体默认执行for语句后面的第一条语句(;结尾)

public class ForDemo09 {

	public static void main(String[] args) {
		// 作用域：i 的作用域 是在for循环以内  表达式 1 2 3 4 中使用
		for(int i = 0 ; i < 4 ; i ++)
			//;
			System.out.println(i);// 这个是我们的循环体
		System.out.println("---------");
	}

}

1.4.2 表达式2的值是一个boolean类型

表达式2如果有多个条件我们需要用逻辑运算符连接

int a = 10;
int b = 20;
for(int i = 0 ; i < 10 && (a > 0 || b < 30) ; i ++){

}

1.4.3 表达式2可以省略，但是";"不能省略

如果表达式2省略的话，那么程序会一直执行，直到资源耗尽，死循环

public static void main(String[] args) {
    for ( int i = 0 ;  ; i ++) {
        System.out.println("-->" + i);
    }
}

1.4.4 表达式1 省略，表达式3省略

表达式1和表达式3也省略

package com.bobo.fordemo;

public class ForDemo11 {

	/**
	 * 表达式1 初始化变量的
	 * @param args
	 */
	public static void main(String[] args) {
		int i = 0; // 表示i的作用域在方法中
		for (; i < 10 ;) {
			System.out.println(i);
			
			// 将表达式4的信息 写到循环体的尾部
			i ++;
		}
		
		/*for ( int i = 0 ; i < 10; i++) {
			
		}*/
	}

}

1.4.5 表达式123都可以省略

表达式123都可以省略，但是两个";"是不能够省略的,出现死循环的情况

public class ForDemo12 {

	/**
	 * 表达式1 初始化变量的
	 * @param args
	 */
	public static void main(String[] args) {
		for(;;){
			System.out.println("----");
		}
	}

}

2.while循环

while是Java使用频率也比较高的一种循环方式。while语句的语法结构要比for循环简单些

2.1 语法格式

while (条件表达式) {
    // 循环语句
}

/**
	 * while循环
	 * @param args
	 */
public static void main(String[] args) {
    int i = 0;
    while( i < 10){
        System.out.println("i = " + i);
        i ++ ;
    }

    System.out.println("循环结束...");
}

2.2 while语句的执行顺序

首先判断条件表达式结果是为true还是false
如果结果是true，执行循环体
如果结果是false，退出循环体

这里面为了便于大家的理解，可以将while循环看出for循环的一种简化形式

for( 表达式1 ; 表达式2 ; 表达式3 ){
 	循环体
}
--->
表达式1
for( ; 表达式2 ; ){
	循环体;
	表达式3
}

对应的while循环

表达式1
while (表达式2){
    循环体
    表达式3
}

2.3 课堂案例

1.用while语句去实现1到100的和

package com.bobo.whiledemo;

public class WhileDemo02 {

	/**
	 * 用while语句去实现1到100的和
	 * @param args
	 */
	public static void main(String[] args) {
		int total = 0; // 记录总和
		int i = 1; // 声明的变量
		while( i <= 100){
			total += i;
			// 改变循环条件
			i ++; // 不能漏掉，不然会 死循环
		}
		System.out.println("1到100的和是：" + total);

	}

}

2.用while语句实现1到100偶数的和

	/**
	 * 用while语句实现1到100偶数的和
	 * @param args
	 */
	public static void main(String[] args) {
		int total = 0;
		int i = 0;
		while( i <= 100){
			if( i % 2 == 0){
				// 表示循环的数字是偶数
				total += i;
			}
			i++;
		}
		
		System.out.println("1到100之间的偶数和是：" + total);
	}

    public static void main(String[] args) {
        int sum = 0;
        int i = 2;
        while(i <= 100){
            sum += i;
            i += 2; // 每次自增2
        }
        System.out.println("sum = " + sum);
    }

3.将前面讲的for循环中的案例该为通过while循环来实现

3.do while循环

do while循环的特点：先执行一次循环体，然后在判断条件是否成立

3.1 语法格式

do{
    循环语句;
}while ( 条件表达式 ) ;

public static void main(String[] args) {
    int i = 0 ;
    do{
        // 循环在循环条件判断之前执行一次
        System.out.println("----" + i);
    }while(i < 0);
    System.out.println("循环执行结束...");

}

3.2 执行顺序

先执行循环语句一次
然后判断条件语句的返回结果是true还是false
如果是true再执行一次循环体，然后判断条件语句
如果是false，那么直接退出循环

3.3 课堂案例

1.使用do-while语句去实现1到100的和

2.使用do-while循环实现1-100的偶数求和

3.使用do-while循环实现for循环中的所有的案例

4. while循环和for循环的对比

for循环和while循环都是先判断再执行，do-while是先执行再判断，并且一定会执行一次循环体
在循环结束之后，还希望能够使用循环变量，使用while循环，否则使用for循环，for循环的变量i只能作用于循环体
死循环的方式

while:

while (true) {}

do -while:

do{
    
}while(true);

for:

for (;;){
    
}

循环方式的选择：

1.如果循环条件是一个区间范围(循环次数确定的)，推荐使用for循环

2.如果循环次数不明确的情况下，推荐使用while循环

3.在第二个基础上如果要先执行再判断就使用do-while循环，否则使用while循环

场景引入：

请在控制台输出如下的图形
********
********
********

public static void main(String[] args) {
    // TODO Auto-generated method stub
    System.out.println("********");
    System.out.println("********");
    System.out.println("********");
}

5.嵌套循环

5.1 嵌套循环的格式

最常用的方式：

for(表达式1 ; 表达式2 ; 表达式3){
    for(表达式1 ; 表达式2 ; 表达式3){
    	
	}
}

其他的组合

for(表达式1 ; 表达式2 ; 表达式3){
    while(表达式){
        
    }
}

while(表达式){
     while(表达式){
        
	}   
}

do{
    for(表达式1 ; 表达式2 ; 表达式3){
    	
	}
}while(表达式);

…

5.2 嵌套循环的规则

外层循环控制行数，内层循环控制列数
外层循环变量变化一次，内层循环变量要变化一轮

5.3 课堂案例

1.打印如下的图案

********
********
********

package com.bobo.forfor;

public class QTDemo01 {

	/**
	 * 请在控制台输出如下的图形
	 *  ********
		********
		********
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*System.out.println("********");
		System.out.println("********");
		System.out.println("********");*/
		for(int i = 0 ; i < 8; i ++){
			System.out.print("*");
		}
		System.out.println(); // 显示的换行
		for(int i = 0 ; i < 8; i ++){
			System.out.print("*");
		}
		System.out.println();// 显示的换行
		for(int i = 0 ; i < 8; i ++){
			System.out.print("*");
		}
		System.out.println();// 显示的换行
		System.out.println("------------------");
		
	}

}
	public static void main(String[] args) {

		/*
		 * 1. 外层循环控制行数，内层循环控制列数
		 * 2. 外层循环变量变化以此，内层循环变量要变化一轮
		 */
		for (int i = 0 ; i < 3 ; i ++) { // 外层循环控制行数
			for( int j = 0 ; j < 8 ; j ++){ // 内层循环控制列数
				System.out.print("*");
			}
			System.out.println(); // 内层循环走完一遍 显示的换行
		}
    }

2.打印如下图案，直角三角形

*
**
***
****
*****
******

package com.bobo.forfor;

public class QTDemo02 {

	/**
	 * 输出如下图案
	 *  *
		**
		***
		****
		*****
		******
		
		1. 外层循环控制行数，内层循环控制列数
		2. 外层循环变量变化以此，内层循环变量要变化一轮
	
	 * @param args
	 */
	public static void main(String[] args) {
		for(int i = 0 ; i < 6 ; i ++){
			// i = 0 1*
			// i = 1 2*
			// i = 2 3*
			// ...
			for(int j = 0 ; j < i +1 ; j ++){
				System.out.print("*");
			}
			System.out.println();
		}

	}

}

3.打印如下图案，直角三角形

*
***
*****
*******
*********

package com.bobo.forfor;

public class QTDemo03 {

	/**
	 * 输出如下图案
	 *  *
		***
		*****
		*******
		*********
		***********
		
		1. 外层循环控制行数，内层循环控制列数
		2. 外层循环变量变化以此，内层循环变量要变化一轮
	
	 * @param args
	 */
	public static void main(String[] args) {
		for(int i = 0 ; i < 6 ; i ++){
			// i = 0 1*
			// i = 1 3*
			// i = 2 5*
			// ...
			for(int j = 0 ; j < 2 * i +1 ; j ++){
				System.out.print("*");
			}
			System.out.println();
		}

	}

}

4.打印九九乘法表

package com.bobo.forfor;

public class QTDemo04 {

	/**
	 * 打印九九乘法表
	 * 1*1=1
	 * 1*2=2  2*2=4
	 * 1*3=3  2*3=6 3*3=9
	 * ....
	 * 1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=72 ... 9*9=81
	 * 
	 * i = 1 1个表达式
	 * i = 2 2个表达式
	 * ..
	 * i = 9 9个表达式
	 * @param args
	 */
	public static void main(String[] args) {
		for(int i = 1 ; i <= 9 ; i ++){
			for(int j = 1 ;j <= i ; j ++){
				System.out.print(j + " × " + i + " = " +  i*j + "\t");
			}
			System.out.println();
		}

	}

}

输出的结果

1×1=1	
1×2=2	2×2=4	
1×3=3	2×3=6	3×3=9	
1×4=4	2×4=8	3×4=12	4×4=16	
1×5=5	2×5=10	3×5=15	4×5=20	5×5=25	
1×6=6	2×6=12	3×6=18	4×6=24	5×6=30	6×6=36	
1×7=7	2×7=14	3×7=21	4×7=28	5×7=35	6×7=42	7×7=49	
1×8=8	2×8=16	3×8=24	4×8=32	5×8=40	6×8=48	7×8=56	8×8=64	
1×9=9	2×9=18	3×9=27	4×9=36	5×9=45	6×9=54	7×9=63	8×9=72	9×9=81

5.计算若干个学生5门课的平均分。

package com.bobo.forfor;

import java.util.Scanner;

public class QTDemo05 {

	/**
	 * 计算若干个学生5门课的平均分。
	 *    提示：
	 *       外层循环一次处理一个学生
	 *       内层循环一遍处理一个学生的五门成绩
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println("输入学生的个数：");
		int num = in.nextInt();
		
		for(int i = 1 ; i <= num ; i ++){
			double sum = 0.0 ; // 记录当前学生的总成绩
			for(int j = 0 ; j < 5 ; j ++){ // 五门课程 内层循环5次
				// 获取该学生的每门课程的成绩
				double score = 0.0;
				System.out.println("请输入第" + i + "个学生的第" + (j+1) + "门的成绩");
				score = in.nextDouble();
				sum += score;
			} // 通过一次内层循环获取到该学生的总成绩
			System.out.println("第" + i + "个学生的平均成绩是：" + sum/5);
		}

	}

}

6.break、continue、return关键字

6.1 break关键字

6.1.1 break关键字介绍

在循环过程中我们要跳出循环的时候那么可以通过break关键字来实现，改变程序控制流。

用户do-while、while、for循环中，可以跳出循环而执行循环以后的语句

6.1.2 使用的场合

循环语句中(单层循环、嵌套循环)
switch语句

6.1.3 课堂案例

1.打印1到10个数，遇到4的倍数程序自动退出

package com.bobo.breakdemo;

public class BreakDemo01 {

	/**
	 * 打印1到10个数，遇到4的倍数程序自动退出
	 * @param args
	 */
	public static void main(String[] args) {
		for( int i = 1 ;i <= 10 ; i++){
			if(i % 4 == 0){
				break; // 跳出循环 执行之后的代码
			}
			System.out.println(i);
		}
		System.out.println("程序结束...");

	}

}

2.循环录入学生成绩，求和。如果输入的成绩为负数。则停止输入，给出错误的提示

package com.bobo.breakdemo;

import java.util.Scanner;

public class BreakDemo02 {

	/**
	 * 循环录入学生成绩，求和。如果输入的成绩为负数。则停止输入，给出错误的提示
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int sum = 0;
		int i = 1; // 记录循环的次数
		while(true){
			System.out.println("请输入第" + i + "个学生的成绩：");
			int score = in.nextInt();
			if(score < 0){
				// 表示是负数
				System.out.println("你输入的数据有误！！！");
				break; // 退出循环
			}
			sum += score;
			System.out.println("sum = " +sum);
			i++;
		}
	}

}

3.嵌套循环中的break；只能跳出包裹的那层循环

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {

            for (int j = 0; j < 5; j++) {

                if(j == 3 && i ==2){
                    break;
                }
                System.out.print( i + "+ " + j + " = " + (i + j ) + "\t" );
            }
            //break;
            System.out.println();
        }
    }

6.2 continue 关键字

作用：continue关键字用于跳过某个循环语句的一次执行，下一次循环还会继续

使用的场合：跳过循环体中剩余的语句而执行下一次循环

package com.bobo.continuedemo;

import java.util.Scanner;

public class ContinueDemo01 {

	/**
	 * 循环录入Java课程的学生成绩，统计分数大于等于80分的学生比例
	 * 分析：
	 *    1.通过循环获取分数大于等于80分的学生人数num
	 *    2.判断成绩是否<80分，满足条件不执行num++,直接进入下一次循环
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入班级总的人数：");
		int count = input.nextInt();
		int num = 0 ; // 记录成绩大于等于80分的人数
		for(int i = 0 ; i < count ; i ++){
			System.out.println("请输入第" + i + "个学生的成绩:");
			int score = input.nextInt();
			if(score < 80){
				continue;
			}
			num++;
		}
		System.out.println("80分以上的人数：" + num);
		System.out.println("80分以上的人数的比例：" + num/(double)count);

	}

}

6.3 break和continue的对比

使用场合

break可以用于switch语句和循环结构中
continue只能用于循环结构中

作用：

break语句终止某个循环，程序跳转到循环块外的下一条语句
continue跳出本次循环，进入下一次循环

6.4 课外练习

1.循环录入会员信息

package com.bobo.continuedemo;

import java.util.Scanner;

public class ContinueDemo02 {

	/**
	 * 循环录入会员信息
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("MyShopping管理系统....");
		for(int i = 0 ; i < 3 ; i ++){
			System.out.println(i + "请输入会员号<4位整数>");
			int vipNumber = input.nextInt();
			System.out.println("请输入会员生日(月/日 用俩位整数表示):");
			String birthday = input.next();
			System.out.println("请输入会员的积分：");
			int score = input.nextInt();
			
			if( !(vipNumber >=1000 && vipNumber < 10000)){
				System.out.println("客户号" + vipNumber + "无效");
				System.out.println("录入信息失败...");
				continue;
			}
			
			System.out.println("您录入的会员信息是:");
			System.out.println(vipNumber + "\t" + birthday + "\t" + score);
		}

	}

}

2.模拟验证用户登录信息

录入成功：

package com.bobo.continuedemo;

import java.util.Scanner;

public class ContinueDemo03 {

	/**
	 * 模拟用户登录操作
	 *   情况：
	 *      1.登录成功
	 *      2.登录失败，提示可以使用的登录次数，
	 *      3.登录失败的次数超过了规定的次数，就不让再登录
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		for(int i = 0 ; i < 3 ; i ++){ // 循环控制登录的次数
			System.out.println("请输入登录的账号：" );
			String userName = input.next();
			System.out.println("请输入密码：");
			String password = input.next();
			// 判断账号密码是否正确 admin  123456
			if("admin".equals(userName) && "123456".equals(password)){
				// 表示登录成功
				System.out.println("欢迎光临MyShopping管理系统....");
				break; // 跳出循环
			}
			
			// 表示登录失败
			
			if(i == 2){
				System.out.println("对不起，您3次机会都输入错误~~");
				continue;
			}
			
			System.out.println("认证失败，您还有" + (2-i) + "次机会");
		}

	}

}