五【java基础】程序流程控制 -循环结构

DempseyLee

已于 2022-02-12 06:26:44 修改

阅读量167

点赞数

分类专栏： java 文章标签： java 开发语言后端

于 2022-02-11 21:12:16 首次发布

本文链接：https://blog.csdn.net/DempseyLee/article/details/122853242

版权

java 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

01 循环结构

循环结构

在某些条件满足的情况下，反复执行特定代码的功能

循环语句分类

for 循环
while 循环
do while 循环

02 for 循环

测试代码

/*
For循环结构的使用
一、循环结构的四个要素
① 初始化条件
② 循环条件
③ 循环体
④ 迭代条件

二、for循环的结构
for(①;②;④){
	③
}
*/
class ForTest{
	public static void main(String[] args){
		for(int i=1;i <= 5 ;i++){
			System.out.println("Hello World!");
		}

		//练习：
		int num = 1;
		for(System.out.print('a');num <= 3;System.out.print('c'),num++){
			System.out.print('b');
		}

		//遍历100以内的偶数,获取所有偶数的和,输出偶数的个数
		int sum = 0;	//记录所有偶数的和
		int count = 0; // 记录偶数个数
		for(int i = 1;i <= 100;i++){
			if(i % 2 == 0){
				System.out.println(i);
				sum += i;
				count++;
			}
		}
		System.out.println("100以内的偶数的和：" + sum);
		System.out.println("个数为：" + count);
	}
}

练习1 循环中的条件语句

/*
编写程序从 1 循环 到 150 ，并 在每行打印一个值，另外在每个 3 的倍数行
上打印出“ foo 在每个 5 的倍数行上打印“ biz”, 在每个 7 的倍数行上打印
输出“ baz
 */
public class ForTest {
    public static void main(String[] args){
        for(int i=0; i <=150; i++){
            System.out.print(i);
            if(i % 3 == 0){
                System.out.print(" foo");
            }
            if(i % 5 == 0){
                System.out.print(" biz");
            }
            if(i % 7 == 0){
                System.out.print(" baz");
            }
            // 换行
                System.out.println();
        }
    }
}

练习2 最大公约数和最小公倍数

/*
题目：输入
两个正整数 m 和 n ，求其最大公约数和最小公倍数 。
比如12 和 20 的最大公约数是 4 ，最小公倍数是 60 。
说明：break 关键字的使用
 */
import java.util.Scanner;
public class MathTest {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int num1 = scan.nextInt();
        System.out.println("请输入第二个整数");
        int num2 = scan.nextInt();
        // 先找出两个数中的大小
        int max = (num1 < num2) ? num2 : num1;
        int min = (num1 < num2) ? num1 : num2;

        // 求最大公约数
        for (int i = min; i >= 1; i--) {
            if ((max % i == 0) && (min % i == 0)) {
                System.out.println("最大公约数为" + i);
                break;
            }
        }
        // 求最小公倍数
        for (int b = max; b <= min * max; b++) {

            if ((b % max == 0) && (b % min == 0)) {
                System.out.println("最小公倍数为" + b);
                break;
            }
        }
        
    }
}

练习3 水仙花数

/*
输出所有的水仙花数，所谓水仙花数是指一 个 3 位数 ，其各个位上数
字立方和等于其本身。
例如：153 = 1*1*1 + 3*3*3 + 5*5*5
 */
public class ShuiXianHua {
    public static void main(String[] args){
        for (int i= 100; i < 1000 ; i++){
            // 获取个十百位数字
            int bai = i / 100;
            int shi = i % 100 / 10;
            int ge = i % 10;
            // 判断是否为水仙花数
            int sum = bai*bai*bai + shi*shi*shi + ge*ge*ge;
            if(sum == i){
                System.out.println(i);
            }
        }
    }
}

03 while循环

语法格式

while 测试代码

/*
避免出现死循环
不要忘记声明迭代部分
for 和 While可以相互转换
 */

public class WhileTest {
    public static void main(String[] args){
        int i = 1;
        while (i <= 100){
            if (i % 2 == 0){
                System.out.println(i);
            }
            i++;  //迭代部分
        }
    }
}

04 do-while循环

语法格式

Do-While-Test

/*
至少执行一次循环体
先执行循环体 再判断循环条件
 */

