凯哥带你从零学大数据系列之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