JavaSE基础——流程控制

一、用户交互Scanner

1. 初识Scanner

Java.util.Scanner是Java提供的一个工具类，可以通过Scanner类来获取用户的输入。

可以通过Scanner类的next()方法和nextLine()方法获取字符
可以通过Scanner类的hasNext()和hasNextLine()方法判断是否还有输入的数据

以scanner.next()方法接收字符串输入

import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        /*
        Java.util.Scanner是Java提供的一个工具类
        可以通过Scanner类来获取用户的输入
        基本语法：Scanner s = new Scanner (System.in);
        可以通过Scanner类的next()方法和nextLine()方法获取字符串
        可以通过Scanner类的hasNext()和hasNextLine()方法判断是否还有输入的数据
         */
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收： ");
        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            //使用next方法接收用户输入
            String str = scanner.next();
            System.out.println("输入的内容为：" + str);
            //scanner.next()方法在接收到有效字符后面的空格时就终止输入
            //剩余的字符将留在输入队列中，直到下一次`next()方法`或`nextLine()方法`的调用。
            //str = scanner.next();
            //System.out.println("输入的内容2为：" + str);
            
        }
        //凡是属于IO流的类使用完应立即关闭，若不关闭会一致占用资源。
        scanner.close();
    }
}
-------------------------------
运行结果：
    使用next方式接收： 
    hello
    输入的内容为：hello
-------------------------------
然而，该程序存在一定的问题，当输入hello时，程序输出hello。当输入hello world时，程序输出依旧是hello。
    使用next方式接收： 
    hello world！
    输入的内容为：hello
--------------------------------
将以下两行去除注释，再次运行：
    //str = scanner.next();
    //System.out.println("输入的内容为：" + str);
运行结果：
    使用next方式接收： 
             hello world!
    输入的内容为：hello
    输入的内容2为：world！
    //可以发现只进行了一次输入，第一次调用scanner.next（）输出了hello，第二次调用scanner.next（），虽然未进行输入，但输出了上一次输入的后半部分，即world！。而hello前面的空格则被忽略没有被输出。

接下来尝试用scanner.nextLine()方法来获取字符串：

import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方式接收： ");
        //判断用户有没有输入字符串
        if (scanner.hasNextLine()){
            //使用next方法接收用户输入
            String str = scanner.nextLine();
            System.out.println("输入的内容为：" + str);
        }
        //凡是属于IO流的类使用完应立即关闭，若不关闭会一致占用资源。
        scanner.close();
    }
}
---------------------------------------
运行结果：
    使用nextLine方式接收： 
        hello world!
    输入的内容为：    hello world!
    //可以发现，以nextLine()方式接受字符串，输入的内容全部被输出，包括hello world！前面的空格。

scanner.next()与scanner.nextLine()方法的比较

next()方法:

一点要读取到有效字符后才可以结束输入
对输入有效字符之前遇到的空白，next()方法会自动将其去掉，忽略
对于有效字符之后的空白，next()方法将其当作分割符或结束符，遇到空白，终止输入。剩余的字符将留在输入队列中，直到下一次next()方法或nextLine()方法的调用。
因此，next()方法不能得到带有空格的字符串

nextLine()方法：

以回车符作为结束符，将返回回车符之前的所有字符，包括空白符
因此，nextLine()方法可以得到带有空格的字符串

2. Scanner进阶

利用Scanner方法进行输入数据类型的限定

import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int i;
        double d;
        System.out.println("请输入整数数据： ");
        //判断是否有整型数据的输入
        if (scanner.hasNextInt()) {
            //若有，则接收数据并赋值给i
            i = scanner.nextInt();
            System.out.println("输入的整数数据为： " + i);
        } else {
            //若输入的不是整型数据，则输出提示信息
            //同时，用户键盘输入的数据将留在输入队列中，等待下一次输入方法调用时接收
            System.out.println("输入的不是整数数据!");
        }
        System.out.println("请输入小数数据： ");
        //判断输入的数据是否为浮点型
        if (scanner.hasNextDouble()) {
            //若是，则接收数据并赋值给d
            d = scanner.nextDouble();
            System.out.println("输入的小数数据为： " + d);
        } else {
            //若输入的不是浮点型数据，则输出提示信息
            //同时，用户输入的数据将留在输入队列中（输入缓冲区），等待下一次输入方法调用时接收
            System.out.println("输入的不是小数数据！");
        }
        //若输入的数据类型为字符串，整型数据判断和浮点型数据判断失败，可由此输出输入队列中的数据
        //String str = scanner.nextLine();
        //System.out.println("此时输入队列的数据为：" + str);
        scanner.close();
    }
}
--------------------------------------
运行结果：
    请输入整数数据： 
    2
    输入的整数数据为： 2
    请输入小数数据： 
    10.1
    输入的小数数据为： 10.1
    ----------------------------------
    请输入整数数据： 
    2.0
    输入的不是整数数据!
    请输入小数数据： 
    输入的小数数据为： 2.0
    ----------------------------------
    去掉下面两行注释，输入字符串进行测试：
    //String str = scanner.nextLine();
    //System.out.println("此时输入队列的数据为：" + str);
    请输入整数数据： 
    yes
    输入的不是整数数据!
    请输入小数数据： 
    输入的不是小数数据！
    此时输入队列的数据为：yes

