凱哥帶你從零學大數據系列之Java篇---第三章:流程控制

溫馨提示:如果想學紮實,一定要從頭開始看凱哥的一系列文章(凱哥帶你從零學大數據系列),千萬不要從中間的某個部分開始看,知識前後是有很大關聯,否則學習效果會打折扣.

系列文章第一篇是擁抱大數據：凱哥帶你從零學大數據系列-學習大數據前奏(必讀)(點我)!

上一篇:擁抱大數據：凱哥帶你從零學大數據系列之Java篇---第二章:Java語法基礎

課程重點：

分支 if-else 的使用
分支 switch-case 的使用
循環 for 的使用
循環 while 的使用
break、continue 的使用

3.1. 流程控制的簡介

3.1.1. 程序的執行結構

在Java中，程序的執行結構分爲三種

順序結構：代碼從上往下，逐行依次執行。是程序執行的默認結構。
分支結構：程序在某一個節點遇到了多種向下執行的可能性，根據條件，選擇一個分支繼續執行。
循環結構：某一段代碼需要被重複執行多次。

3.1.2. 流程控制的介紹

流程控制，就是通過指定的語句，修改程序的執行結構。按照修改的不同的執行結構，流程控制語句可以分爲：

分支流程控制語句：
- 將程序，由順序結構，修改爲分支結構

循環流程控制語句：
- 將程序，由順序結構，修改爲循環結構

3.2. 分支流程控制 - if

3.2.1. if流程圖

3.2.2. if基礎語法

if(condition) {
   // 代碼段1
}
else{
   // 代碼段2
}

邏輯: condition是一個boolean類型的變量, 或者一個boolean結果的表達式. 如果condition的值爲true, 則代碼段1執行, 否則, 代碼段2執行

/**
 * @Description if-else的基礎語法
 */
public class JavaSyntax{
   public static void main (String[] args) {
       int score=99;
       if(score>=60) {
           System.out.println ("成績及格了！")；
      }
       else{
           System.out.println ("成績不及格！")；
      }
  }
}

3.2.3. if語法進階

if (condition1) {
   // 代碼段1
}
elseif (condition2) {
   // 代碼段2
}
else {
   // 代碼段3
}

邏輯: 先判斷condition1, 如果condition1成立, 執行代碼段1; 如果condition1不成立, 再判斷condition2, 如果condition2成立, 執行代碼段2, 否則執行代碼段3

/**
 * @Description if-else的語法進階
 */
public class JavaSyntax{
   public static void main (String[] args) {
       int score=99;
       if(score<60) {
           System.out.println ("成績不及格！")；
      }
       elseif (score<80) {
           System.out.println ("良！")；
      }
       else{
           System.out.println ("優！")；
      }
  }
}

3.3. 分支流程控制 - switch

3.3.1. switch流程圖

3.3.2. switch的基礎語法

switch(變量) {
   case值1：
       // 分支語句1
   case值2:
       // 分支語句2
  ...
       
   default:
}

程序邏輯：

檢測某一個變量的值，從上往下依次與每一個case進行校驗、匹配
如果變量的值和某一個case後面的值相同，則執行這個case後的語句
如果變量的值和每一個case都不相同，則執行default後的語句

3.3.3. break

/**
 * @Description switch結構
 */
public class JavaSyntax{
   public static void main (String[] args) {
       int season=1;
       switch(season) {
           case1:
               System.out.println ("春天");
           case2:
               System.out.println ("夏天");
           case3:
               System.out.println ("秋天");
           case4:
               System.out.println ("冬天");
           default:
               System.out.println ("錯誤季節")；
      }
  }
}

上述代碼中， switch結構捕獲變量season的值。變量的值和第一個case是匹配的，應該輸出的結果是 "春天"。但實際上的輸出結果卻是從春天開始的每一個輸出。

因爲在switch結構中有“穿透性”。

穿透性:

指的是，當switch的變量和某一個case值匹配上之後，將會跳過後續的case或者default的匹配，直接向後穿透。

爲了杜絕穿透，可以使用關鍵字 break:

這一段程序， season的值，和case 1匹配。因此會輸出“春天”，然後向下穿透，輸出“夏天”。
此時，遇到了關鍵字 break。將會結束穿透，直接結束switch結構。
因此，此時的輸出結果是:
春天
夏天

3.4. 循環流程控制 - for

3.4.1. for循環流程圖

3.4.2. for循環基礎語法

for (循環初始部分； 循環條件； 循環迭代部分) {
循環體
}

執行邏輯：

循環開始後，先執行循環初始部分，這一部分的代碼只會執行一次。在初始部分，常常用於定義循環控制變量。
循環初始部分結束後，判斷循環條件。
如果循環條件成立，執行循環體。
循環體執行結束後，執行循環迭代部分。這裏常常用於對循環控制變量進行修改。
循環迭代部分執行結束，再回到第二步，判斷循環條件。
如果循環條件成立，繼續執行循環體。如果循環條件不成立，循環結束。

