2019-07-05

for循环-1

1.循环的种类

for    while    do...while        forEach        forLable

2.for循环(最重要的)

语法:

for(a;b;c){
         d;
     循环体//
 }

a 循环的起始条件,一般是一个变量的定义,标识符一般设置为i(index).
b 循环的判断条件,是一个具有布尔值的表达式,通常和起始条件有关.
c 循环趋向于结束的条件,一般是自增自减运算或者复合赋值运算.
d b为真的时候要执行的代码,成为循环体或循环代码块.

例:
public class ForDemo {
    public static void main(String[] args) {
        // 打印三遍 带牌儿
        // 起始条件 判断条件 趋向于结束的条件
        for (int i = 0; i < 3; i++) {
            System.out.println("带牌儿");
        }
    }
}

for循环的执行步骤

3.for循环的应用

例1:计算1-100的和

public class ForDemo2 {
    public static void main(String[] args) {
        // 计算1-100的和
        // 设置一个变量,存储每一步的加和
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;//sum = sum + i;
        }
        //输出sum即可
        System.out.println(sum);
    }
}

ext:看看
分治算法,动态规划{target=”_blank”
rel=”noopener”}

例2:计算5的阶乘

//5! = 5*4*3*2*1;
//n! = n*(n-1)*(n-2)*...*1;

public class ForDemo3 {
    public static void main(String[] args) {
    //计算5的阶乘
    //设置一个记录变量,最好的选择是1(0*n=0)
        int result = 1;
        for (int i = 1; i <= 5; i++) {
            result *= i;
        }
        System.out.println(result);
    }
}

例3:计算1-100之内3的倍数的和

public class ForDemo4 {
    public static void main(String[] args) {
        int sum = 0;
        // 计算1-100以内3的倍数的和
        for (int i = 3; i <= 100; i++) {
            // 如果一个数%3=0代表整除;
            if (i % 3 == 0) {
                sum += i;
            }
        }
        System.out.println(sum);
    }
}

或:

public class ForDemo4 {
    public static void main(String[] args) {
        int sum = 0;
        // 计算1-100以内3的倍数的和
        for (int i = 3; i <= 100; i+=3) {
            // 如果一个数%3=0代表整除;
                sum += i;
        }
        System.out.println(sum);
    }
}

例4:计算1-100内所有能被3和7整除的数字的和

public class ForDemo5 {
    public static void main(String[] args) {
//计算1-100内所有能被3和7整除的数字的和
        int sum = 0;
        for (int i = 1; i <= 100; i += 21) {
        //能同时被3和7整除的最小数是21,并且一定都是21的倍数
            sum += i;
        }
        System.out.println(sum);
    }
}

例5:找到并输出1000以内所有能被3整除的数字

public class ForDemo6 {
    public static void main(String[] args) {
        // 找到并输出1000以内所有能被3整除的数字
        for (int i = 1; i <= 1000; i++) {
            if (i % 3 == 0) {
                System.out.println(i);
            }
        }
    }
}

例6:找到并输出500以内第12个被1整除的数字

public class ForDemo7 {
    public static void main(String[] args) {
        //设置一个记录当前值的位置的变量
        int count = 0;
        //找到并输出500以内第12个被1整除的数字
        for (int i = 17; i <= 500; i += 17) {
            count++;
            //统计个数
            if (count == 12) {
                //当个数为12时输出当前的数字
                System.out.println(i);
            }
        }
    }
}

4.循环中的break

    break在循环中表示一旦执行之后,后续尚未执行的循环部分全部放弃,不再执行.
效果:
    提前结束循环
注意:
    break必须位于循环体中可运行部分代码的最后一行,否则后续的代码标记不可达,报错.

如上例6:找到并输出500以内第12个被1整除的数字

public class BreakDemo01 {
    public static void main(String[] args) {
        // 设置一个记录当前值的位置的变量
        int count = 0;
        // 找到并输出500以内第12个被1整除的数字
        for (int i = 1; i <= 500; i++) {
            if (i % 17 == 0) {
                count++;
                // 统计个数
            }
            if (count == 12) {
                // 当个数为12时输出当前的数字
                System.out.println(i);
                break;
            }
        }
    }
}

5.break在for循环中的应用

例7:找到并输出500以内所有偶数个能被13整除的数字的和.

public class BreakDemo02 {
    public static void main(String[] args) {
        int count = 0;// 记录位置
        int sum = 0;// 统计和
        for (int i = 1; i <= 500; i++) {
            if (i % 13 == 0) {
                count++;
                // 筛选偶数
                if (count % 2 == 0) {
                    sum += i;
                }
            }
        }
        System.out.println(sum);
    }
}

6.for循环的嵌套

语法:

//外层循环
for(a1;b1;c1){
    //内层循环
    for(a2;b2;c2){
        //循环体
    }
}

注意:

外层循环的循环变量从i开始,内层依次是j,k
循环最多嵌套三次(允许3次)

循环的执行次数:
外层循环的执行次数取决于外层循环的三个条件
内层循环的执行次数是外层循环的次数和内层循环的次数的乘积

7.双层for循环的执行流程

双层for循环的执行流程

先执行外层循环,再执行内层循环,此时内层要执行完毕所有的次数,再执行外层循环,以此类推…

结论:
外层循环执行一次,内层循环执行全部
外层循环像是分针,内层循环是秒针

双层for循环的应用

例1:输出100以内所有的质数

//质数(素数):只能被1和它本身整除的数字    
public class DoubleForDemo02 {
    public static void main(String[] args) {
        // 输出100以内所有的质数/素数
        for (int i = 2; i < 100; i++) {
            // 设置一个布尔值
            boolean status = true;
            // 质数的判断
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
            //当前的值能被2或自身之外的数整除时,将布尔值变为false并跳出当前循环
                    status = false;
                    break;
                }
            }
            //如果布尔值为真,即除了2或自身之外没有能整除的数时是质数,输出
            if (status) {
                System.out.println(i);
            }
        }
    }
}

例2:计算1-100之内所有合数的和

public class DoubleForDemo04 {
    public static void main(String[] args) {
        //计算1-100之内所有合数的和
        int sum = 0;
        for (int i = 2; i <= 100; i++) {
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    //如果存在被1或自身之外的数整除,就是合数,输出并退出循环
                    sum+=i;
                    break;
                }
            }
        }
        System.out.println(sum);
    }
}

//练习写注释,所以要多写”废话”=_=;