Java流程控制

1. 用户交互 Scanner

Scanner对象

Java中提供了一个工具栏：java.util.Scanner；这是java5的新特性，可以通过Scanner 类来获取用户输入的值。
基本语法：

Scanner s = new Scanner(System.in);

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

next()

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

/**
 * 使用 next() 接收时
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建Scanner对象   System.in:表示接收从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        //判断是否有值输入
        //hasNext()：表示有下一个
        if (scanner.hasNext()){
            //程序执行到此处时，会停留在此，等待输入，当输入完值后才继续向下执行
            //next：下一个
            String next = scanner.next();
            System.out.print("这是next的执行效果：" + next);
        }
        //凡是io流，都必须要关流，不然会占用很多资源
        scanner.close();
    }
}

nextLin()

以 Exter 为结束符，也就是说 nextLine() 方法返回的时输入回车之前的所有字符。
可以获得空白。

/**
 * 使用 nextLine() 接收
 */
public class Demo02 {
    public static void main(String[] args) {
        //创建 scanner 对象
        Scanner scanner = new Scanner(System.in);
        //hasNextLine:有下一行，
        //判断是否有下一行
        if (scanner.hasNextLine()){
            //程序走到此处，会等待输入
            //nextLine：下一个
            String s = scanner.nextLine();
            System.out.println("使用nextLine接收：" + s);
        }
        //关流
        scanner.close();
    }
}

if...else

/**
 * if...else 语句
 */
public class Demo03 {
    public static void main(String[] args) {
        //创建一个Scanner对象
        Scanner scanner = new Scanner(System.in);

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

        int a = 0;
        float b = 0.0f;
        //hasNextInt()：接收的数据为整型......
        //hasNextDouble();   ......
        if(scanner.hasNextInt()){
            //接收数据
            a = scanner.nextInt();
            System.out.println("接收的整数为：" + a);
        }else {
            System.out.println("该数据不是整数");
        }
        //hasNextFloat()：接收的数据为单精度类型......
        if(scanner.hasNextFloat()){
            b = scanner.nextFloat();
            System.out.println("float数据为：" + b);
        }else {
            System.out.println("该数据不是浮点类型");
        }
        //关流
        scanner.close();
    }
}

while()语句

public class Demo04 {
    //要求：从键盘录入数据，没输入一个数据，用回车确认；当输入的值为非数值型时，结束输入并输出数据的个数、总和、平均数
    public static void main(String[] args) {
        //创建 Scanner 对象
        Scanner scanner = new Scanner(System.in);

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

        //定义变量，用于接收数据个数、总和、平均值
        int number = 0;
        float sum = 0.0f;
        double avg = 0;

        while (scanner.hasNextDouble()){
            //接收数据
            double nextLine = scanner.nextDouble();
            //计算数据总和
            sum += nextLine;
            //计算输入的个数
            number++;
        }
        avg = (sum / number);
        System.out.println("数据总和：sum = " + sum);
        System.out.println("数据个数：number = " + number);
        System.out.println("数据总和：avg = " + avg);
    }
}

while循环开始后bai，先判断条件是否满du足，如zhi果满足就执行循环dao体内的语句，执行完zhuan毕后再回来判shu断条件是否满足，如此无限重复；直到条件不满足时，执行while循环后边的语句。简单来讲就是说while循环是先判断后循环，判断如果满足条件进入循环本次循环后再次判断。

2. 顺序结构

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

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

3. 选择结构

if 单选择结构

我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用 if 语句来表示。
语法：

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

例：

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    //接收键盘录入的数据
    String nextLine = scanner.nextLine();

    //判断值是否相等
    if ("Hello".equals(nextLine)){
        System.out.println("相等");
    }
}
字符串与字符串做比较时，不是使用（==）符号；而是使用（equals）关键字

if 双选择结构

语法：

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

例：

public static void main(String[] args) {
    //判断考试分数大于60为及格，否则为不及格
    Scanner scanner = new Scanner(System.in);

    System.out.println("请输入一个数据...");

    //接收键盘录入数据
    double sourc = scanner.nextDouble();

    //判断数据是否大于60
    if(sourc > 60){
        System.out.println("及格");
    }else {
        System.out.println("不及格");
    }
}

if 多选择结构

语法：

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

例：

public static void main(String[] args) {
    //判断考试分数大于60为及格，否则为不及格
    Scanner scanner = new Scanner(System.in);

    System.out.println("请输入一个数据...");

    //接收键盘录入数据
    double sourc = scanner.nextDouble();

    //判断数据是否大于60
    if(sourc == 100){
        System.out.println("满分");
    }else if (sourc < 100 && sourc >= 90){
        System.out.println("A级");
    }else if (sourc < 90 && sourc >= 80){
        System.out.println("B级");
    }else if (sourc < 80 && sourc >= 70){
        System.out.println("C级");
    }else if(sourc < 70 && sourc >= 60){
        System.out.println("D级");
    }else if (sourc < 60 && sourc >= 0){
        System.out.println("不及格");
    }else {
        System.out.println("输入数据错误，请从新输入！");
    }
}
只要满足一个条件为 true，则不会在走其他任何一个条件。

嵌套 if 结构

语法：

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

switch 多选择结构

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
switch 语句中的变量类型可以是：
- byte、short、int、char
- 从 Java SE 7 开始
- switch 支持字符串 String 类型了
- 同时 case 标签必须为字符串常量或字面量

