JAVA java学习（33）——————java流程控制之循环结构（for循环/乘法表/回文数/水仙花数）

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

for 语句是一种在程序执行前就要先判断条件表达式是否为真的循环语句。假如条件表达式的结果为假，那么它的循环语句根本不会执行。for 语句通常使用在知道循环次数的循环中。

for 语句语法格式如下所示。

for(条件表达式1;条件表达式2;条件表达式3) {
    语句块;
}

for 循环中 3 个条件表达式的含义如表所示。

表达式	形式	功能	举例
条件表达式 1	赋值语句	循环结构的初始部分，为循环变量赋初值	int i=1
条件表达式 2	条件语句	循环结构的循环条件	i<100
条件表达式 3	迭代语句，通常使用++ 或 – 运算符	循环结构的迭代部分，通常用来修改循环变量的值	i++

for 关键字后面括号中的 3 个条件表达式必须用“;”隔开。

for 循环语句执行的过程为：首先执行条件表达式 1 进行初始化，然后判断条件表达式 2 的值是否为 true，如果为 true，则执行循环体语句块；否则直接退出循环。最后执行表达式 3，改变循环变量的值，至此完成一次循环。接下来进行下一次循环，直到条件表达式 2 的值为 false，才结束循环，其运行流程如图所示。

for 循环的循环迭代语句并没有与循环体放在一起，因此即使在执行循环体时遇到 continue 语句结束本次循环，循环迭代语句也一样会得到执行。

注意事项：
1、for循环在执行条件测试后，先执行循环体程序部分，再执行步进。
2、在for语句的初始化部分声明的变量，其作用域为整个for循环体。
–“初始化”和“循环条件表达式”部分可以使用逗号来执行多个操作。
3、for 语句中初始化、循环条件以及迭代部分都可以为空语句（但分号不能省略），三者均为空的时候，相当于一个无限循环。
例1：
计算 1~100 所有奇数的和。

/**
 * 计算 0-100 奇数的和输出！
 * @豆皮没有豆
 */
public class YuFa19 {

	public static void main(String[] args) {
	    //（1）完整的
		int result = 0;
	    for(int i=1;i<=100;i++){
	    	if(i%2!=0){// 如果不能整除2，说明是奇数，则进行累加
	    		result+=i;
	    	}
	    }
	    System.out.print("完整的for循环计算100 以内所有奇数和为：" + result);
	    System.out.println();
	    //（2）条件表达式 1为空
	    //for 语句中条件表达式 1 的作用可以在程序的其他位置给出，所以当条件表达式 1 为空时，for 语句后面括号内其他条件表达式执行的顺序不变。
	    int count=0;
	    int j=1;// 相当于for语句的第1个表达式
	    for(;j<=100;j++){
	    	if(j%2!=0){// 如果不能整除2，说明是奇数，则进行累加
	    		count+=j;
	    	}
	    }
	    System.out.print("条件表达式 1为空的for循环计算100 以内所有奇数和为：" + count);
	    System.out.println();
	    //（3）条件表达式 2为空
	    //当 for 语句中条件表达式 2 为空时，将没有循环的终止条件。此时 for 语句会认为条件表达式 2 的值总是为真，循环无限制执行下去。因此，为了使循环达到某种条件时退出，需要在语句块中进行逻辑判断，并使用 break 语句来跳出循环，否则将产生死循环。
	    int numb=0;
	    for(int k=1;;k++){
	    	if(k>100){
	    		break;// 相当于for语句的表达式2，满足时就退出for循环
	    	}
	    	if(k%2!=0){// 如果不能整除2，说明是奇数，则进行累加
	    		numb+=k;
	    	}
	    }
	    System.out.print("条件表达式 2为空的for循环计算100 以内所有奇数和为：" + numb);
	    System.out.println();
	    //（4）条件表达式 3为空
    	//当 for 语言中条件表达式 3 为空时，也就没有设置控制变量的表达式，即每次循环之后无法改变变量的值，此时也无法保证循环正常结束。
	    int sum=0;
	    for(int s=1;s<=100;){
	        if (s % 2 != 0){ // 如果不能整除2，说明是奇数，则进行累加
	        	sum += s;
	        }
	        s++; // 相当于for语句的条件表达式3，每次递增1
	    }
	    System.out.print("条件表达式 3为空的for循环计算100 以内所有奇数和为：" + sum);
	    //如果没有循环体语句，s变量的值为 1，永远小于 101，因此将无法结束循环，形成无限循环。在上面代码中将 s 的递增语句放在 for 循环体内，效果与完整 for 语句功能相同。
	    System.out.println();
	    //(5)3 个条件表达式都为空
	    //在 for 循环语句中，无论缺少哪部分条件表达式，都可以在程序的其他位置补充，从而保持 for 循环语句的完整性，使循环正常进行。
	    //当 for 语句中循环体全为空时，即没有循环初值，不判断循环条件，循环变量不增值，此时无条件执行循环体，形成无限循环或者死循环。对于这种情况，在使用时应该尽量避免。
	    int he=0;
	    int q=1;// 相当于for语句的条件表达式1
	    for(;;){
	    	if(q>100){
	    		break;// 相当于for语句的条件表达式2
	    	}
	    	if(q%2!=0){// 如果不能整除2，说明是奇数，则进行累加
	    		he+=q;
	    	}
	    	q++;// 相当于for语句的条件表达式3
	    }
	    System.out.print("3 个条件表达式都为空的for循环计算100 以内所有奇数和为： " + he);
	}

}

for、do-while 和 while 的区别
下面主要介绍它们的区别，如下表所示。