Scanner学习示例

import java.util.Scanner;
//Scanner学习示例
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double sum = 0;
        int num = 0;
        System.out.println("请输入要计算的数据：");
        //通过循环判断是都还有输入，并实现多次输入
        while (scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            sum += x;
            //这里的 num++ 和 ++num 作用效果相同
            //num++;
            //这里的 num++ 和 ++num 体现各自的特点
            System.out.println("您输入了第" + ++num + "个数据，当前数据的和是" + sum);
        }
        System.out.println("输入数据的总和是：" + sum);
        System.out.println("输入数据的平均数是：" + sum / num);
        scanner.close();
    }
}
----------------------------------
运行结果：
    请输入要计算的数据：
    10
    您输入了第1个数据，当前数据的和是10.0
    20
    您输入了第2个数据，当前数据的和是30.0
    20
    您输入了第3个数据，当前数据的和是50.0
    50
    您输入了第4个数据，当前数据的和是100.0
    ok
    输入数据的总和是：100.0
    输入数据的平均数是：25.0

二、顺序结构

顺序结构是最基本也是最简单的算法结构。
除非特殊指明，所有程序语句将从上到下依次执行。

三、分支结构

分支结构，又称为选择结构。主要可以分为if语句和switch语句。

其中if语句根据使用情况又可以分为单选结构if、双选结构if...else、多选结构if...else if...else...和嵌套结构。

1. if单选结构

import java.util.Scanner;
// if单选结构
public class Demo02 {
    public static void main(String[] args) {
        //if单选结构
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容： ");
        String s = scanner.nextLine();
        //equals用于判断字符串是否相等
        if (s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();
    }
}
----------------------------------------------
运行结果：
    请输入内容： 
    Hello
    Hello
    End

2. if…else…双选结构

import java.util.Scanner;
//if...else...双选结构
public class Demo03 {
    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("成绩不合格！");
        }
        System.out.println("End");
        scanner.close();
    }
}
----------------------------
运行结果：
    请输入分数：
    60
    成绩合格！
    End

3. if…else if…else…多选结构

import java.util.Scanner;
//if...else if...else...多选结构
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入分数：");
        float score = scanner.nextFloat();
        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("End");
        }else{
            System.out.println("输入成绩不合理");
        }
        scanner.close();
    }
}
---------------------------------
运行结果：
    请输入分数：
    102
    输入成绩不合理

4. if…else…嵌套结构

public class Demo03 {
   public static void main(String args[]){
      int x = 30;
      int y = 10;
      if( x ** 30 ){
         if( y ** 10 ){
             System.out.print("X = 30 and Y = 10");
          }
       }
    }
}
--------------
运行结果：
    X = 30 and Y = 10

5. switch case结构

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

5.1 switch case语法

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

switch 语句中的变量类型可以是： byte、short、int 或者 char类型
从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
switch 语句可以拥有多个case 语句。每个 case 后面跟一个要比较的值和冒号。
case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
当变量的值与 case 语句的值相等时，那么case 语句之后的语句开始执行，直到 break 语句出现才会跳出switch 语句。
当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

5.2 switch使用举例

switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。

public class Demo04 {
    public static void main(String[] args) {
        char grade = 'C';
        switch (grade){
            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("未知等级");
        }
        System.out.println("你的等级是： " + grade);
    }
}
------------------------------------
运行结果：
    中等
    你的等级是： C

break的作用：

   1. 若程序中没有 break 语句时，JVM 会依次匹配每一个case，若所有case都匹配不成功，则返回默认 case(default)
   2. 若程序中没有 break 语句时，JVM 会依次匹配每一个case。若匹配成功，则从当前case开始，后续所有case值都会输出。（**case穿透现象**）
   3. 若当前匹配成功的case没有break；则从当前case开始，后续case值都会输出；若后续case语句块有break，则至break处跳出判断。