public static void main(String[] args) {
    /**
         * switch 语句
         * 如果不加 break 关键字，会出现 case 穿透现象
         * jdk7之后，增加了字符串形式
         * 所有字符串的本质都是数字，底层使用的是 hashCode() 方法，将字符串转为数字，在进行计算
         */
    String str = "张三";
    //hash值
    System.out.println(str.hashCode());
    switch (str){
        case "李四":
            System.out.println("李四");
            break;
        case "张三":
            System.out.println("张三");
            break;
        case "王五":
            System.out.println("王五");
            break;
        default:
            System.out.println("输入有误，请从新输入！");
    }
}

使用 idea 反编译查看底层代码结果：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package struct;

public class switchDemo {
    public switchDemo() {
    }

    public static void main(String[] args) {
        String str = "张三";
        System.out.println(str.hashCode());
        byte var3 = -1;
        switch(str.hashCode()) {
            case 774889:
                if (str.equals("张三")) {
                    var3 = 1;
                }
                break;
            case 842061:
                if (str.equals("李四")) {
                    var3 = 0;
                }
                break;
            case 937065:
                if (str.equals("王五")) {
                    var3 = 2;
                }
        }

        switch(var3) {
            case 0:
                System.out.println("李四");
                break;
            case 1:
                System.out.println("张三");
                break;
            case 2:
                System.out.println("王五");
                break;
            default:
                System.out.println("输入有误，请从新输入！");
        }

    }
}

4. 循环结构

while 循环

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

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

只要布尔值为 true ，循环就会一直执行下去
大多数情况是会让循环停止下来的，需要一个让表达式失效的方式来结束循环
少部分情况需要循环一直执行，比如服务器的请求响应监听等
循环条件一直为 true 就会造成无限循环【死循环】，正常的业务编程中应该尽量避免死循环；会影响程序性能或者造成程序卡死崩溃。

例：

public static void main(String[] args) {
    int i = 0;
    int sum = 0;
    while (i <= 100){
        sum += i;
        i++;
    }
    System.out.println(sum);
}

do...while 循环

对于 while 语言而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do...while 循环和 while 循环相似，不同的是，do...while 循环至少会执行一次。
语法：

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

While 和 do ... While 的区别：
- while 先判断，后执行。do...while 先执行，后判断
- do...while 总是保证循环体会被至少执行一次！

public static void main(String[] args) {
    int a = 0;
    /**
         * while() 循环
         */
    while (a < 0) {
        System.out.println(a);
        a++;
    }

    System.out.println("-----------------");

    /**
         * do...while 循环
         */
    do {
        System.out.println(a);
        a++;
    } while (a < 0);
}

for 循环

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

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

例：for 和 while 做比较

public static void main(String[] args) {
    //定义变量
    int i = 0;
    while (i < 100){//条件判断
        System.out.println(i);//循环体
        i += 2;//迭代：变量随着循环而发生改变
    }
    System.out.println("While条件循环结束！");

    System.out.println("----------------");

    for (int k = 0; k < 100; k++) {
        System.out.println(k);//循环体
    }
    System.out.println("for循环条件结束！");
}

例：计算0~100之间的奇数和偶数之间的和

public static void main(String[] args) {
    //计算0~100之间的奇数和偶数之间的和

    int oddSum = 0;//奇数
    int evenSum = 0;//偶数

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

例：使用for循环输出1~1000之间能被 5 整除的数，并且每行输出 3 个

public static void main(String[] args) {
    //使用for循环输出1~1000之间能被 5 整除的数，并且每行输出 3 个
    for (int i = 1; i < 1000; i++) {
        //使用模(%)计算，变量 i 是否能将 5 整除
        if (i % 5 == 0){
            System.out.print(i + "\t");//输出数据，不进行换行
        }
        //在判断该行是否有三个数据
        if(i % (5 * 3) == 0){
            System.out.println();
        }
    }
}
-------------
5   10  15  
20  25  30  
35  40  45  
50  55  60  
65  70  75

例：九九乘法表

public static void main(String[] args) {
    //外循环控制行
    for (int i = 1; i <= 9; i++) {
        //内循环控制列
        for (int j = 1; j <= i; j++) {
            //判断如果 i==j 则换行，反之，不换行
            if (i == j) {
                System.out.println(j + "*" + i + "=" + (j * i));
            } else {
                System.out.print(j + "*" + i + "=" + (j * i) + "\t");
            }
        }
    }
}
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();
    }
}
--------------------
    1*1=1
    1*2=2   2*2=4
    1*3=3   2*3=6   3*3=9
    1*4=4   2*4=8   3*4=12  4*4=16
    1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
    1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
    1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
    1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
    1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

增强 for 循环

Java5引入了一种主要用于数据或集合的增强型 for 循环
java 增强 for 循环语法格式如下：

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

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

5. break & continue

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

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

//break
public static void main(String[] args) {
    int i = 0;
    while (i < 100){
        i++;
        System.out.println(i);
        if (i == 20){
            break;//结束所有操作
        }
    }
    System.out.println("程序已结束！");
}

//continue
public static void main(String[] args) {
    int i = 0;
    while (i < 20) {
        i++;
        if (i % 5 == 0) {
            continue;//结束本次操作
        }
        System.out.println(i);
    }
}

6. 练习

public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
        for (int j = 4; j >= i; j--) {
            System.out.print(" ");
        }

        for (int k = 0; k <= i; k++){
            System.out.print("*");
        }

        for (int h = 0; h < i; h++){
            System.out.print("*");
        }
        System.out.println();
    }
}
-----------------------------------
     *
    ***
   *****
  *******
 *********

posted @ 2021-03-06 18:59 初夏_雨露阅读(61) 评论(0) 收藏举报

刷新页面返回顶部

初夏_雨露