3.4.3. 示例代碼

/**
 * @Description switch結構
 */
public class JavaSyntax{
   public static void main (String[] args) {
       // 循環輸出1~100之間的每一個數字
       for(int i=1; i<=100; i++) {
           System.out.println (i);
      }
       // 循環輸出1~100之間的每一個奇數
       for(int i=1; i<=100; i+=2) {
           System.out.println (i);
      }
  }
}

3.4.4. 特殊語法

1 循環體中的代碼如果只有一句，大括號可以省略。但是從語法角度出發，可以省略。實際寫程序的時候，出於規範，一般不省略。

/**
 * @Description for循環特殊語法
 */
public class JavaSyntax {
 public static void main (String[] args) {
 // 循環輸出1~100之間的每一個數字
 for(int i=1; i<=100; i++) 
 System.out.println (i);
  }
}

2 for循環小括號中的每一部分都可以省略不寫，但是分號不能省略。

/**
 * @Description for循環特殊語法
 */
public class JavaSyntax{
 public static void main (String[] args) {
 // 循環輸出1~100之間的每一個數字
 int i=1;
 for(;;) {
 System.out.println (i++);
 if(i>=100) {
 break;
          }
      }
  }
}

3.5. 循環流程控制 - while

3.5.1. while循環基礎語法

while (循環條件) {
// 循環體
}

程序邏輯：

判斷循環條件是否成立，如果循環條件條件成立，循環體循環執行。直到循環條件不成立。

3.5.2. 示例代碼

/**
 * @Description for循環特殊語法
 */
public class Loop{
   public static void main (String[] args) {
       // 輸出1-100之間所有的數字
       int n=1;
       while(n<=100) {
           System.out.println (n++);
      }
  }
}

3.5.3. do-while循環

do-while循環基本與while循環是一致的，只是在執行邏輯上稍微有點區別:

/**
 * @Description do-while循環
 */
public class Loop{
   public static void main (String[] args) {
       // 輸出1-100之間所有的數字
       int n=1;
       do{
           System.out.println (n++);
      }
       while(n<=100);
  }
}

執行邏輯

先執行循環體，再判斷循環條件是否成立。
如果循環條件成立，繼續執行循環體。
如果循環條件不成立，結束循環。

3.6. 兩個關鍵字

3.6.1. break

break用在循環中，表示無論循環條件是否成立，立即結束循環。

/**
 * @Description break關鍵字
 */
public class Loop{
   public static void main (String[] args) {
       for(int i=0; i<10; i++) {
           if(i==5) {
               break;
          }
           System.out.println (i);
      }
  }
}

上述代碼中，如果i的值爲5，結束循環。所以，程序輸出結果是
0
1
2
3
4

3.6.2. continue

continue用在循環中，表示立即停止本次循環，開始下次循環。

/**
 * @Description continue關鍵字
 */
public class Loop{
   public static void main (String[] args) {
       for(int i=0; i<10; i++) {
           if(i==5) {
               continue;
          }
           System.out.println (i);
      }
  }
}

當i的值是5的時候，停止當次的循環，立即進入下次循環。所以，程序輸出的結果是
0
1
2
3
4
6
7
8
9

3.7. 循環標籤

循環的實際使用中，有些情況下，需要使用到嵌套循環。在嵌套循環中，如果內層循環寫了break或者continue，此時只能作用於內層的循環。

/**
 * @Description 嵌套循環
 */
public class Loop{
   public static void main (String[] args) {
       for(int i=0; i<3; i++) {
           for(int j=0; j<3; j++) {
               if(j==2) {
                   break;
              }
               System.out.println ("i = "+i+", j = "+j);
          }
      }
  }
}

上述代碼中，當內層循環j的值爲2的時候，結束內層循環。所以，程序的輸出結果是
i = 0, j = 0
i = 0, j = 1
i = 1, j = 0
i = 1, j = 1
i = 2, j = 0
i = 3, j = 1

如果在內層循環中，需要使用break或者continue關鍵字作用於外層的循環，需要配合循環標籤使用。

循環標籤是一個標識符，常寫成全大寫。在循環的前面直接寫標籤，添加一個冒號即可。

/**
 * @Description 循環標籤
 */
public class Loop{
   public static void main (String[] args) {
       OUTER:// 這就是一個循環標籤
       for(int i=0; i<3; i++) {
           for(int j=0; j<3; j++) {
               if(j==2) {
                   breakOUTER;// 配合循環標籤使用
              }
               System.out.println ("i = "+i+", j = "+j);
          }
      }
  }
}

上述代碼中， break OUTER; 使得break關鍵字作用於指定的循環。此時，程序的輸出結果是
i = 0, j = 0
i = 0, j = 1