5.3 switch支持的字符串

从 Java SE 7 开始，switch 增添了支持字符串 String 类型。

//支持字符串
public class Demo04 {
    public static void main(String[] args) {
        String name = "automan";
        switch (name) {
            case "spiderman":
                System.out.println("spiderman: cool!");
                break;
            case "automan":
                System.out.println("automan: beautiful");
                break;
            case "ironman":
                System.out.println("ironman: strong");
                break;
            default:
                System.out.println("big problem!");
        }
    }
}
------------------------
运行结果：
    automan: beautiful

6. 扩展知识：反编译

由Java文件得到.class字节码文件的过程称之为编译；

那么由.class字节码文件反推得到Java文件的过程就称之为反编译。

四、循环结构

Java中主要由三种循环结构：while循环、do...while循环、for循环。

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

1. while循环

while是最基本的循环，它的语法格式为：

while( 布尔表达式 ) {      //循环内容}//只要布尔表达式为 true，循环就会一直执行下去。

只要布尔表达式为 true，while循环就会一直执行下去;
大多数情况下是需要循环停止的，因此需要设计程序使布尔表达式失效来结束循环；
是少数情况下，需要循环一直运行，比如服务器的请求响应监听等等；
循环条件一直为true的循环称为死循环，应尽量避免死循环的出现。

public class Demo05 {
    public static void main(String[] args) {
        //while循环小例子：计算1~100的和
        int i = 0;
        int sum = 0;
        while (i <= 100) {
            sum += i;
            i++;
        }
        System.out.println("1~100数字的和为： " + sum);
    }
}
-------------------------------------------
运行结果：
    1~100数字的和为： 5050

2. do…while循环

对于 while 语句而言，如果不满足条件，则不能进入循环。do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。它的语法格式是：

do {
       //代码语句
}while(布尔表达式);
//布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 
//如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

//while与do...while
public class Demo05 {
    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);
        } while (a < 0);
    }
}
---------------------------------
运行结果：
    -------------------
    1

3. for循环

对于已知循环次数的循环，Java提供了for循环。for循环是最有效最灵活的循环结构，它的语法格式是：

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

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

//for循环示例1
public class Demo05 {
    public static void main(String[] args) {
        //计算0~100之间所有奇数和偶数的和
        int oddSum = 0;     //奇数和
        int evenSum = 0;    //偶数和
        //使用for循环遍历0~100
        for (int i = 0; i <= 100; i++) {
            //使用if判断区分奇数和偶数
            if (i % 2 ** 0) {
                evenSum += i;
            } else {
                oddSum += i;
            }
        }
        //输出计数和、偶数和
        System.out.println("所有奇数的和为：" + oddSum);
        System.out.println("所有偶数的和为：" + evenSum);
    }
}
-------------------------------
运行结果：
   所有奇数的和为：2500
   所有偶数的和为：2550

//for循环举例2
public class Demo05 {
    public static void main(String[] args) {
        //用while或for循环输出1~1000之间可以被5整除的数，每行8个
        //使用for循环遍历0~1000
        for (int i = 1; i <= 1000; i++) {
            //判断当i可以被5整除，打印输出
            //print打印输出后不会换行
            //println打印输出后自动换行
            if (i % 5 ** 0) {
                System.out.print(i + "\t");
            }
            //判断当i可以被15整除，也就是每行数量积累到8的时候，进行换行
            if (i % (5 * 8) ** 0) {
                println打印输出后自动换行
                System.out.println();
                //使用print输出转义字符\n(换行符)
                //System.out.print('\n');
            }
        }
    }
}
--------------------------------------------
运行结果：
    5    10    15    20    25    30    35    40    
    45    50    55    60    65    70    75    80    
    85    90    95    100    105    110    115    120    
    125    130    135    140    145    150    155    160    
    165    170    175    180    185    190    195    200    
    205    210    215    220    225    230    235    240    
    245    250    255    260    265    270    275    280    
    285    290    295    300    305    310    315    320    
    325    330    335    340    345    350    355    360    
    365    370    375    380    385    390    395    400    
    405    410    415    420    425    430    435    440    
    445    450    455    460    465    470    475    480    
    485    490    495    500    505    510    515    520    
    525    530    535    540    545    550    555    560    
    565    570    575    580    585    590    595    600    
    605    610    615    620    625    630    635    640    
    645    650    655    660    665    670    675    680    
    685    690    695    700    705    710    715    720    
    725    730    735    740    745    750    755    760    
    765    770    775    780    785    790    795    800    
    805    810    815    820    825    830    835    840    
    845    850    855    860    865    870    875    880    
    885    890    895    900    905    910    915    920    
    925    930    935    940    945    950    955    960    
    965    970    975    980    985    990    995    1000

