5.java的程序控制循环条件（嵌套循环）

嵌套循环一般不会超过三层！
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，构成嵌套循环。
2.外层循环B；内层循环A
3.内层循环遍历一遍，相当于外层循环运行一次。
4.外层循环控制行数内层循环控制列数。

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

九九乘法表

对10000以内的质数输出进行代码优化。
优化一：添加break减少质数参与的循环结构。


优化二：缩小j的考虑范围，减少非质数参与的循环。

特殊关键字的使用：break、 continue

break 语句
1.break语句用于终止某个语句块的执行
2.break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是
哪一层语句块

continue 语句
1.continue只能使用在循环结构中
2.continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
3.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
continue语句用法举例
public class ContinueTest {
public static void main(String args[]){
for (int i = 0; i < 100; i++) {
if (i%10==0)
continue;
System.out.println(i);
}
}
}



下面展示一些 NestLoopTest。

/*                i       j
 *                1       1
 * * *            2       3
 * * * * *        3       5
 * * * * * * *    4       7
 * * * * *        1       5
 * * *            2       3
 *                3       1
 */

//外层循环代表行数i，内层循环代表列数j。
public class NestLoopTest {
    public static void main(String[] args) {
        //明确要从两部分进行，先从上半部分开始
        for (int i = 1;i <= 4;i++){
            for (int j = 1;j <= 2*i - 1;j++){
                    System.out.print('*');
            }
            System.out.println();
        }
        for (int i = 1;i < 4;i++){
            for (int j = 1;j <= 7 - 2*i;j++){
                System.out.print('*');
            }
            System.out.println();
        }

    }
}

下面展示一些 NestLoopTest1。

/*
其中i对应的是行，j对应的是列
九九乘法表
1 * 1 = 1
1 * 2 =2 2 * 2 =4
。。。
1 * 9 = 9 。。。。。。。9 * 9 = 81
 */

public class NestLoopTest1 {
    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();
        }
    }
}

下面展示一些 NestLoopTest2。

/*
获取10000以内的所有质数
质数：只能被1和它本身整除的数----->从2开始，最小的质数是2
 */



public class NestLoopTest2 {
    public static void main(String[] args) {



//方式一：未进行优化，耗时相对较长
        //获取当前时间距离1970-01-01 00：00:00的毫秒数
        long start = System.currentTimeMillis();
        boolean isFlag = true;//标识符标识i是否被除尽，一旦除尽，修改其值
        int count = 0;
        for (int i = 2;i <= 100000;i++){//遍历100000以内的所有整数
            for (int j = 2;j <= i;j++){

                if (i % j == 0){ //i能被j整除
                    isFlag = false;
                }
            }

            if (isFlag == true){
                //System.out.println(i);
                count++;
            }
            //重置isFlag
            isFlag = true;
        }
        //获取此时时间距离1970-01-01 00：00:00的毫秒数
        long end = System.currentTimeMillis();
        System.out.println("100000以内的质数个数是：" + count);
        System.out.println("计算耗时：" + (end - start));//输出结果：100000以内的质数个数是：9592 计算耗时：15774




/*
//对计算时间进行优化

        //获取当前时间距离1970-01-01 00：00:00的毫秒数
        long start = System.currentTimeMillis();
        boolean isFlag = true;//标识符标识i是否被除尽，一旦除尽，修改其值
        int count = 0;
        for (int i = 2;i <= 100000;i++){//遍历100000以内的所有整数
            //优化二：考虑质数本身的性质，能被根号i内的数整除就不是质数
            for (int j = 2;j <= Math.sqrt(i);j++){

                if (i % j == 0){ //i能被j整除
                    isFlag = false;
                    //优化一：加入break，一旦出现结束循环，该优化只对质数有效
                    break;
                }
            }

            if (isFlag == true){
                //System.out.println(i);
                count++;
            }

            //重置isFlag
            isFlag = true;
        }
        //获取此时时间距离1970-01-01 00：00:00的毫秒数
        long end = System.currentTimeMillis();
        System.out.println("100000以内的质数个数是：" + count);
        System.out.println("计算耗时：" + (end - start)); //输出结果：100000以内的质数个数是：9592 计算耗时：17

*/



/*
//最终优化：使用continue

        //获取当前时间距离1970-01-01 00：00:00的毫秒数
        long start = System.currentTimeMillis();
        int count = 0;
        label:for (int i = 2;i <= 100000;i++){//遍历100000以内的所有整数
            //优化二：考虑质数本身的性质，能被根号i内的数整除就不是质数
            for (int j = 2;j <= Math.sqrt(i);j++){

                if (i % j == 0){ //i能被j整除
                    continue label;
                }
            }

            //能进行到此步骤的都是质数
            count++;

            }

        //获取此时时间距离1970-01-01 00：00:00的毫秒数
        long end = System.currentTimeMillis();
        System.out.println("100000以内的质数个数是：" + count);
        System.out.println("计算耗时：" + (end - start)); //输出结果：100000以内的质数个数是：9592 计算耗时：16

*/

    }
}