循环结构

# JavaSE-流程控制

# 循环结构

上面选择结构中，我们始终无法让程序一直跑着，我们每次运行就停止了。我们需要规定一个程序运行多少次，运行多久，等等。所以按照我们编程是为了解决人的问题的思想，我们是不是得需要有一个结构来搞定这个事情！于是循环结构自然的诞生了！

顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,，就需要使用循环结构。

Java中有三种主要的循环结构：

while 循环
do…while 循环
for 循环

在Java5中引入了一种主要用于数组的增强型for循环。

# 1、while 循环

while是最基本的循环，它的结构为：

while( 布尔表达式 ) {
    //循环内容
}

1
2
3

【图解】在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次判断是否为真。直到条件不成立，则循环结束。

我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。

方式有：循环内部控制，外部设立标志位！等

public static void main(String[] args) {
    int i = 0;
    //i小于100就会一直循环
    while (i<100){
        i++;
        System.out.println(i);
    }
}

1
2
3
4
5
6
7
8

少部分情况需要循环一直执行，比如服务器的请求响应监听等。

public static void main(String[] args) {
    while (true){
        //等待客户端连接
        //定时检查
        //......
    }
}

1
2
3
4
5
6
7

循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃！

【案例：计算1+2+3+…+100=?】

public static void main(String[] args) {
    int i = 0;
    int sum = 0;
    while (i <= 100) {
        sum = sum+i;
        i++;
    }
    System.out.println("Sum= " + sum);
}

1
2
3
4
5
6
7
8
9

【高斯的故事】

德国大数学家高斯（Gauss）：高斯是一对普通夫妇的儿子。他的母亲是一个贫穷石匠的女儿，虽然十分聪明，但却没有接受过教育，近似于文盲。在她成为高斯父亲的第二个妻子之前，她从事女佣工作。他的父亲曾做过园丁，工头，商人的助手和一个小保险公司的评估师。当高斯三岁时便能够纠正他父亲的借债账目的事情，已经成为一个轶事流传至今。他曾说，他在麦仙翁堆上学会计算。能够在头脑中进行复杂的计算，是上帝赐予他一生的天赋。

高斯用很短的时间计算出了小学老师布置的任务：对自然数从1到100的求和.他所使用的方法是：对50 对构造成和101的数列求和（1＋100,2＋99,3＋98……）,同时得到结果：5050.这一年,高斯9岁.

这个故事我们在高中数学中的“等差数列求和”听过，当时我们用的公式求解。

编程难的不是语言，是算法。数学能让你写的程序运算次数更少，效率更高。

如果求1+2+3.....+100万呢，虽然100万次的运算加法，对于计算机不算什么，但我们为了效率可以用数学公式进行求解。

有能力的同学可以看下编程程序比赛，考验算法能力的，例如：“传智杯”，“蓝桥杯”

# 2、do…while 循环

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {
    //代码语句
}while(布尔表达式);

1
2
3

注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

我们用do...while改造一下上面的案例！

public static void main(String[] args) {
    int i = 0;
    int sum = 0;
    do {
        sum = sum+i;
        i++;
    }while (i <= 100);
    System.out.println("Sum= " + sum);
}

1
2
3
4
5
6
7
8
9

执行结果当然是一样的！

While和do-While的区别：

while先判断后执行。dowhile是先执行后判断！

Do...while总是保证循环体会被至少执行一次！这是他们的主要差别。

public static void main(String[] args) {
    int a = 0;
    while(a<0){
        System.out.println(a);
        a++;
    }
    System.out.println("-----");
    do{
        System.out.println(a);
        a++;
    } while (a<0);
}

1
2
3
4
5
6
7
8
9
10
11
12

# 3、For循环

虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。

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

for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

1
2
3

关于 for 循环有以下几点说明：

最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量(迭代因子控制循环变量的增减。
再次检测布尔表达式。循环执行上面的过程。

【演示：while和for输出】

public static void main(String[] args) {
    int a = 1; //初始化
    
    while(a<=100){ //条件判断
        System.out.println(a); //循环体
        a+=2; //迭代
    }
    System.out.println("while循环结束！");
    
    for(int i = 1;i<=100;i++){ //初始化//条件判断 //迭代
        System.out.println(i); //循环体
    }
    System.out.println("while循环结束！");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

我们发现，for循环在知道循环次数的情况下，简化了代码，提高了可读性。我们平时用到的最多的也是我们的for循环！

# 4、练习

【练习1：计算0到100之间的奇数和偶数的和】

public static void main(String[] args) {
    int oddSum = 0; //用来保存奇数的和
    int evenSum = 0; //用来存放偶数的和
    for (int i = 0; i <= 100; i++) {
        if (i % 2 != 0) {
            oddSum += i;
        } else {
            evenSum += i;
        }
    }
    System.out.println("奇数的和：" + oddSum);
    System.out.println("偶数的和：" + evenSum);
}

1
2
3
4
5
6
7
8
9
10
11
12
13

【练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个】

public static void main(String[] args) {
    for (int j = 1; j <= 1000; j++) {
        if (j % 5 == 0) {
            System.out.print(j + "\t");
        }
        if (j % (5 * 3) == 0) {
            System.out.println();
        }
    }
}

1
2
3
4
5
6
7
8
9
10

【练习3：打印九九乘法表】

1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

1
2
3
4
5
6
7
8
9

当然，成功的路不止一条，但是我们要追求最完美的一条，如果你做不到，不妨试试笨办法，依旧可以完成任务！比如一行行输出，也是可以搞定的。一定要多分析！

我们使用嵌套for循环就可以很轻松解决这个问题了！

第一步：我们先打印第一列，这个大家应该都会

for (int i = 1; i <= 9; i++) {
	System.out.println(1 + "*" + i + "=" + (1 * i));
}

1
2
3

第二步：我们把固定的1再用一个循环包起来

for (int i = 1; i <= 9 ; i++) {
    for (int j = 1; j <= 9; j++) {
        System.out.println(i + "*" + j + "=" + (i * j));
    }
}

1
2
3
4
5

第三步：去掉重复项，j<=i

for (int i = 1; i <= 9 ; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.println(j + "*" + i + "=" + (i * j));
    }
}

1
2
3
4
5

第四步：调整样式

for (int i = 1; i <= 9 ; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print(j + "*" + i + "=" + (i * j)+ "\t");
    }
    System.out.println();
}

1
2
3
4
5
6

通过本练习，大家要体会如何分析问题、如何切入问题！在我们以后写代码的过程中，一定要学会将一个大问题分解成若干小问题，然后，由易到难，各个击破！这也是我们以后开发项目时的基本思维过程。希望大家好好体会！

# 5、增强for循环

Java5 引入了一种主要用于数组或集合的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式)
{
    //代码句子
}

1
2
3
4

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

【演示：增强for循环遍历输出数组元素】

public static void main(String[] args) {
    
    int [] numbers = {10, 20, 30, 40, 50};
    for(int x : numbers ){
        System.out.print( x );
        System.out.print(",");
    }
    System.out.print("\n");
    
    String [] names ={"James", "Larry", "Tom", "Lacy"};
    for( String name : names ) {
        System.out.print( name );
        System.out.print(",");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

我们现在搞不懂这个没关系，就是拉出来和大家见一面，下章就讲解数组了！

更新时间: 2024/01/17, 05:48:13

← 选择结构 break和continue→