本文源码：GitHub·点这里 || GitEE·点这里

一、分支语句

流程管制语句对任何一门编程语言都是十分重要的，Java 中基于流程控制程序执行的不同步骤和代码块。

1、IF 条件

IF 条件语句会依据不同的判断条件执行不同的语句，if 后括号内的条件是否成立关键步骤，IF 条件的判断后果必然要是 true 或 false。IF…Else 语句则是满足 IF 条件，就执行相应代码块，否则就执行 Elase 代码块。

public class Process01 {public static void main(String[] args) {
        // 演示：Node01
        if (compare01(40,30)){System.out.println("40>30:true");
        } else {System.out.println("40>30:false");
        }
        // 演示：Node02
        if (compare01(10,20) && compare01(20,30)){System.out.println("条件成立");
        } else {System.out.println("条件不成立");
        }
        // 演示：Node03
        if (compare01(20,10) || compare01(20,30)){System.out.println("条件成立");
        } else {System.out.println("条件不成立");
        }
        // 演示：Node04
        if(compare02(1,1))
            if(compare02(2,2))
                System.out.println("Running...");
        // 演示：Node05
        if(compare01(1,2))
            if(compare01(5,3)){System.out.println("5>3");
            }
    }

    private static boolean compare01 (int num1,int num2){System.out.println("判断：num1="+num1+";num2="+num2);
        return num1 > num2 ;
    }
    private static boolean compare02 (int num1,int num2){System.out.println("判断：num1="+num1+";num2="+num2);
        return num1 == num2 ;
    }
}

节点案例，测试后果形容：

• Node01：如果 if 条件不成立，则执行 else 流程或者完结；
• Node02：逻辑且判断，任何条件不成立，则间接完结；
• Node03：逻辑或判断，任何条件成立，则间接进入分支；
• Node04：IF 的格局，能够去掉 {}，后续语句会作为分支；
• Node05：IF 语句面试题，不会输入任何内容，第二个语句作为分支；

留神 ：在流程管制语句中必须应用大括号，即便只有一行代码，防止采纳单行的编码方式，这是根底标准。在下面的测试节点 4 和 5，代码看着就感觉扎心。

2、IF-Else-IF 条件

Else…IF 分支语句用于多种状况进行的判断解决，直到分支判断条件胜利，执行分支模块代码，如果没有 else 条件，能够所有分支都不满足，间接完结。

public class Process02 {public static void main(String[] args) {elseIf(11) ;
        elseIf(9) ;
        elseIf(5);
    }

    private static void elseIf (Integer num){if (num > 10){System.out.println("num > 10");
        } else if (num > 7){System.out.println("num > 7");
        } else if (num > 4){System.out.println("num > 4");
        } else {System.out.println("num < 4");
        }
    }
}

留神 ：依据条件一一判断，直到找到第一个满足的条件，不会再持续往下面的判断执行，分支语句执行结束就会退出以后的 else…if 流程。超过 3 层的的逻辑判断代码能够应用卫语句、策略模式、状态模式等来实现。

3、Switch 条件

流程形容：switch 语句先获取表达式的值，判断表达式的值与 case 语句后的常量值是否雷同，匹配胜利则执行该 case 后的代码块，直到遇到 break 语句后终止，如果缺失 break 打断，则持续匹配下一 case 常量，直到遇到 break 为止。如果条件全不匹配，则执行 default 前面的语句。default 语句可选，如果不存在 default 语句，同一个 switch 语句，case 的常量值必须互不雷同。

public class Process03 {public static void main(String[] args) {Scanner scan = new Scanner(System.in);
        System.out.print("What day is it today：");
        String value = scan.next();
        weekInfo(value);
    }

    private static void weekInfo (String value){switch (value) {
            case "Monday":
                System.out.println("Monday");
                break;
            case "Tuesday":
                System.out.println("Tuesday");
                break;
            case "Wednesday":
                System.out.println("Wednesday");
                break;
            case "Thursday":
                System.out.println("Thursday");
                break;
            case "Friday":
                System.out.println("Friday");
                break;
            case "Saturday":
                System.out.println("Saturday");
                break;
            case "Sunday":
                System.out.println("Sunday");
                break;
            default:
                System.out.println("Matching failure");
                break;
        }
    }
}

留神 ：从 JDK1.7 之后，switch 反对对 String 字符串的匹配。

二、循环语句

循环语句就是在满足特定条件的状况下，重复执行同个操作。循环语句包含：for 循环、while 循环、do···while 循环。

1、For 循环

Java 开发中最有用的循环形式，也是诸多算法中的根底管制语句，在常见的很多算法编码实现中，都须要借助 for 循环形式。

public class Process04 {public static void main(String[] args) {
        // Node01
        int sum = 0;
        for(int i=1; i<=100; i++) {sum += i;}
        System.out.println(sum);

        // Node02
        String[] nameArr = {"Java","C++","C#"} ;
        for (String name:nameArr){System.out.println("name="+name);
        }

        // Node03
        // 输入 i = 13
        int i = 0;
        for (i++; i++ < 10; i++);
        System.out.println(++i);

        // 输入：j=3 6 9
        int j = 0;
        for (j++; j++ < 10; j++){System.out.println(++j);
        }
    }
}

节点案例，测试后果形容：

