Java流程控制——循环结构

循环结构

有些时候我们需要多次运行程序，但无法让程序一直运行，运行一遍，程序就停止了 。但是很多电脑网站始终都是全天一直无休止的在运行 ，所以说，按照我们“编程是为了解决人的问题”的这个思想我们需要一个结构，来完成这件事:于是就有了循环结构。顺序结构的程序只能被执行一次，想让相同的操作进行多次，就可以使用循环结构。

Java中主要有三种循环结构:

• while 循环

• do while 循环

• for循环

• 在 Java5 中引入了一种主要用于数组的增强型for循环

while 循环

whlie 是最基本的循环，它的结构为：

whlie(布尔表达式){
	//循环类容  
}

• 只要布尔表达式为true，循环就会一直进行下去
• 我们大多数情况是会让循环停下来的，我们需要让一个表达式失效的方式来结束循环
• 少部分情况我们需要循环一直进行，比如说服务器请求响应监听等
• 循环条件一直为true就为了造成无限循环(死循环) 我们正常的业务编程中应该尽量避免死循环。会影响程序性能，或造成程序卡死崩溃。

⭐️ 练习：使用 while 循环 输出1～100

        //为了后面的表达式判断先要设定一个初始的值
        int i = 0;

        //表达式为 i<100 这样输出之后的结果只会是1~100，如果输出101(大于100的数)，表达式为false，循环内代码将不再执行
        while (i < 100) {
            
            //自增运算（之前的笔记里有）
            ++i;

            //自增一次进行一次输出
            System.out.println(i);
        }

//运行结果：请自行敲完代码后查看哦

/*
再捋一遍
循环在刚刚开始的时候会计算一下i的值，如果值为真，就会去执行循环中的代码，后面的循环也都如此，先计算表达式，只要满足表达式都会执行，一旦表达式不满足了，就不再执行循环
*/

🌟 练习2：计算1+2+3……+99+100=?

        int i = 0;
        int sum = 0;

        while (i<=100)
        {
            sum=sum+i;
            i++;
        }
        System.out.println(sum);
 
//运行结果为：
5050

举个栗子🌰：

就像有些闹钟，每到规定的时间就会响。判断就是被指针指到哪个点它就会响，除非没有电池没有电了(也就是表达式不成立了)才不会响。不要想得多复杂，慢慢理解。

do while 循环:

• do while 循环，对于 where 语句而言，如果不满足条件，则不能进入循环，但有的时候我们需要，即使不满足条件也至少能执行一次

• do while 循环和 while 循环相似，不同的是 do while 循环无论对错 至少先会执行一次

do while 循环的结构如下：

do{
    //代码语句
}whlie(布尔表达式);

		
	  	int i = 0;
        int sum = 0;

        do {
            sum = sum + i;
            i++;
        } while (i<=100);
            System.out.println(sum);

//程序是从上到下的，进行到 do 先输出一遍{}中的内容，再通过判断表达式为true，进行while循环, 最后输出

//运行结果为：
5050

• while和do while 的区别

  • while 先判断后执行，do while 是先执行后判断。

  • do while 总是保证 循环体会至少执行一次，这是它们的主要差别

		int a = 0;

		//使用while 循环
        while (a < 0) {
            System.out.println(a);
            a++;
        }

        //为了更直观的区别结果，输出分隔号将两个循环分开
        System.out.println("===========================");
		
		//使用do while 循环
        do {
            System.out.println(a);
            a++;
        } while (a < 0);

//运行结果为：
===========================
0
    
