【Java学习笔记】【流程控制】09.顺序、选择、循环结构

顺序结构

顺序结构是Java的基本结构，除非特别指明，否则就按照顺序一句一句执行。顺序结构是最简单的算法结构。

语句与语句之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

举例：

public static void main(String[] args) {
        System.out.println("Hello1");
        System.out.println("Hello2");
        System.out.println("Hello3");
        System.out.println("Hello4");
        System.out.println("Hello5");
}

//输出：按照自上而下的顺序执行，依次输出。
Hello1
Hello2
Hello3
Hello4
Hello5

选择结构

1.if单选择结构

我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示。格式如下：

if(布尔表达式){
	//如果布尔表达式为true将执行的语句
}

举例：

import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容：");
        String s = scanner.nextLine();

        if(s.equals("Hello")){    //equals：判断字符串是否相等
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();
    }
}


//输出结果1：
请输入内容：
Hello
Hello
End:
//输出结果2：
请输入内容：
abc
End

2.if-else双选择结构

当选择出现两种判断并且每种情况都需要说明时，需要用到if-else双选择结构，格式如下：

if(布尔表达式){
	//如果布尔表达式的值为true
}else{
	//如果布尔表达式的值为false
}

举例：考试分数大于等于60分是及格，小于60分不及格

import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩");
        int score = scanner.nextInt();

        if(score >= 60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }
        scanner.close();
    }
}

3.if多选择结构

当选择出现多种情况，我们需要一个if多选择结构来处理。格式如下：

if(布尔表达式1){
	//如果布尔表达式1的值为true执行代码
}else if(布尔表达式2){
	//如果布尔表达式2的值为true执行代码
}else if(布尔表达式3){
	//如果布尔表达式3的值为true执行代码
}else {
	//如果以上布尔表达式都不为true执行代码
}

注意：

• if语句至多可以有1个else语句，必须在所有的else if语句之后；
• if 语句可以有若干个else if 语句，必须在else语句之前；
• 一旦其中一个else if语句检测为true，其他的else if以及else语句都将跳过执行。

举例：考试分数区分为ABCD四个等级

import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if(score == 100){
            System.out.println("恭喜满分");
        }else if (score >= 90 && score < 100){
            System.out.println("A级");
        }else if (score >= 80 && score < 90){
            System.out.println("B级");
        }else if (score >= 70 && score < 80){
            System.out.println("C级");
        }else if (score >= 60 && score < 70){
            System.out.println("D级");
        }else if (score >= 0 && score < 60){
            System.out.println("不合格");
        }else{
            System.out.println("成绩不合法");
        }
        scanner.close();
    }
}

//输出结果1：
请输入成绩：
110
成绩不合法
//输出结果2：
请输入成绩：
90
A级
//输出结果3：
请输入成绩：
50
不合格

4.嵌套的if结构

有时候我们在解决某些问题的时候，需要缩小查找范围，需要有层级条件判断，提高效率。
记住一点就好，所有的流程控制语句都可以互相嵌套，互不影响。

格式如下：

if(布尔表达式1){
	//如果布尔表达式1的值为true
	if(布尔表达式2){
		//如果布尔表达式2的值为true
	}
}

5.switch多选择结构

多选择结构还有一个实现方式就是switch-case 语句。

switch-case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。格式如下：

switch(expression){
	case value1:
    	//语句1
        break;  //可选
    case value2:
        //语句2
        break;  //可选
    case value3:
    	…
    default:    //可选
        //语句
}

注意：

• switch语句中的变量类型可以是: byte、short、int或者char。从Java SE 7开始，switch支持字符串String类型了；
• case语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量；
• 当变量的值与case语句的值相等时，case语句之后的语句开始执行，直到出现 break语句才会跳出switch语句；
• 如果case语句块中没有break语句时，匹配成功后，从当前case开始，后续所有case的值都会输出。如果后续的case语句块有break语句则会跳出判断。【case穿透】
• switch语句可以包含一个default分支，该分支一般是switch语句的最后一个分支(可以在任何位置，但建议在最后一个)；
• default在没有case语句的值和变量值相等的时候执行，default分支不需要break语句。

举例：判断成绩等级

import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String grade = scanner.nextLine();

        switch(grade){     //JDK 7新特性，表达式结果可以是字符串
            case "A":
                System.out.println("优秀");
                break;
            case "B":
                System.out.println("良好");
                break;
            case "C":
                System.out.println("及格");
                break;
            case "D":
                System.out.println("再接再厉");
                break;
            case "E":
                System.out.println("挂科");
                break;
            default:
                System.out.println("未知等级");
        }
    }
}