• Node01：for 循环作为计算中的罕用形式；
• Node02：foreach 遍历模式，简化循环操作，也能够改写为 for 语句；
• Node03：循环 for 语句的根底执行机制，两道面试常见题；

留神 ：越是根底的货色，学起来越难，for 语句作为很多算法实现的根底管制，了解起来相当的绕。

2、While 循环

while 循环语句首先判断条件是否成立，成立才执行循环体；

do···while 循环语句先执行一次循环体，而后判断条件是否成立，所以 do···while 至多会执行一次；

public class Process05 {public static void main(String[] args) {
        int num1 = 1;
        int num2 = 1;

        // while 循环
        while(num1 <= 3) {System.out.println("num1 ==" + num1);
            num1++;
        }

        // do...while 循环
        do {System.out.println("num2 ==" + num2);
            num2++;
        } while(num2 <= 3);
    }
}

留神 ：while 循环在理论的开发中，因为极其容易导致死循环，所以应用并不多。

三、流程中断

Java 中有三种流程中断语句，关键字别离为 break、continue、return 语句。

1、Return 语句

Java 中最罕用的流程管制关键字，当执行 return 语句后，从该办法返回，返回到调用该办法的业务流程中。

public class Process06 {public static void main(String[] args) {System.out.println(getNum1());
        System.out.println(getNum2());
    }
    public static int getNum1 (){
        int a =100;
        try{return a+1;   // 这里是运算逻辑，非赋值}catch(Exception e){e.printStackTrace();
        }finally{return a;}
    }
    public static int getNum2 (){
        int a =100;
        try{return a++;   //  a++ -> a=a+1 此时 a 的值扭转}catch(Exception e){e.printStackTrace();
        }finally{return a;}
    }
}

return 常在地位

• return 语句只在办法最初呈现一次。
• return 语句仅在 try 和 catch 外面都呈现。
• return 语句仅在 try 和办法最初都呈现。
• return 语句仅在 catch 和办法的最初都呈现。

2、Break 语句

break 中断语句罕用在 for、while、do···while 循环中，用于退出以后整个循环流程，非以后这一次循环。

public class Process07 {public static void main(String[] args) {for (int i = 1 ; i < 3 ; i++){if (i == 2){break ;}
            System.out.println("i =" + i);
        }
    }
}

3、Continue 语句

Continue 中断语句罕用在 for、while、do···while 循环中，用于退出以后这一次循环，进入下一次循环。

public class Process08 {public static void main(String[] args) {for (int i = 1 ; i < 3 ; i++){if (i == 1){continue ;}
            System.out.println("i =" + i);
        }
    }
}

四、利用场景

1、冒泡排序算法

public class Process09 {public static void main(String[] args) {int[] score = {9,8,7,6,5} ;
        // 排序次数：最多 length - 1 次
        for (int i = 0 ; i < score.length -1 ; i ++){
            // 以后排序的汇合区间, 排序完一个数据就放弃一个
            for (int j = 0 ; j < score.length - i - 1 ; j++){
                // 冒泡排序：把后果大的向后扔
                if (score[j] > score[j+1]){int temp = score[j] ;
                    score[j] = score[j+1] ;
                    score[j+1] = temp ;
                }
            }
        }
        // 输入排序后的后果集
        for (int i = 0 ; i < score.length ; i++){System.out.print(score[i]);
        }
    }
}

2、排列组合算法

有 1、2、3、4 个数字，能组成多少个互不雷同且无反复数字的三位数？都是多少？

public class Process10 {public static void main(String[] args) {arrange() ;
    }
    public static void arrange (){
        int i=0; // 百位数
        int j=0; // 十位数
        int k=0; // 个位数
        int t=0; // 计数器
        for (i = 1 ; i <= 4 ; i++){for (j = 1 ; j <= 4 ; j++){for (k = 1 ; k <=4 ; k++){if (i != j && j != k && k != i){
                        t += 1 ;
                        System.out.print(i*100+j*10+k+"--");
                    }
                }
            }
        }
        System.out.println();
        System.out.println("t="+t);
    }
}

3、递归常见算法

基于递归思维的各种计算方法实现。

public class Process11 {public static void main(String[] args) {System.out.println(getSumOne(100));
        System.out.println(getSumTwo(30));
        System.out.println(getSumThree(5));
    }
    /**
     * 应用递归的形式计算 1 +2+...+100
     */
    public static int getSumOne (int i){ // 传入 100
        int sum ;
        if (i == 1){return 1 ;}
        else {sum = i + getSumOne(i - 1) ;
        }
        return sum ;
    }
    /**
     * 一列数的规定如下: 1、1、2、3、5、8、13、21、34...
     * 求第 30 位数是多少，用递归算法实现
     */
    public static int getSumTwo (int i){ // 传入第几位数下标
        if (i <= 0){return 0 ;} else if (i == 1 || i == 2){ // 解决后面 2 位的 1,1
            return 1 ;
        } else { // 以后位数是前两位之和
            return getSumTwo(i - 1) + getSumTwo(i - 2) ;
        }
    }
    /**
     * 1*2*3*...*100 递归计算阶乘
     */
    public static int getSumThree (int i){if (i == 1){return i ;} else {return i * getSumThree (i - 1) ;
        }
    }
}

五、源代码地址

GitHub·地址
https://github.com/cicadasmile/java-base-parent
GitEE·地址
https://gitee.com/cicadasmile/java-base-parent

举荐浏览：Java 根底系列