/*
发现了吧：这里的while循环没有任何输出，而do whil 循环，输出了一个0

仔细查看代码，while循环表达式中的，a<0才可以进行循环。但是第一行就有表示 a=0，而不是a<0，表达式为false，所以while 循环无法进行。而下do whil循环，我们也说到了。无论表达式是否为true，都会先进行一遍，然后再判断表达式是否可以循环

for 循环

• for循环，虽然所有循环结构都可以使用where 或者是都表示，但 java 提供了另一种语句for循环，使一些循环结构变得更加简单

• for循环语句是迭代的一种通用结构，是最有效，最灵活的循环结构

• For循环执行的次数是在执行之前就确定的。

for 循环 的结构如下：

for(初始化;表达式;更新){
    //代码语句
}

		//初始化条件
        int a = 1;

        //条件判断
        while (a <= 100) {

            //循环体
            System.out.println(a);

            //迭代（每一次循环都会将a的值刷新，直到表达式为float）
            a += 2;//每次加2
        }
        System.out.println("while循环结束");


        //初始化、条件判断、迭代
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
        }
        System.out.println("for循环结束");

• 关于for循环有以下几点说明:

  最先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句，

  然后，检测布尔表达式的值，如果为true 循环被执行，如果为false 循环终止，开始执行循环体后面的语句，

  执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）

  再次检测布尔表达式。循环执行上面的过程

⭐️ 练习：计算0~100之间的奇数和偶数的和

        int oddSum = 0;
        int evenSum = 0;

        for (int i = 0; i < 100; i++) {

            //奇数
            //如果i除以2不等于0肯定就是奇数
            if (i % 2 != 0) {
                oddSum += i;

                //偶数
                //相反，可以被除以2等于0肯定就是偶数
            } else {
                evenSum += i;
            }
        }

        //输出奇数的和
        System.out.println("奇数的和：" + oddSum);

        //输出偶数的和2
        System.out.println("偶数的和：" + evenSum);

🌟 练习：使用where或for循环输出1~1000之间的能被5整除的数，并且每行输出三个

        for (int i = 0; i <= 1000; i++) {
            
            //计算：能被5整除的数
            if (i % 5 == 0) {
                System.out.print(i + "\t");
                
            }
            
            if (i % (5 * 3) == 0) {
                //换行
                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=20

1 *6=6 2 *6=12 3 *6=18 4 *6=24 5 *6=30 6 *6=30

1 *7=7 2 *7=14 3 *7=21 4 *7=24 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

        //首先要输出第一行：1*1=1···1*9=9
        //i要赋值1的初始值，应为我们是从1开始相乘

        for (int i = 1; i <= 9; i++) {            
            System.out.println(1 + "*" + i + "=" + (1 * i));
        }
		
//请动手写出以上代码后，运行查看结果

		//接着，我们将固定的1，用一个循环包起来

        for (int j = 1; j <= 9; j++) {
            
            for (int i = 1; i <= 9; i++) {
                System.out.println(1 + "*" + i + "=" + (1 * i));
            }
            
        }

//自行 运行查看结果

//运行之后可以看出，输出的数学乘法中，有重复的乘法

		//去掉重复，i<=j

		for (int j = 1; j <= 9; j++) {
            
            for (int i = 1; i <= j; i++) {
                System.out.println(1 + "*" + i + "=" + (j * i));
            }
            
        }

//自行 运行查看结果

//运行之后可以看出，输出的数学乘法会十分不美观

		//调整样式

		for (int j = 1; j <= 9; j++) {
            
            for (int i = 1; i <= j; i++) {
                System.out.print(1 + "*" + i + "=" + (j * i));
            }
           
            System.out.println();
        }

//自行 运行查看结果

增强for 循环

• 这里先暂时做一个了解

• JAVA5引入了一种主要用于数组和集合的增强型for循环

  JAVA增强for循环语法结构如下

for(声明语句：表达式){
    //代码句子
}

• 声明语句：声明新的局部变量，该变量的类型必须和数组元素类型匹配，其作用域限定在循环语句快，其值与此时上数组元素的值相等

• 表达式表达式是要访问的数组名，或者是返回值为数组的方法

		//练习代码，辅助理解	
		
		//定义一个数组
		int[] numders = {10, 20, 30, 40, 50};

		//遍历数组元素
        for (int x : numders) {
        //这里的 numders 每一项都赋值给了前面的 int x
            
            System.out.println(x);
        }

//运行结果为：
10
20
30
40
50

    	//上面的不懂也没关系，这里用另一种for循环表现一下这个概念（核心是一样的）

		//定义一个数组
		int[] numders = {10, 20, 30, 40, 50};

        for (int i = 0; i < 5; i++) {
            System.out.println(numders[i]);
            //[]表示，取numders中的第几个值：取第i个值。
            //i在循环中每次都会更新，就相当于是取1、2···（小于5的数）
        }

//运行结果为：
10
20
30
40
50
    
//建议回到上个代码再看看、理解理解