009Java基础之流程控制

合集 - Java学习(2)

1.009Java基础之流程控制2023-07-06

2.008Java基础语法2023-07-04

收起

Java基础之流程控制

---

1、用户交互Scanner

Scanner对象

• 我们之前学的基本语法中并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特性，我们可以通过Scanner类来获取用户的输入。
• 基本语法：

Scanner sc = new Scanner(System.in);

• 通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()和hasNextLine()判断是否还有输入的数据。

使用next()和nextLine()方法接收数据的区别

• next()：
  1. 一定要读取到有效字符后才可以结束输入，控制台按空格、回车都没有用。
  2. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  4. next()不能得到带有空格的字符串。
• nextLine():
  1. 以Enter作为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。
  2. 可以获得空白。

实例：

使用next()方法接收

Scanner scanner = new Scanner(System.in);
if (scanner.hasNext()){
    String str = scanner.next();
    System.out.println("使用next()接收到的是："+str);
}

输入：

Hello World!

输出：

使用next()方法接收到的是：Hello

可以看到输入有效字符集合Hello后，空白变成了结束符。

使用nextLine()方法接收

Scanner scanner = new Scanner(System.in);
if (scanner.hasNextLine()){
    String str = scanner.nextLine();
    System.out.println("使用nextLine()方法接收到的是："+str);
}

输入：

20 30 40

输出：

通过nextLine()方法接收到的是：20 30 40

特别提醒：凡是属于IO流的类，如果不关闭它，就会一直占用资源，所以要养成用完就关的好习惯！

scanner.close();

当我们需要使用Scanner扫描器输入不同类型的数据时，可以选用以下方法：

• nextInt()：用于接收Int型
• nextFloat()：用于接收单精度浮点型
• nextDouble()：用于接收双精度浮点型
• ……

一个简单的Scanner应用

//输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果：
//创建一个扫描器，从键盘中获取数据
Scanner scanner = new Scanner(System.in);
 
//和
double sum = 0;
//计算输入了多少个数字
int i = 0;
 
//通过循环判断是否还有输入，并在里面对每一次进行求和统计
while (scanner.hasNextDouble()){
    double x = scanner.nextDouble();
    sum += x;
    i++;
}
//计算平均数
double average = sum/i;
//输出结果
System.out.println("总和为："+sum);
System.out.println("平均数为："+average);
 
//Scanner使用完，要记得关闭
scanner.close();

2、顺序结构

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

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

3、选择结构

选择结构可以通过if或switch实现。

• if单选择结构
• if双选择结构
• if多选择结构
• 嵌套的if结构
• switch多选择结构

if单选择结构

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

代码实例：

Scanner scanner = new Scanner(System.in);
System.out.println("Please enter content:");
String s = scanner.nextLine();
 
//判断字符串是否相等，使用.equals()方法而不是==
if(s.equals("Hello")){
    System.out.println(s);
}
System.out.println("End");
scanner.close();

if双选择结构

假设现在有个需求，公司要收购一个软件，成功了，给人支付100万元，失败了就找人开发。这样的需求用一个if就搞不定了，我们需要有两个判断，需要一个双选择结构，所以就有了if-else结构。

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

代码实例：

//创建一个Scanner扫描器，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("请输入收购结果：成功/（其他）");
String str = scanner.nextLine();
 
//比较判断
if(str.equals("成功")){
    System.out.println("收购成功，支付100万元。")
}else{
    System.out.println("收购失败，找人开发");
}
 
//Scanner使用完毕，关闭Scanner
scanner.close();

if多选择结构

我们发现刚才的代码不一定能适应所有情况，真实情况可能是多种多样的，在生活中我们很多时候的选择也不仅仅只有两个，所以我们需要一个多选择结构来处理这类问题！

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

代码实例：

//创建一个Scanner扫描器，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
 
System.out.println("请输入成绩：");
int score = scanner.nextInt();
 
//根据输入成绩判断等级
 
if (score == 100){
        System.out.println("恭喜满分");
}else if(score<100 && score>=90){
        System.out.println("A");
}else if(score<90 && score>=80){
        System.out.println("B");
}else if(score<80 && score>=70){
        System.out.println("C");
}else if(score<70 && score>=60){
        System.out.println("D");
}else if(score<60 && score>=0){
        System.out.println("不及格");
}else{
        System.out.println("成绩不合法");
}