//输出结果1：
A
优秀
//输出结果2：
E
挂科
//输出结果3：
G
未知等级

循环结构

上面选择结构中，我们始终无法让程序一直跑着，我们每次运行就停止了。这在真实环境中肯定是不行的，比如网站服务器，需要24小时全年无消息的跑着，我们需要规定一个程序运行多少次、运行多久，等等。所以按照编程是为了解决人的问题的思想，我们需要有一个结构来搞定这个事情，于是循环结构自然的诞生了。

1.while循环

格式如下：

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

举例：输出1~100

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

举例：计算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);  //5050
}

注意：

• 只要布尔表达式为true，循环就会一直执行下去；
• 大多数情况是会让循环停止下来，我们需要一个让表达式失效的方法来结束循环；
• 少数情况需要循环一直执行，比如服务器的请求响应监听等；
• 循环条件一直为true就会造成无限循环（死循环），我们应该尽量避免死循环，可能会影响程序性能或者造成程序卡死崩溃。

2.do…while循环

对于while循环而言，如果不满足条件，则不能进入循环。

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

格式如下：

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

举例：计算1+2+3+…+100

public static void main(String[] args) {
    int i = 0;
    int sum = 0;

    do{
        sum = sum +  i;
        i++;
    }while(i <= 100);
    System.out.println(sum);  //5050
}

3.for循环

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

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环执行的次数是在执行前就确定的。格式如下：

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

举例：输出1~100

public static void main(String[] args) {
         //初始化     条件判断   迭代
    for (int i = 0; i <= 100; i++) {
        System.out.println(i);
    }
}

//死循环
for( ; ; ){
}

4.for循环练习

练习一：计算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-1000之间能被5整除的数，并且每行输出3个

public static void main(String[] args) {
    for (int i = 1; i <= 1000; i++) {
        if(i % 5 == 0){
            System.out.print(i + "\t");  //print：输出之后不回车
        }
        if(i % 15 == 0){
            System.out.println();
        }
    }
}

练习三：打印九九乘法表

public static void main(String[] args) {
    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();
    }
}

5.增强for循环

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

格式如下:

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

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

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

public static void main(String[] args) {
    int[] numbers = {10,20,30,40,50};  //定义了一个数组
    for (int i = 0; i < 5; i++) {
        System.out.print(numbers[i] + "\t");
    }
   
    System.out.println();
    
    for(int x : numbers){
        System.out.print(x + "\t");
    }
}
//输出结果：
10	20	30	40	50	
10	20	30	40	50	

break&continue

1.break

break主要用在循环语句或者switch语句中，用来跳出整个语句块。

break跳出最里层的循环，并且继续执行该循环下面的语句。

举例：

public static void main(String[] args) {
    int i = 0;
    while(i < 100){
        i++;
        System.out.print(i + "\t");
        if(i == 15){
            break;
        }	
    }
}

//输出结果：
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15

2.continue关键字

continue适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在for循环中，continue语句使程序立即跳转到更新语句；在while或者do…while循环中，程序立即跳转到布尔表达式的判断语句。

public static void main(String[] args) {
    int i = 0;
    while(i < 100){
        i++;
        if(i % 10 == 0){
            System.out.println();
            continue;
        }
        System.out.print(i + "\t");
    }
}
//输出结果：
1	2	3	4	5	6	7	8	9	
11	12	13	14	15	16	17	18	19	
21	22	23	24	25	26	27	28	29	
31	32	33	34	35	36	37	38	39	
41	42	43	44	45	46	47	48	49	
51	52	53	54	55	56	57	58	59	
61	62	63	64	65	66	67	68	69	
71	72	73	74	75	76	77	78	79	
81	82	83	84	85	86	87	88	89	
91	92	93	94	95	96	97	98	99

3.break与continue区别

break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。break语句也在switch语句中使用。

continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

4.拓展：goto关键字

goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用；

Java没有goto，然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子——带标签的break和continue；

“标签"是指后面跟一个冒号的标识符，例如：label:

对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

举例：打印101-150之间所有的质数

public static void main(String[] args) {
    int count = 0;
    outer:for(int i = 101; i < 150; i++){
        for(int j = 2; j< i / 2; j++){
            if(i % j == 0){
                continue outer;
            }
        }
        System.out.print(i + " ");
    }
}