你个锤子🔨 首页归档标签分类关于
Java流程控制
|Java

这一部分是流程控制，包括有：Scanner的使用，顺序结构，选择结构，循环结构，break和continue语句的使用，以及一些小练习。最近被抓去项目基地了，课程也比较紧张，偶尔还要打打游戏，所以更新频率会慢很多了。但是不会断更的。

1、用户交互Scanner

之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供有个类Scanner，可以用来获取用户的输入。

1.1 基本语法：

1
Scanner str = new Scanner(System.in);

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

使用 next 方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.hammer.scanner;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {

        // 创建一个扫描器对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收：");

        // 判断用户有没有输入字符
        if (scanner.hasNext()){
            // 使用next方式接收
            String str = scanner.next();
            System.out.println("输出的内容为："+str);
        }
        // 凡是属于IO流的类，如果不关闭会一直占用资源，要养成用完就关闭的好习惯
        scanner.close();
    }
}

执行以上程序输出结果：

可以看到只有hello输出了，world没了。接下来我们看看nextLine 方法。

使用 nextLine 方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.hammer.scanner;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        // 创建一个扫描器对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用nextLine方式接收");

        // 判断用户有没有输入字符
        if (scanner.hasNextLine()){
            // 使用nextLine方式接收
            String str = scanner.nextLine();
            System.out.println("输出的内容："+str);
        }
        scanner.close();
    }
}

执行以上程序输出结果：

next() 与 nextLine() 区别

next():

  • 1、一定要读取到有效字符后才可以结束输入；
  • 2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉；
  • 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符；
  • 4、next() 不能得到带有空格的字符串。

nextLine()：

  • 1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符；
  • 2、可以获得空白。

1.2 Scanner的进阶用法

hasNext…的用法

上面既然有hasNextInt的用法，那可不可以判断其他数据类型呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 从键盘接收数据
        int i = 0;
        float f = 0.0f;

        System.out.println("请输入整数：");

        if (scanner.hasNextInt()) {
            i = scanner.nextInt();
            System.out.println("整数数据：" + i);
        }else{
            System.out.println("输入的不是整数数据！");
        }

        System.out.println("请输入小数：");

        if (scanner.hasNextFloat()) {
            f = scanner.nextFloat();
            System.out.println("小数数据：" + f);
        }else{
            System.out.println("输入的不是小数数据！");
        }
        scanner.close();
    }
}

利用while循环做一个简单的计算器

如果一直扫描，输出个不一样的数据类型，是不是会终止？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 和
        double sum = 0;
        // 计算输入了多少个数字
        int m =0;

        // 通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        System.out.println("请输入数据：");
        while(scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            m = m + 1;
            sum = sum + x;
            System.out.println("你输入了第"+m+"个数据，当前结果是："+sum);
        }
        System.out.println(m+"个数的和为"+sum);
        System.out.println(m+"个数的平均值是"+sum/m);
        scanner.close();
    }
}

2、顺序结构

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

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

3、选择结构

3.1 if单选择结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class IfDemo01 {
    public static void main(String[] args) {
        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();
    }
}

3.2 if双选择结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class IfDemo02 {
    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("成绩及格");
        }
        scanner.close();
    }
}

3.3 if多选择结构

if语句还可以有一个else语句，else语句在所有else if语句之后。if语句可以有若干个else if语句，它们必须在else语句之前。一旦其中一个else if语句检测为true，其他的else if以及else都不会执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class IfDemo03 {
    public static void main(String[] args) {
        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("优秀");
        }else if (score<100 & score>=80){
            System.out.println("良好");
        }else if (score<100 & score>=60){
            System.out.println("及格");
        }else if (score<60& score>=0){
            System.out.println("不及格");
        }else{
            System.out.println("成绩输入有误");
        }
        scanner.close();
    }
}

3.4 嵌套的if结构

自己写的，还没测试出bug。应该是对的，如有错误，请与我联系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class IfDemo04 {
    public static void main(String[] args) {
        
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个0~100的整数：");
        int num = scanner.nextInt();

        if (num>50 & num<=100){
            if (num>75){
                int i = 75;
                while (i != num){
                    i++;
                }
                System.out.println("这个数字是"+i);
            } else{
                int i = 50;
                while (i != num){
                    i++;
            }
            System.out.println("这个数字是"+i);
            }
        }
        
        else if (num<=50 & num>=0){
            if (num>25){
                int i = 25;
                while (i != num){
                    i++;
                }
            System.out.println("这个数字是"+i);
            } else{
                int i = 0;
                while (i != num){
                    i++;
                }
                System.out.println("这个数字是"+i);
            }
        }else{
            System.out.println("输入的数据不符合要求");
        }
        
        scanner.close();
    }
}

3.5 switch多选择结构

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class SwitchDemo01 {
    public static void main(String[] args) {
        // case穿透
        char grade = 'B';

        switch (grade){
            case 'A':
                System.out.println("优秀");
                break;  // 可选
            case 'B':
                System.out.println("良好");
            case 'C':
                System.out.println("及格");
            default:
                System.out.println("未知等级！");
                break;
        }
    }
}
输出的结果

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