嵌套的if结构

使用嵌套的if...else语句是合法的。也就是说你可以在另一个if或者else if语句中使用if或else if语句。你可以像if语句一样嵌套else if...else。

if(布尔表达式1){
    //如果布尔表达式1的值为true则执行
    if(布尔表达式2){
        //如果布尔表达式1和2的值都为true则执行
    }
}

switch多选择结构

多选择结构还有一种实现方式就是switch case结构。

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

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

switch语句的变量类型可以是：

• byte、short、int或者char
• *从Java SE 7开始，switch支持字符串String类型了
• 同时case标签必须为字符串常量或字面量

代码实例1：

char grade = 'F';
 
switch (grade){
    case 'A':
        System.out.println("优秀");
        break;//case具有穿透现象，如果一个case下的语句执行完后没有break，那么就会将之后所有的语句都执行出来
    case 'B':
        System.out.println("良好");
    case 'C':
        System.out.println("及格");
    case 'D':
        System.out.println("再接再厉");
    case 'E':
        System.out.println("挂科");
    default:
        System.out.println("未知等级");
}

注意：case具有穿透现象，如果一个case对应的语句执行完毕后没有break语句，那么程序会将之后的所有语句执行，包括default对应的语句。

JDK7后，switch也支持字符串类型。字符的本质还是数字，我们可以通过反编译一窥switch在处理String字符串时的方法：

在IDEA中，Ctrl+Shift+Alt+S打开Project Structure，找到Project compiler output，将路径复制到资源管理器打开，此时将看到生成的class文件，将class文件拷贝到IDEA的Java项目文件对应的文件夹下，然后就可以在IDEA中看到class文件内容了：

可以看到，在进行switch比较的时候，Java底层是将字符串的hashCode扔了进去，case的也是hashCode，当hashCode一致时，再用equals方法将字符串进行比较。本质而言进行了两次switch-case，第一次对应hashCode，第二次对应将str比对结果抽象成数字后再执行对应的操作。

看源码是非常重要的，是一名优秀程序开发者的基本素养。

4、循环结构

• while循环
• do...while循环
• for循环（在Java5中引入了一种主要用于数组的增强型for循环，用来遍历一些数字和对象。）

while循环

while是最基本的循环，它的结构为：

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

只要布尔表达式为true，循环就会一直执行下去。

我们大多数情况下最终是会让循环停下来的，我们需要一个让表达式失效的方式来结束循环。

少部分情况下需要循环一直执行，比如服务器的请求响应监听等。

循环条件一直为true就会陷入无限循环（死循环），我们正常的业务编程中应该尽量避免死循环。会影响程序性能或造成程序卡死崩溃！

代码实例：

//计算1+2+3+...+100
int i = 0;
int sum = 0;
while(i<100){
    i++;
    sum += i;
}
System.out.println("1+2+3...+100="+sum);

do...while循环

对于while循环而言，如果不满足条件，则不能进入循环。但有时我们需要即使不满足条件，也至少执行一次。

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

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

while和do...while的区别：

• while先判断后执行，dowhile是先执行后判断；
• Do...while总是保证循环体至少被执行一次，这是他们的主要区别。

代码实例：

/计算1+2+3...+100
int i = 0;
int sum = 0;
 
do {
    i++;
    sum += i;
}while (i<100);
System.out.println("1+2+3+...100="+sum);

⭐For循环

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

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

语法格式如下：

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

练习一：计算0到100之间的奇数和偶数的和

//计算0到100间奇数和偶数的和
int oddSum = 0;
int evenSum = 0;
for (int i = 0;i<=100;i++){
    if (i%2 == 0){
        evenSum += i;
    }else {
        oddSum += i;
    }
}
System.out.println("奇数和为："+oddSum);
System.out.println("偶数和为："+evenSum);

练习二：用while循环或for循环输出1-1000之间能被5整除的数，并且每行输出3个

