java循环结构

程序流程控制：循环结构

• 循环结构
  在某些条件满足的情况下，反复执行特定的代码的功能
  循环结构的分类：

1.for循环
2.while循环
3.do-while循环

for循环

循环语句的四要素：
初始化条件
循环条件 ：一定是一个boolean类型）
循环体
迭代条件

for循环的结构

for(① ; ② ; ④){
   ③
}
//执行过程：①------②--③--④------②--③--④----...--②
//①只执行了一次。

最简单代码演示：

package com.fan.pojo;
public class DemoVariable {
    public static void main(String[] args) {
        //idea编辑器使用5.fori会提示，直接回车
        for (int i = 0; i < 5; i++) {
            System.out.println("我爱学java");
        }

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

练习：求最大公约数和最小公倍数

最大公约数：指两个或多个整数共有约数中最大的一个。

例如：【12和24】12的约数有：1、2、3、4、6、12；24的约数有：1、2、3、4、6、8、12、24。它们共有的约数为：1、2、3、4、6、12，则12和24的最大公约数为12

最小公倍数：两个或多个整数公有的倍数叫做它们的公倍数，其中除0以外最小的一个公倍数就叫做这几个整数的最小公倍数。

例如：【3和4】3的倍数有6、9、12、15、18、21、24……；4的倍数有4、8、12、16、20、24……。它们公有的倍数有12、24……，则3和4的最小公倍数为12
代码演示：

package com.fan.pojo;

import java.util.Scanner;

/*练习：求最大公约数和最小公倍数(这里是穷举法)
最大公约数：指两个或多个整数共有约数中最大的一个。
例如：【12和24】12的约数有：1、2、3、4、6、12；24的约数有：1、2、3、4、6、8、12、24。它们共有的约数为：1、2、3、4、6、12，则12和24的最大公约数为12
最小公倍数：两个或多个整数公有的倍数叫做它们的公倍数，其中除0以外最小的一个公倍数就叫做这几个整数的最小公倍数。
例如：【3和4】3的倍数有6、9、12、15、18、21、24……；4的倍数有4、8、12、16、20、24……。它们公有的倍数有12、24……，则3和4的最小公倍数为12
*/
public class DemoVariable {
   public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       System.out.println("请输入第一个正整数：");
       int m = sc.nextInt();//12

       System.out.println("请输入第二个正整数：");
       int n = sc.nextInt();//20

       //最大公约数：
       int min = m < n ? m : n;//将最大值取出来赋值给max
       for (int i = min; i >= 1 ; i--) {//最大公约数不能超过最小的那个数
           if(m % i == 0 && n % i == 0){
               System.out.println("最大公约数："+i);//4
               break;
           }
       }

       //最小公倍数：一定比最大的那个数大，起始值选择最大值,终止值选择两个数的乘积。
       int max = m > n ? m : n;
       for (int i = max; i < m*n ; i++) {
           if(i % m == 0 && i % n == 0){
               System.out.println("最小公倍数是："+i);//60
               break;
           }
       }

   }
}

while循环

一、循环结构的四要素：
初始化条件
循环条件 ：一定是一个boolean类型）
循环体
迭代条件
二、while循环的结构

①；
while(②){
	③；
	④；
}
执行过程：①--②--③--④  -- ②--③--④-... 当②为假结束循环

说明：
1.写while循环千万小心不要丢了迭代条件，一旦丢了，就可能导致死循环
2.我们写程序，要避免死循环。
3.for循环和while循环可以相互转换的。

do-while循环

一、循环结构的四要素：
初始化条件
循环条件 ：一定是一个boolean类型）
循环体
迭代条件
二、do-while循环的结构:

①;
do{
	③;
	④;
}while(②);
//执行过程：① -- ③-- ④ -- -②-- ③-- ④ -- ...当②为假，终止退出循环。
//注意：都是在②处退出的。

说明：
1.do-while循环至少执行一次循环体。
2.开发中，for和while循环使用更多一点。

三种循环的区别
虽然可以完成同样的功能，但是还是有小区别：
1.do…while循环至少会执行一次循环体。
2.for循环和while循环只有在条件成立的时候才会去执行循环体
3.for循环语句和while循环语句的小区别：
使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。

循环嵌套（重点）

嵌套循环的使用：
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环。
2.外层循环：循环结构B
内层循环：循环结构A
3.内层循环结构遍历所有次数，只相当于外层循环体执行了一次。

package com.fan.pojo;

import java.util.Scanner;

public class DemoVariable {
  public static void main(String[] args) {
      //初始演示：

      //第一步：
      //循环结构：整体A
      for (int i = 1; i <= 4; i++) {
          System.out.print("*");//通过一个循环打印4个星号，每次打印一个
      }
      System.out.println("===========分割线==========");

      //第二步：如果我们需要打印同样的三行这样的****星号，怎么办呢，笨的办法，将上面的for循环复制粘贴3次。但是如果是1000行呢？
      //我们想我们可以把上面for循环整体A  当成一个  简单的语句，再次放到一个循环中,如下：
      //循环结构：整体B
      for (int k = 1; k <= 3; k++) {
          //for循环整体A:实现的是打印一行中所有的星号
      }

      //第三步：乾坤大挪移，将for循环整体A放到B循环的循环体中
      for (int k = 1; k <= 3; k++) {
          for (int i = 1; i <= 4; i++) {
              System.out.print("*");//通过一个循环打印4个星号，每次打印一个
          }
          System.out.println();//换行输出
      }

  }
}

代码二：

package com.fan.pojo;

public class DemoVariable {
    public static void main(String[] args) {
        //实例1：
        for (int hour = 0; hour < 24; hour++) {//24个小时，外层控制小时
            for (int minute = 0; minute < 60; minute++) {//每个小时有60分钟，内层控制小时之内的分钟
                System.out.println(hour + "点" + minute +"分");
            }

        }
        System.out.println("\n===================");

        //实例2：
        for (int day =1 ; day <= 365; day++) {//一年有365天
            for (int eat = 1; eat <= 3; eat++) {//其中的每一天要干饭 三次
                System.out.println("第"+ day + "天，第" + eat + "次干饭");
            }
        }
    }
}

总结：
技巧：外层循环控制行数，内层循环控制列数（有行列分布规律的）
外层循环了三轮，每一轮中有循环了四次。

跳转语句(控制循环结构)

定义
Java语言中提供了3种跳转语句，分别是break语句、continue语句和return语句。

分类

break

break的使用场景：
在选择结构switch语句中

​ 在循环语句中

break的作用：跳出单层循环

注意：离开使用场景是没有意义的。
代码演示

/*
 * break:中断的意思
 * 使用场景：
 * 		A:switch语句中
 * 		B:循环中
 * 注意：
 * 		离开使用场景是没有意义的。
 * 作用：
 * 		跳出循环，让循环提前结束
 */
public class BreakDemo {
	public static void main(String[] args) {
		//break;
		
		for(int x=1; x<=10; x++) {
			if(x == 3) {
				break;
			}
			System.out.println("HelloWorld");
		}
	}
}

continue

continue的使用场景：在循环语句中

continue的作用：结束一次循环，继续下一次的循环

注意：离开使用场景的存在是没有意义的

continue与break区别：
break 退出当前循环
continue 退出本次循环

代码演示：

/*
 * continue:继续的意思
 * 使用场景：
 * 		循环中
 * 注意：
 * 		离开使用场景是没有意义的
 * 作用：
 * 		结束一次循环，继续下一次的循环
 * 区别：
 * 		break:退出本层循环
 * 		continue:结束一次循环，继续下一次的循环
 */
public class ContinueDemo {
	public static void main(String[] args) {
		//continue;
		
		for(int x=1; x<=10; x++) {
			if(x == 3) {
				//break;
				continue;
			}
			System.out.println("HelloWorld");
		}
	}
}

return

return的使用场景：
在循环语句中
在方法中

return的作用：

​ 可以从一个方法返回，并把控制权交给调用它的语句。
​ 直接结束整个方法,不管这个return处于多少层循环之内。
代码演示：

public class ReturnDemo {
	public static void main(String[] args) {
		getStr();
	}

	public String getStr() {
        return "Hello";
    }

}

带标签的break 和 continue

package com.fan.pojo;

import java.util.Scanner;
//带标签的break 和 continue
public class DemoVariable {
    public static void main(String[] args) {
        //打标识方式：  标识名（标记）：for（）{}
        A:for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= 10; j++) {
                if(j % 4 ==0){
                    //break;//默认跳出包裹次关键字最近的一层循环。
                    //continue;

                    //break A;//复制标识名 ，然后break+空格+标识名;//结束指定标识的一层循环结构
                    continue  A;//结束指定标识的一层循环结构 的当次循环
                }

                System.out.print(j);
            }

            System.out.println();
        }
    }
}