Java中的流程控制--循环

while与do while

while:

while(布尔表达式){
    循环体
}

do-while:

do {
    循环体
} while (布尔表达式);

 while有"当"的意思:当符合这个条件,就执行下面的语句,当布尔表达式结果为false时,就结束循环,所以想要一直循环,就在布尔表达式处填上true,直到遇到break都不会中断循环:

    public static void main(String[] args) {
        int number = 0;
        while(true){
            if (number > 100){
                break;
            }
            number ++;
        }
        System.out.println("循环中断,一共循环了" + number + "次.");  //循环中断,一共循环了101次.
    }

do-while无论如何都会先执行一次,即使布尔表达式为false.

break与continue

break有"打断"的意思,而continue有"继续"的意思,在循环中,这两个关键字有不同的用途.

break:中断循环,例子可以看上面的代码,需要注意的一点是,在多层循环中,break只能打断它所处的那一层循环.这里主要说说continue.

一旦执行了continue语句,那么循环体continue下面的语句都不会执行,重新开始一次循环:

    public static void main(String[] args) {
        int number = 0;
        do {
            number ++;
            if (number % 5 == 0){
                System.out.println(number + "是5的倍数.");
                continue;
            }
            System.out.println("number = " + number);
            if (number > 10){
                break;
            }
        } while (true);
        System.out.println("循环中断,一共循环了" + number + "次.");
    }

运行结果: 

number = 1
number = 2
number = 3
number = 4
5是5的倍数.
number = 6
number = 7
number = 8
number = 9
10是5的倍数.
number = 11
循环中断,一共循环了11次.

可以看到,在number是5的倍数的时候,没有执行continue下面的输出语句,说明本次循环在此终止,进入了下一次循环. 

for

for(初始化变量; 循环继续的条件; 变量步进){
    循环体
}

第一次循环会对变量进行初始化,之后判断循环条件,如果为true就执行循环体,循环体执行一次后(continue后也算一次),步进1次,再次判断,为true再次进入循环体,以此类推,直到判断结果为false,结束循环.

for后面的括号中不一定要这么写,还有多种写法,比如: 

        int i = 0;
        for (; i < 10;) {
            i++;
        }

如果小括号里面只有两个分号,那就跟while(true)一样,会开始无限循环,直到break打断:

        for(;;){
            循环体
        }

冒泡排序法

利用for与if-else配合可以完成经典的冒泡排序法:

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;

public class IfElse {
    public static void main(String[] args) {
        int[] arr = new int[10];
        Random random = new Random(1000);
        for (int i = 0; i < arr.length; i++) {
            int ele = random.nextInt(1024);
            Array.setInt(arr, i, ele);
        }
        System.out.println("原数组:" + Arrays.toString(arr));

        int cache = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 1; j < arr.length - i; j++) {
                if (arr[j - 1] > arr[j]) {
                    cache = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = cache;
                }
            }
        }
        System.out.println("排序后:" + Arrays.toString(arr));
    }
}

其中一次运行结果:

    原数组:[727, 252, 588, 471, 969, 16, 40, 848, 498, 365]
    排序后:[16, 40, 252, 365, 471, 498, 588, 727, 848, 969]

 Array是java.lang.reflect中的数组类,提供了操作数组的多种方法,如get,set和创建数组方法,这里使用setInt()来填充元素.

中心思想就是,把大的元素往后移动.外层for循环代表第几轮循环,内层for循环代表本次循环需要对几个元素进行排序.

最开始外层循环为0,内层循环从1(第二个元素)开始到最后一个元素依次遍历,如果发现下标为[j-1]的元素大于下标为[j]的(),就将[j-1]移动至[j]的位置,依次循环,第一次移动之后,最大的元素一定在最后一位(按从小到大排列),之后循环外层循环+1,内层循环的元素数-1,也就是把最后一个元素忽略掉,依次循环,最终完成排序.

foreach

foreach又称为增强for循环:

    for(类型 变量名 : 要迭代的容器(集合数组等)){
        循环体
    }

foreach主要是针对数组与集合而设计的,但是注意foreach中不存在下标之类的东西,所以只是用来进行迭代,如果需要下标进行操作的话,还是应该使用普通for循环. 

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class For {
    public static void main(String[] args) {
        int times = 0;
        Set<Integer> set = new HashSet<>();
        Random random = new Random(1024);
        for (int i = 0; i < 100; i++) {
            times++;
            set.add(random.nextInt(100));
            if (set.size() < i + 1) {
                i--;
            }
        }
        System.out.println("一共进行了" + times + "次循环,set中有" + set.size() + "个元素.");
        for (Integer i: set) {
            if (i % 20 == 0){
                System.out.println(i + "与20取余为0.");
            }
        }
    }
}

其中一次运行结果为: 

一共进行了615次循环,set中有100个元素.
0与20取余为0.
20与20取余为0.
40与20取余为0.
60与20取余为0.
80是与20取余为0.

Set有每个元素只能存在一份的特性,所以当set.size()小于i+1时,就证明加入了重复的数值,就将i-1,相当于重新进入本次循环.最后看到直到进行了615次循环才将0~99填充成功.

在需要下标的时候,就应该使用普通的for循环:

import java.lang.reflect.Array;
import java.util.Random;

public class For {
    public static void main(String[] args) {
        int times = 0;
        int[] array = new int[100];
        Random random = new Random(1024);
        for (int i = 0; i < array.length; i++) {
            int ele = random.nextInt(100);
            if (i == ele){
                Array.setInt(array, i, ele);
            } else {
                i--;
            }
        }
        System.out.println("array中有" + array.length + "个元素.");
        for (int i = 0; i < array.length; i++) {
            if (array[i] % 20 == 0){
                System.out.println("下标为" + i + "的元素值为" + array[i] + ",可以被20整除.");
            }
        }
    }
}

运行结果:

array中有100个元素.
下标为0的元素值为0,可以被20整除.
下标为20的元素值为20,可以被20整除.
下标为40的元素值为40,可以被20整除.
下标为60的元素值为60,可以被20整除.
下标为80的元素值为80,可以被20整除.