//用while循环或for循环输出1-1000之间能被5整除的数，并且每行输出3个
//用for循环
for (int i = 1,flag = 0;i<=1000;i++){
    if (i%5 ==0){
        flag++;
        if (flag>3){
            System.out.print("\n");
            flag = 1;
        }
        System.out.print(i+" ");
    }
}
System.out.println();
//用while循环
int i = 0,flag = 0;
while(i<1000){
    i++;
    if (i%5 == 0){
        flag++;
        if (flag>3){
            System.out.println();
            flag = 1;
        }
        System.out.print(i+" ");
    }
}
System.out.println();
//用do...while循环
int j = 0,flag1 = 0;
do {
    j++;
    if (j%5 ==0){
        flag1++;
        if (flag1>3){
            System.out.println();
            flag1 = 1;
        }
        System.out.print(j+" ");
    }
}while (j<1000);

练习三：打印九九乘法表

//打印九九乘法表
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();
}

要学会拆分困难问题的思想：

1. 我们先打印第一列
2. 把固定的1再用一个循环包起来
3. 去掉重复项，通过j<=i
4. 调整最后的样式，包括换行、制表符等

IDEA里的for循环快捷写法：

如果想写一个1-100的for循环，只需在IDEA中输入

100.for

即可自动填充为1-100的for循环：

for(int i = 0;i<100;i++){
    
}

关于for循环有以下几点说明：

最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。

然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。

执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。

再次检测布尔表达式，循环执行上面的过程。

增强for循环

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

语法格式如下：

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

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

代码实例：

//定义一个数组
int [] numbers = {10,20,30,40,50};
//遍历这个数组中每一个元素并打印
for (int x:numbers){
    System.out.println(x);
}
//以上增强for循环等价于
for (int i = 0;i<5;i++){
    System.out.println(numbers[i]);
}

5、break&continue

break

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

代码实例1：

int i = 0;
while(i<100){
    i++;
    if(i%10 == 0){
        System.out.println();
        break;
    }
    System.out.print(i);
}

输出结果：

123456789

可以看到直接跳出了整层循环。

代码实例2：

for(int i = 0;i < 10;i++){
    for(int j = 0;j < 10;j++){
        if (j == 8){
            break;
        }
        System.out.print("i="+i+",j="+j+"\t");
    }
    System.out.println();
}

输出结果：

i=0,j=0	i=0,j=1	i=0,j=2	i=0,j=3	i=0,j=4	i=0,j=5	i=0,j=6	i=0,j=7	
i=1,j=0	i=1,j=1	i=1,j=2	i=1,j=3	i=1,j=4	i=1,j=5	i=1,j=6	i=1,j=7	
i=2,j=0	i=2,j=1	i=2,j=2	i=2,j=3	i=2,j=4	i=2,j=5	i=2,j=6	i=2,j=7	
i=3,j=0	i=3,j=1	i=3,j=2	i=3,j=3	i=3,j=4	i=3,j=5	i=3,j=6	i=3,j=7	
i=4,j=0	i=4,j=1	i=4,j=2	i=4,j=3	i=4,j=4	i=4,j=5	i=4,j=6	i=4,j=7	
i=5,j=0	i=5,j=1	i=5,j=2	i=5,j=3	i=5,j=4	i=5,j=5	i=5,j=6	i=5,j=7	
i=6,j=0	i=6,j=1	i=6,j=2	i=6,j=3	i=6,j=4	i=6,j=5	i=6,j=6	i=6,j=7	
i=7,j=0	i=7,j=1	i=7,j=2	i=7,j=3	i=7,j=4	i=7,j=5	i=7,j=6	i=7,j=7	
i=8,j=0	i=8,j=1	i=8,j=2	i=8,j=3	i=8,j=4	i=8,j=5	i=8,j=6	i=8,j=7	
i=9,j=0	i=9,j=1	i=9,j=2	i=9,j=3	i=9,j=4	i=9,j=5	i=9,j=6	i=9,j=7

可以看到break在j == 8的时候强制停止了所在的本层循环，而外层循环不受影响。

continue

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

代码实例1：

int i = 0;
while(i<100){
    i++;
    if(i%10 == 0){
        System.out.println();
        continue;
    }
    System.out.print(i);
}

输出结果：

123456789
111213141516171819
212223242526272829
313233343536373839
414243444546474849
515253545556575859
616263646566676869
717273747576777879
818283848586878889
919293949596979899