名称	概念	适用场景	特点
for	根据循环次数限制做多少次重复操作	适合循环次数是已知的操作	①初始化的条件可以使用局部变量和外部变量。②使用局部变量时，控制执行在 for 结束后会自动释放，提高内存使用效率。③且变量在 for 循环结束后，不能被访问。④先判断，再执行。
while	当满足什么条件的时候，才做某种操作	适合循环次数是未知的操作	①初始化的条件只能使用外部变量，且变量在 while 循环结束后可以访问。②先判断，再执行。
do-while	先执行一次，在判断是否满足条件	适合至少执行一次的循环操作	①在先需要执行一次的情况下，代码更加简洁。②先执行一次，再判断。

例2：
使用for、do-while 和 while 求出 1-1000 的和。

/**
 * 计算 1-1000 求和输出！
 * @豆皮没有豆
 */
public class YuFa20 {

	public static void main(String[] args) {
		//(1)for循环
		int num=0;
		for(int i=1;i<=1000;i++){
			num+=i;
		}
		System.out.print("for循环计算1000 以内求和为：" + num);
		System.out.println();
		//(2)while循环
		int sum=0;
		int j=1;
		while(j<=1000){
			sum+=j;
			j++;
		}
		System.out.print("while循环计算1000 以内求和为：" + sum);
		System.out.println();
		//(3)do while 循环
		int count=0;
		int k=1;
		do{
			count+=k;
			k++;
		}
		while(k<=1000);
		System.out.print("do while循环计算1000 以内求和为：" + count);
	}

}

例3：
输出0-1000之间的水仙花数
水仙花数（Narcissistic number）也被称为超完全数字不变数（pluperfect digital invariant, PPDI）、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数（Armstrong number），水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身（例如：1^3 + 5^3+ 3^3 = 153）。

/**
 * 输出0-1000 之间的水仙花数
 * 水仙花数只是自幂数的一种，严格来说3位数的3次幂数才称为水仙花数。
 *附：其他位数的自幂数名字
 *一位自幂数：独身数
 *两位自幂数：没有
 *三位自幂数：水仙花数
 *四位自幂数：四叶玫瑰数
 *五位自幂数：五角星数
 *六位自幂数：六合数
 *七位自幂数：北斗七星数
 *八位自幂数：八仙数
 *九位自幂数：九九重阳数
 *十位自幂数：十全十美数
 *
 *三位的水仙花数共有4个：153，370，371，407；
 *四位的四叶玫瑰数共有3个：1634，8208，9474；
 *五位的五角星数共有3个：54748，92727，93084；
 *六位的六合数只有1个：548834；
 *七位的北斗七星数共有4个：1741725，4210818，9800817，9926315；
 *八位的八仙数共有3个：24678050，24678051，88593477
 *......
 *
 *
 * @豆皮没有豆
*/
public class YuFa22 {

	public static void main(String[] args) {
		int i = 100;
        String str="";
        for (;i<1000;i++)
        {
            int a, b, c;
            a = i % 10;
            b = (i / 10) % 10;//b=(i%100)/10;
            c = i / 100;
            if (a * a * a + b * b * b + c * c * c == i)
            {
                str = str + i + ",";
            }
            
        }
        System.out.println("0-1000 之间的水仙花数："+str);
	}

}

例4：
输出100-100000之间的回文数
回文数:正读倒读都一样的整数.
“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数（palindrome number）

/**
 * 输出100-100000之间的回文数
 *  @豆皮没有豆
 *
 */
public class YuFa23 {

	public static void main(String[] args) {
		String str = "";
        for (int i=100;i<100000;i++)
        {
            int wan = i / 10000;
            int qian = (i % 10000) / 1000;
            int bai = (i % 1000) / 100;
            int shi = (i % 100) / 10;
            int ge = (i % 10);
            if (i < 1000 && bai == ge)
            {
               str += i + ",";
            }
            if (i < 10000 && i > 1000 && bai == shi && qian == ge)
            {
                str += i + ",";
            }
            if ( i > 10000 && wan == ge && qian == shi)
            {
                str += i+ ",";
            }
        }
        System.out.println("100-100000 之间的回文数："+str);

	}

}

…

for循环嵌套

如果把一个循环放在另一个循环体内，那么就可以形成嵌套循环。

嵌套循环既可以是 for循环嵌套 while 循环，也可以是 while 循环嵌套 do-while 循环 …… 即各种类型的循环都可以作为外层循环，也可以作为内层循环。

当程序遇到嵌套循环时，如果外层循环的循环条件允许，则开始执行外层循环的循环体，而内层循环将被外层循环的循环体来执行——只是内层循环需要反复执行自己的循环体而已。

当内层循环执行结束，且外层循环的循环体执行结束时，则再次计算外层循环的循环条件，决定是否再次开始执行外层循环的循环体。

根据上面分析，假设外层循环的循环次数为 n 次，内层循环的循环次数为 m 次，那么内层循环的循环体实际上需要执行 n×m 次。嵌套循环的执行流程如图所示。

嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可以结束外层循环的当次循环，开始下一次循环。

例5：
使用嵌套循环输出九九乘法表。

/**
 * 使用嵌套循环输出九九乘法表
 * @豆皮没有豆
*/
public class YuFa21 {

	public static void main(String[] args) {
	    System.out.println("乘法口诀表：");
	    // 外层循环
	    for (int i = 1; i <= 9; i++) {
	        // 内层循环
	        for (int j = 1; j <= i; j++) {
	            System.out.print(j + "*" + i + "=" + j * i + "\t");
	        }
	        System.out.println();
	    }
			
	}

}

上一篇：JAVA java学习（32）——————java流程控制之循环结构（while循环和do-while循环）

下一篇：JAVA java学习（34）——————java流程控制之循环结构（for循环增强型：foreach语句）