- byte、short、int或者char
- 从JDK-7开始，switch支持字符串String类型了（本质是转化为哈希值，可以在反编译文件中查看）
- 同时case标签必须为字符串常量或字面量

4、循环结构

4.1 while循环

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

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

  • 少部分情况需要循环一直执行，例如服务器的请求响应。

  • 循环条件一直为true就会造成无限死循环，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class WhileDemo02 {
    public static void main(String[] args) {
        // 计算1+2+...+100 = ?

        int i = 0;
        int sum = 0;

        while(i<100){
            i++;
            sum = sum + i;
        }
        System.out.println(sum);
    }
}

4.2 do…while循环

对于while循环而言，如果不满足条件，则不能进入循环。但是有些时候，我们需要即使不满足条件，也至少执行一次。这个时候就需要用上do…while循环。

  • while循环和do…while循环的区别：
    • while先判断后执行，do…while是先执行后判断
    • do…while总是保证循环体会被至少执行一次！这是它们的主要差别
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class DoWhileDemo02 {
    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);
            a++;
        }while(a<0);
    }
}

最终输出的结果如下：

1
2
3
4
==========================
0

Process finished with exit code 0

4.3 for循环

虽然所有循环结构都可以用while或者do…while表示，但Java提供了另一种for循环，使一些循环结构变得更加简单。for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环执行的次数是在执行前就确定的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class ForDemo01 {
    public static void main(String[] args) {
        int a = 1;  // 初始化条件

        while (a<=100){ // 条件判断
            System.out.println(a);  // 循环体
            a+=2;
        }

        System.out.println("while循环结束！！");

        // 初始化值；条件判断；迭代
        for (int i = 1; i<=100; i++){ // 快捷键：100.for + 回车
            System.out.println(i);
        }
        System.out.println("for循环结束！！");
    }
}

注意点

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

练习1：计算0~100之间的奇数和偶数的和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ForDemo02 {
    public static void main(String[] args) {
        // 计算所有奇数和偶数的和
        int oddSum = 0;
        int evenSum = 0;

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

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

for循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ForDemo03 {
    public static void main(String[] args) {
        // 用while或for循环输出1~1000之间能被5整除的数，并且每行输出3个

        for (int i=0; i<=1000; i++){
            if (i%5 == 0){
                System.out.print(i+"\t");   // print 输出不会换行
                }
            if (i%(5*3)==0){
                System.out.println();       // println 输出会换行
            }
        }
    }
}

while循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ForDemo03 {
    public static void main(String[] args) {
        int i = 0;
        while(i<=1000){
            i++;
            if (i%5==0){
                System.out.print(i+"\t");
            }
            if (i%(5*3)==0) {
                System.out.println();
            }
        }
    }
}

练习3：打印九九乘法表

  1. 我们先打印第一列
  2. 我们把固定的1再用一个循环包装起来
  3. 去掉重复项 j<=i
  4. 调整样式
1
2
3
4
5
6
7
8
9
10
public class ForDemo04 {
    public static void main(String[] args) {
        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();
        }
    }
}

4.4增强for循环

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

格式如下：

1
2
3
4
for(声明语句 : 表达式)
{
    // 代码句子
}
  • 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素相等。
  • 表达式：表达式是要访问的数组名，或者是返回值为数组的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ForDemo05 {
    public static void main(String[] args) {
        int [] numbers = {10,20,30,40,50};    // 定义了一个数组

        for (int i =0;i<5;i++){
            System.out.print(numbers[i]+"\t");
        }
        System.out.println();
        // 遍历数组的元素，功能和上面的for一样
        for (int x:numbers){
            System.out.print(x+"\t");
        }
    }
}

输出的结果：

1
2
3
10	20	30	40	50	
10	20	30	40	50	
Process finished with exit code 0

5、break & continue

break

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

1
2
3
4
5
6
7
8
9
10
11
12
public class BreakDemo {
    public static void main(String[] args) {
        int i=0;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30){
                break;
            }
        }
    }
}

continue

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ContinueDemo {
    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);
        }
    }
}

goto

goto关键字很早就在程序设计语言中出现，尽管goto仍是Java一个保留字，但并未在语言中得到正式使用；Java没有goto。然而break和continue这两个关键字的身上，我们仍能看出一些goto的影子——带标签的break和continue。

“标签”是指后面跟一个冒号的标识符，例如：label：

对Java来说，唯一用到标签的地方是在循环语句之前，而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中段当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

练习：打印三角形

  • 拆分问题

一个三角形🔺是对称的，可以先打印半边。它的一半可以补全为矩形，其中对角线的左边是为空白的，对角线右边以“*”填充。

拆分步骤

  • 程序实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class TestDemo01 {
    public static void main(String[] args) {
        // 打印三角形 5行
        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >= i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
Author: 锤子🔨
Link: https://hammer-wh.github.io/posts/1092623140/
Copyright Notice: All articles in this blog are licensed under CC BY-NC-SA 4.0 unless stating additionally.
Java基础知识