可以看到程序只是每逢10的时候终止本次循环，接着进行下一次是否进行循环的判定。

代码实例2：

for(int i = 0;i < 10;i++){
    for(int j = 0;j < 10;j++){
        if (j == 8){
            continue;
        }
        System.out.print("i="+i+",j="+j+"\t");
    }
    System.out.println();
}

输出结果：

i=0,j=0	i=0,j=1	i=0,j=2	i=0,j=3	i=0,j=4	i=0,j=5	i=0,j=6	i=0,j=7	i=0,j=9	
i=1,j=0	i=1,j=1	i=1,j=2	i=1,j=3	i=1,j=4	i=1,j=5	i=1,j=6	i=1,j=7	i=1,j=9	
i=2,j=0	i=2,j=1	i=2,j=2	i=2,j=3	i=2,j=4	i=2,j=5	i=2,j=6	i=2,j=7	i=2,j=9	
i=3,j=0	i=3,j=1	i=3,j=2	i=3,j=3	i=3,j=4	i=3,j=5	i=3,j=6	i=3,j=7	i=3,j=9	
i=4,j=0	i=4,j=1	i=4,j=2	i=4,j=3	i=4,j=4	i=4,j=5	i=4,j=6	i=4,j=7	i=4,j=9	
i=5,j=0	i=5,j=1	i=5,j=2	i=5,j=3	i=5,j=4	i=5,j=5	i=5,j=6	i=5,j=7	i=5,j=9	
i=6,j=0	i=6,j=1	i=6,j=2	i=6,j=3	i=6,j=4	i=6,j=5	i=6,j=6	i=6,j=7	i=6,j=9	
i=7,j=0	i=7,j=1	i=7,j=2	i=7,j=3	i=7,j=4	i=7,j=5	i=7,j=6	i=7,j=7	i=7,j=9	
i=8,j=0	i=8,j=1	i=8,j=2	i=8,j=3	i=8,j=4	i=8,j=5	i=8,j=6	i=8,j=7	i=8,j=9	
i=9,j=0	i=9,j=1	i=9,j=2	i=9,j=3	i=9,j=4	i=9,j=5	i=9,j=6	i=9,j=7	i=9,j=9

可以看到，相比break，continue控制下的循环除了j == 8时不执行后面的语句外，后面的j == 9也继续执行了，并且与break一样也不终止外层循环。

关于goto关键字

• goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用；Java没有goto。然而，在break和continue两个关键字的身上，我们仍能看到一些goto的影子——带标签的break和continue。
• “标签”是指后面跟一个冒号的标识符，例如label:
• 对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

代码实例：

//打印101-150之间所有的质数
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+" ");
}

输出结果：

101 103 107 109 113 127 131 137 139 149

我们在最外层for循环前定义了一个标签outer，当i%j == 0，即i不是质数时，通过continue跳出到外层循环，直接执行下一次循环，因此前一次循环里的打印语句就不会被执行。但是这种写法是非常不建议的。

可以用以下方式改写程序：

//打印101-150之间的所有质数
boolean flag = false;
for(int i = 101;i<=150;i++){
    for(int j = 2;j <= i/2;j++){
        if(i%j == 0){
            flag = false;
            break;
        }
        flag = true;
    }
    if(flag){
        System.out.print(i+" ");
    }
}

输出结果：
101 103 107 109 113 127 131 137 139 149

可以看到我们得到了同样的结果，且摒弃了插入标签这种被淘汰的写法。

6、练习

打印三角形：

    *
   ***
  *****
 *******
*********

思路：

1. 这是一个5层的三角形，需要用5次循环打印
2. 整个图形的打印应先打印左边空格，再打印右边星号，所以要内嵌两个循环，分别打印空格和星号
3. 接下来找到空格、星号与行数的对应关系：设行数为i，则空格数为5-i，星号数为2*i-1。
4. 据此我们可以构建出清晰的代码。

代码实例：

//打印三角形
for(int i = 1;i<=5;i++){
    for(int j = 1;j<=5-i;j++){
        System.out.print(" ");
    }
    for(int j = 1;j< 2*i-1;j++){
        System.out.print("*");
    }
    System.out.println();
}

输出结果：

    *
   ***
  *****
 *******
*********