public class DoWhileTest {
    public static void main(String[] args){
        int num = 1;
        do{
            if (num %2 == 0){
                System.out.println(num);
            }
            num++;
        }while(num <=100);
    }
}

05 循环结构综合例题

/*
从
键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入
为 0 时结束 程序
 */
import java.util.Scanner;
public class XunHuanTest {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int zheng = 0;
        int fu = 0;
        while(true){
            System.out.println("请输入一个整数（输入0是结束循环）");
            int num = scan.nextInt();
            if (num == 0){        // 输入0时终止循环
                break;
            }else if(num > 0){
                zheng++;
            }else{
                fu++;
            }
        }
        System.out.println(zheng);
        System.out.println(fu);
    }
}

06 嵌套循环

定义

将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环或内层循环。
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

Test

/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环

2.
外层循环：循环结构B
内层循环：循环结构A

3.说明
① 内层循环遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次

4.技巧
外层循环控制行数，内层循环控制列数
*/

public class ForForTest {
    public static void main(String[] args) {
        //******
        for (int i = 1; i <= 6; i++) {
            System.out.print("*");
        }
        System.out.println();// 换行

        /*
         ******
         ******
         ******
         ******
         */
        for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= 6; j++) {
                System.out.print("*");
            }
            System.out.println();// 换行
        }

        /*
         *
         **
         ***
         ****
         *****
         */
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= i; j++) {  //控制列数
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

测试1 九九乘法表

public class JiuJiuTest {
    public static void main(String[] args) {
        for(int i = 1; i <= 9; i++){
            for (int j = 1; j <=i; j++){
                System.out.print(i + "*"  + j + "=" + i*j + " "); //输出格式
            }
            System.out.println();
        }
    }
}

测试2 100以内所有质数

方法一：

/*
100 以内的 所有质数
质数：只能被1和本身整除的数  --》从2开始到这个数-1为止，都不能被这个数整除
最小的质数是2
 */
public class PrimZahlTest {
    public static void main(String[] args) {
        // 方法一

        for (int i = 2; i <= 100; i++){  //遍历100以内的自然数
            boolean isFlag = true;    //标识符号 判断i是否被j整除 在内层循环开始之前重置
            for(int j = 2; j < i; j++){  // 遍历2到i-1的所有数
                if(i % j == 0){
                    isFlag = false;
                }
            }
            if(isFlag == true){
                System.out.println(i);
        }
        }
    }
}

优化100000以内的质数输出：

/*
100000 以内的 所有质数
质数：只能被1和本身整除的数  --》从2开始到这个数-1为止，都不能被这个数整除
最小的质数是2
 */
public class PrimZahlTest {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();  // 时间戳 判断程序运行时间
        int count = 0;
        for (int i = 2; i <= 100000; i++){
            boolean isFlag = true;
            // 针对本身是质数的数
            for(int j = 2; j <= Math.sqrt(i); j++){   // 优化 2  // 任何一个非质数一定有一个约数在2-9之间
                if(i % j == 0){
                    isFlag = false;
                    break;  //优化一 针对本身非质数的数
                }
            }
            if(isFlag == true){
                //System.out.println(i);  // 输出不在优化范围内
                count++;
        }
        }
        System.out.println(count);
        long end = System.currentTimeMillis();
        System.out.println(end - start); //判断循环运行时间
    }
}

07 特殊关键字 break；continue

break语句

break 语句用于终止某个语句块的执行

                { ……
                        break;
                        ……
                }

break 语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是

BreakTest


public  class BreakContinueTest {
    public static void main(String[] args) {
        for (int i = 0;i < 10; i++){
            if(i == 3){
                break;  //跳出本次循环
            }
            System.out.println(i);  // 如果这句写在if语句里面会编译失败：无法访问语句
        }
    }
}
// 输出0 1 2

Continue语句

continue 只能使用在循环结构中
continue 语句用于跳过其所在循环语句块的 一次执行，继续下一次循环
continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

ContinueTest


public  class BreakContinueTest {
    public static void main(String[] args) {
        for (int i = 0;i < 10; i++){
            if(i == 3){
                //break;  //跳出本次循环
                continue;
            }
            System.out.println(i);
        }
    }
}// 输出0 1 2 4 5 6 7 8 9