//for循环举例3：打印九九乘法表
public class Demo05 {
    public static void main(String[] args) {
        //使用第一层for循环，控制第一个操作数遍历1~9
        for (int row = 1; row < 10; row++) {
            //使用第二层for循环，控制第二个操作数遍历1~操作数1
            for (int clum = 1; clum <= row; clum++) {
                //输出乘法算式，使用转义字符\t(制表符)保证算式的对齐
                System.out.print(row + "*" + clum + "=" + row * clum + "\t");
            }
            //当第二个操作数递增至与第一个操作数相同时，跳出第二层for循环，执行换行
            //然后第一层for循环中，操作数1加一，开启下一行算式的输出
            System.out.println();
        }
    }
}
-------------------------------------
运行结果：
    1*1=1    
    2*1=2    2*2=4    
    3*1=3    3*2=6    3*3=9    
    4*1=4    4*2=8    4*3=12    4*4=16    
    5*1=5    5*2=10    5*3=15    5*4=20    5*5=25    
    6*1=6    6*2=12    6*3=18    6*4=24    6*5=30    6*6=36
    7*1=7    7*2=14    7*3=21    7*4=28    7*5=35    7*6=42    7*7=49    
    8*1=8    8*2=16    8*3=24    8*4=32    8*5=40    8*6=48    8*7=56    8*8=64    
    9*1=9    9*2=18    9*3=27    9*4=36    9*5=45    9*6=54    9*7=63    9*8=72    9*9=81

4.增强型for循环

Java5 引入了一种主要用于数组的增强型 for 循环。Java 增强 for 循环语法格式如下:

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

**声明语句：**声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

//增强型for循环
public class Demo05 {
    public static void main(String args[]) {
        //定义一个数组，数组名为numbers，数组内元素都是int型
        int [] numbers = {10, 20, 30, 40, 50};
        //增强型for循环：定义新的局部变量x，类型与数组元素类型相同，表达式为数组名或数组的方法
        //相当于遍历数组
        for(int x : numbers ) {
            // x 等于 30 时跳出循环
            if( x ** 30 ) {
                break;
            }
            System.out.println( x );
        }
        System.out.println("-------------------");
        //等价于以下for循环
        for (int i = 0; i < 5; i++) {
            System.out.println(numbers[i]);
        }
    }
}
----------------------------------
运行结果：
    10
    20
    -------------------
    10
    20
    30
    40
    50

5. break与continue

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。不执行循环中剩余的语句，去执行该循环下面的语句。

continue 适用于任何循环控制结构中，作用是终止某次循环过程，即提奥果循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

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

//continue关键字示例
public class Demo05 {
    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");
        }
        System.out.println("***********************************");
        i = 0;
        while (i < 100) {
            i++;
            if (i % 10 ** 0) {
                System.out.println();
                break;
            }
            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     
    ***********************************
    1     2     3     4     5     6     7     8     9

五、流程控制习题

1.打印7行三角形

public class Demo06 {
    //打印三角形
    public static void main(String[] args) {
        //最外层控制三角形的行数
        for (int row = 1; row <= 5; row++) {
           //循环1：打印左侧空白,计算每行空白的个数
            for (int colu = 5; colu > row; colu--) {
                System.out.print(" ");
            }
            //循环2：打印*，计算每行*的个数
            for (int colu = 0; colu < 2 * row - 1; colu++) {
                System.out.print("*");
            }
            //换行
            System.out.println();
        }
    }
}
-----------------------------
运行结果：
        *
       ***
      *****
     *******
    *********

mport java.util.Scanner;
public class Demo06 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入三角形的层数：");
        int num = scanner.nextInt();
        System.out.println("************************");
        for (int i = 1; i <= 2 * num - 1; i++) {
            for (int j = 1; j <= 2 * num - 1; j++) {
                if (j ** num - i + 1 || j ** num + i - 1) {
                    System.out.print("*");
                }else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
}
-------------------------------------
运行结果：
    请输入三角形的层数：
    9
    ************************
            *        
           * *       
          *   *      
         *     *     
        *       *    
       *         *   
      *           *  
     *             * 
    *               *

转载