3.7 for循环
需求：
某些代码在满足某些条件时需要重复执行。
解决：
循环
Java中循环结构有三种：for、while、do...while
3种循环结构的作用：
可以重复执行某些代码
它们3者完全可以互换。
一、for循环
1、for循环是使用频率最高的一种。
2、for循环的语法结构
for(【循环变量初始化表达式】;【循环条件表达式】;【循环变量迭代表达式】){
循环体语句块;
}
（1）循环体语句块是指满足循环条件就要“重复”执行的代码。
（2）【循环条件表达式】决定是否执行循环体语句块
成立执行，不成立不执行
（3）【循环变量迭代表达式】：修改循环变量的值
（4）【循环变量初始化表达式】：给循环变量初始化
3、注意
（1）for()中两个;不能多也不能少了
（2）如果for()中没有编写循环条件，在for的{}中也没有break等中断语句的话，
这个循环是一个死循环。
4、执行特点
（1）先执行【循环变量初始化表达式】
（2）再判断【循环条件表达式】
如果【循环条件表达式】结果是true，那么将执行（3）
如果【循环条件表达式】结果是false，那么将结束for循环
（3）执行循环体语句块;
（4）执行【循环变量迭代表达式】，然后回到（2）
代码：
class TestFor{
public static void main(String[] args){
/*
for(;;){ //如果不加break就无限循环下去
System.out.println("我爱学Java");
//break;
}*/
for(int i=1; i<=5; i++){
System.out.println("我爱学Java");
}
/*
(1)int i=1;
(2)i<=5; 成立
(3)System.out.println("我爱学Java");
(4)i++ 或 ++i 或 i+=1 都一样，都会让i自增1 i=2
(5)i<=5; 成立
(6)System.out.println("我爱学Java");
(7)i++ i=3
(8)i<=5; 成立
(9)System.out.println("我爱学Java");
(10)i++ i=4
(11)i<=5; 成立
(12)System.out.println("我爱学Java");
(13)i++ i=5
(14)i<=5; 成立
(15)System.out.println("我爱学Java");
(16)i++ i=6
(17)i<=5; 不成立，结束for
*/
}
}3.8 while循环
二、while循环
1、语法结构
while(循环条件表达式){
循环体语句块;
}
2、执行过程
（1）先判断 循环条件表达式
条件成立，执行（2）
条件不成立，直接结束while
（2）执行循环体语句块
（3）回到（1）
代码：
class TestWhile{
public static void main(String[] args){
//输出5次我爱学Java
int i = 1;
while(i<=5){
System.out.println("我爱学Java" + i);
i++;
}
System.out.println("-------------------");
int count = 0;
System.out.println("水仙花数有：");
int num = 100;
while(num<=999){
int ge = num%10;
int shi = num/10%10;
int bai = num/100;
if(ge*ge*ge + shi*shi*shi + bai*bai*bai == num){
System.out.println(num);
count++;
}
num++;
}
System.out.println("水仙花有：" + count +"个");
}
}
3.9 do...while循环
三、do...while（了解）
1、语法结构：
do{
循环体语句块;
}while(循环条件表达式);
注意，do...while结构在while()后面有一个;
在for()或while循环的()后面都没有;
三种循环的相同点：
都是可以实现重复执行某些代码的功能。
三种循环的不同点：
首先，for和while都有可能循环体一次都不执行。
do...while是无论如何，循环体都要执行一次。
其次，习惯问题
当遇到从几循环到几这种场景，一般选用for比较多。
当循环次数不明显，（从几循环到几），但是循环条件明确，使用while比较多。
当循环体要执行一次时，选用do_while。
执行特点：
（1）先不看条件，执行一次do{}循环体
（2）然后再看条件是否成立，
条件成立，再次执行（3）
条件不成立，结束do...while循环的
（3）执行循环体语句，回到（2）
结论：3种循环都是条件成立，再次执行循环体语句，条件不成立，直接结束循环。
代码：
class TestDoWhile{
public static void main(String[] args){
System.out.println("---------for-----------");
for(int i=1; i>=5; i++){//第1次判断条件就不成立
System.out.println("for：" + i);
}
System.out.println("---------while-----------");
int i=1;
while(i>=5){//第1次判断条件就不成立
System.out.println("while：" + i);
i++;
}
System.out.println("---------do_while-----------");
int j=1;
do{
System.out.println("do_while：" + j);
j++;
}while(j>=5);//第1次判断条件就不成立
System.out.println("---------------------");
System.out.println("----------for-----------");
for(int m=1; m<=5; m++){
System.out.println("for：" + m);
}
System.out.println("---------while-----------");
int k=1;
while(k<=5){
System.out.println("while：" + k);
k++;
}
System.out.println("---------do_while-----------");
int h=1;
do{
System.out.println("do_while：" + h);
h++;
}while(h<=5);
}
}
3.10 break
break：
（1）在switch表示结束/中断当前switch
（2）在循环体中表示结束当前的循环
代码：
class TestBreak{
public static void main(String[] args){
for(int i=1; i<=5; i++){
System.out.println(i);
break;//结束当前for
}
System.out.println("-------------");
for(int i=1; i<=10; i++){
System.out.println(i);
//当遇到第1个5的倍数时，就结束当前循环
if(i%5==0){
break;
}
}
System.out.println("-------------");
int i=1;
while(i<=10){
System.out.println(i);
//当遇到第1个5的倍数时，就结束当前循环
if(i%5==0){
break;
}
i++;
}
}
}
//4、输入两个正整数m和n，求其最大公约数和最小公倍数
import java.util.Scanner;
class Exercise4_2{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int m;//把m的作用域提到while外面，使得while结束之后，m还可以继续使用
while(true){//永远成立，如果没有break，它是死循环
System.out.print("请输入第1个正整数：");
m = input.nextInt();
if(m>0){
break;
}else{
System.out.println("m值输入有误，请重新输入！");
}
}
int n;
while(true){
System.out.print("请输入第2个正整数：");
n = input.nextInt();
if(n>0){
break;
}else{
System.out.println("n值输入有误，请重新输入！");
}
}
/*
先假设m和n都是正整数
公约数：
能够同时把m和n整除的数。
例如：
m和n是6和9，公约数：1,3
m和n是6和12，公约数：1,2,3,6
m和n是5和9，公约数：1
最大公约数是它们所有公约数中的最大值。
最大公约数 <= m和n中的小的值
公倍数：
能够同时被m和n整除的数。
例如：
m和n是6和9，公倍数：18,36,54....
m和n是6和12，公倍数：12,24,36,48,60,72.....
m和n是5和9，公倍数：45,90....
最小公倍数是它们所有公倍数中的最小值。
最小公倍数 <= m*n
最小公倍数 >= m和n中的大的值
思考：如何找出m和n的最大公约数？
（1）从1开始找，找到 m和n中的小的数为止，最后一个公约数就是它们的最大公约数
（2）从m和n中的小的数开始往回找，找到第1个公约数，就是它们的最大公约数
*/
//按照方案一
/*
int min = m <= n ? m : n;
int yue = 1;//1是所有数的公约数，默认初始化为1
for(int i=1; i<= min; i++){
if(m%i==0 && n%i==0){
yue = i;//如果有多个公约数，这句代码会被反复执行
//最后一次赋值的，就是最大公约数
}
}*/
/*
int i=1;
while(i<=min){
if(m%i==0 && n%i==0){
yue = i;
}
i++;
}*/
//按照方案二：
int min = m <= n ? m : n;
int yue = 1;
for(int i=min; i>=1; i--){
if(m%i==0 && n%i==0){
yue = i;
break;//直接结束for循环
}
}
System.out.println("最大公约数：" + yue);
/*
如何查找最小公倍数？
（1）公式：m*n/最大公约数
（2）从m*n往回找，找到m和n中大的数为止，找到的最后一个是它们的最小公倍数
（3）从m和n中大的数，找到的第1个公倍数，就是它们的最小公倍数
*/
//方案一：
//System.out.println("最小公倍数：" + m*n/yue);
//方案二：
/*
int max = m > n ? m : n;
int bei = m*n;//m*n的值一定是m和n的公倍数
for(int i = m*n; i>=max; i--){
if(i%m==0 && i%n==0){
bei = i;
}
}
System.out.println("最小公倍数：" + bei);
*/
//方案三：
int max = m>n?m:n;
int bei = m*n;
for(int i=max; i<=m*n; i++){
if(i%m==0 && i%n==0){
bei = i;
break;
}
}
System.out.println("最小公倍数：" + bei);
input.close();
}
}
3.11 循环嵌套
所有的复合语句结构都是可以嵌套：
if...else可以嵌套
switch..case可以嵌套，但是一般不会出现switch...case套switch...case，
一般是if...else嵌套switch..case，或switch..case里面有if...else。
循环也可以嵌套。
循环里面可以嵌套if...else或switch..case。
循环里面也可以嵌套循环。
凡是嵌套，都是外层满足的情况下，再执行内层。
对于循环嵌套来说，外层循环循环一次，内层循环会循环一轮。
代码：
class LoopLoop{
public static void main(String[] args){
/*
11111
22222
33333
分析：
重复3行输出数字
每一行重复输出5个数字然后换行
使用双重循环
外循环的次数表示行数：3
内循环的次数表示每一行的数字个数:5
*/
//外循环for + println控制3个换行
for(int i=1; i<=3; i++){
//内循环for + print控制5个数字的输出
for(int j=1; j<=5; j++){
System.out.print(i);//这里没有ln，不换行
//正好发现，当i=1，第1行时，要输出的正好是1
//正好发现，当i=2，第2行时，要输出的正好是2
//正好发现，当i=3，第3行时，要输出的正好是3
}
System.out.println();
}
/*
(1)int i=1;
(2)i<=3成立
(3)执行外循环的循环体第1次
for(int j=1; j<=5; j++){
System.out.print(i);
}
System.out.println();
执行内循环第1轮：
(3_1)int j=1;
(3_2)j<=5;成立
(3_3)System.out.print(i);
(3_4)j++ j=2
(3_5)j<=5;成立
(3_6)System.out.print(i);
(3_7)j++ j=3
(3_8)j<=5;成立
(3_9)System.out.print(i);
(3_10)j++ j=4
(3_11)j<=5;成立
(3_12)System.out.print(i);
(3_13)j++ j=5
(3_14)j<=5;成立
(3_15)System.out.print(i);
(3_16)j++ j=6
(3_17)j<=5;不成立，结束内循环第1轮
换行
(4)i++ i=2
(5)i<=3 成立
(6)外循环的循环体第2次
for(int j=1; j<=5; j++){
System.out.print(i);
}
System.out.println();
执行内循环第2轮：
(6_1)int j=1;
(6_2)j<=5;成立
(6_3)System.out.print(i);
(6_4)j++ j=2
(6_5)j<=5;成立
(6_6)System.out.print(i);
(6_7)j++ j=3
(6_8)j<=5;成立
(6_9)System.out.print(i);
(6_10)j++ j=4
(6_11)j<=5;成立
(6_12)System.out.print(i);
(6_13)j++ j=5
(6_14)j<=5;成立
(6_15)System.out.print(i);
(6_16)j++ j=6
(6_17)j<=5;不成立，结束内循环第2轮
换行
(7) i++ i=3
(8)i<=3成立
(9)外循环执行循环体第3次
for(int j=1; j<=5; j++){
System.out.print(i);
}
System.out.println();
执行内循环第9轮：
(9_1)int j=1;
(9_2)j<=5;成立
(9_3)System.out.print(i);
(9_4)j++ j=2
(9_5)j<=5;成立
(9_6)System.out.print(i);
(9_7)j++ j=3
(9_8)j<=5;成立
(9_9)System.out.print(i);
(9_10)j++ j=4
(9_11)j<=5;成立
(9_12)System.out.print(i);
(9_13)j++ j=5
(9_14)j<=5;成立
(9_15)System.out.print(i);
(9_16)j++ j=6
(9_17)j<=5;不成立，结束内循环第3轮
换行
(10)i++ i=4
(11)i<=3判断条件不成立，结束外循环
*/
}
}
代码：
class LoopLoop2{
public static void main(String[] args){
/*
1
12
123
1234
12345
分析：
重复5行
每一行也重复输出n个数字，然后换行
依然可以使用双重循环
*/
for(int i=1; i<=5; i++){
/*
当i=1，输出1个数字, j=1, j<=1,内循环循环1次
j=1
当i=2，输出2个数字, j=1, j<=2,内循环循环2次
j=1,2
当i=3，输出3个数字, j=1, j<=3,内循环循环3次
j=1,2,3
当i=4，输出4个数字, j=1, j<=4,内循环循环4次
j=1,2,3,4
当i=5，输出5个数字, j=1, j<=5,内循环循环5次
j=1,2,3,4,5
内循环 j=1; j<=i; j++
*/
for(int j=1; j<=i; j++){
System.out.print(j);
}
System.out.println();
}
}
}
代码：
class LoopLoop3{
public static void main(String[] args){
/*
1
222
33333
4444444
555555555
分析：
重复5行，外循环
重复每一行的n个空格，第一个内循环
重复每一行的m个数字，第二个内循环
*/ for(int i=1; i<=5; i++){
/*
当i=1,4个空格
当i=2,3个空格
当i=3,2个空格
当i=4,1个空格
当i=5,0个空格
发现i的值和空格的数量相加永远是5
*//*
for(int j=1; j<=5-i; j++){//负责第i行的n个空格
System.out.print(" ");
}*/
for(int j=5; j>=i; j--){
System.out.print(" ");
}
/*
当i=1,1个数字,数字是i的值
j=1
当i=2,3个数字
j=1,2,3
当i=3,5个数字
j=1,2,3,4,5
当i=4,7个数字
j=1,2,3,4,5,6,7
当i=5,9个数字
j=1,2,3,4,5,6,7,8,9
int j=1; j<=2*i-1; j++
*/
for(int j=1; j<=2*i-1; j++){//负责第i行的m个数字
System.out.print(i);
}
System.out.println();
}
}
}
3.12 中断和跳转语句
中断和跳转的关键字：
（1）break：只能中断当前的switch或循环
只能用在
A：switch
B：循环
不能脱离这两个结构使用
（2）continue：提前结束本次循环剩下的循环体语句，进入下一次循环的准备
只能用在循环中
（3）return：
结束当前的方法，例如main方法
使用位置只要在方法中就可以，不需要在循环或switch等结构中。
1、break
代码：
import java.util.Scanner;
class TestBreakContinue{
public static void main(String[] args){
/*
boolean flag = false;
if(flag==true){
break;//错误: 在 switch 或 loop 外部中断
}*/
Scanner input = new Scanner(System.in);
//可以重复从键盘输入1-7的数字，然后输出对应的星期单词
//如果输入0，表示结束当前循环
boolean flag = true;
while(flag){
System.out.print("请输入0-7的数字(0表示结束)：");
int week = input.nextInt();
switch(week){
case 1:System.out.println("Monday");break;
case 2:System.out.println("Tuesday");break;
case 3:System.out.println("Wednesday");break;
case 4:System.out.println("Thursday");break;
case 5:System.out.println("Friday");break;
case 6:System.out.println("Saturday");break;
case 7:System.out.println("Sunday");break;
case 0:System.out.println("结束");
flag = false;
break;//结束switch
default:
System.out.println("请重新输入0-7");
}
}
input.close();
}
}
class TestBreakContinue2{
public static void main(String[] args){
for(int i=1; i<=5; i++){
for(int j=1; j<=5; j++){
System.out.print(j);
if(i==j){
break;
}
}
System.out.println();
}
System.out.println("---------------");
int i,j;
for(i=1; i<=5; i++){
for(j=1; j<i; j++){
System.out.print(j);
}
if(i==j){
break;//它属于外循环，中断外循环
}
System.out.println();
}
/*
(1)当i=1
(2)i<=5成立
(3)外循环循环体第1次
for(j=1; j<i; j++){
System.out.print(j);
}
if(i==j){
break;
}
System.out.println();
内循环第一轮
(3_1)j=1
(3_1)j<i不成立，内循环不执行，结束第一轮
if(i==j)成立，结束外循环
*/
}
}
2、continue
class TestBreakContinue3{
public static void main(String[] args){
for(int i=1; i<=5; i++){
for(int j=1; j<=5; j++){
if(i==j){
//break;
continue;//提前结束本次循环
}
System.out.print(j);//内循环的这句代码会被continue跳过
}
System.out.println();
}
/*
i=1, j=1continue没有输出j
j=2,3,4,5输出j
i=2，j=2continue没有输出j
j=1,3,4,5输出j
*/
}
}
3、return
/*
return：
结束当前的方法，例如main方法
使用位置只要在方法中就可以，不需要在循环或switch等结构中。
*/
class TestReturn{
public static void main(String[] args){
for(int i=1; i<=5; i++){
for(int j=1; j<=5; j++){
System.out.print(j);
if(i==j){
return;//直接结束main方法
}
}
System.out.println();
}
System.out.println("循环外面的代码");
}
}
输出结果：1class TestReturn2{
public static void main(String[] args){
System.out.println("1");
boolean flag = true;
if(flag){
return;
}
System.out.println("2");
}
}
输出结果：1