Java流程控制

2021-06-08 18:02

阅读：444

标签：遍历统计区别客户端连接表示迭代字符串的比较未在图标

Java流程控制

1.用户交互Scanner

Scanner对象

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

Scanner s = new Scanner(System.in);

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

Scanner对象的分类

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

package Java流程控制;

import java.util.Scanner;

public class 用户交互Scanner1 {

    public static void main(String[] args) {

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

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

        //判断用户有没有输入字符串
        if (scanner.hasNext()==true){
            //使用next方式接收：
            String str = scanner.next();//这句话一旦执行，程序会等待用户输入完毕
            System.out.println("输出的内容为："+str);
        }

        //凡是属于IO流(输入输出流)的类如果不关闭会一直占用资源，要养成好习惯，用完就关掉
        scanner.close();
    }

}

nextLine()
- 以Ener为结束符，也就是说 nextLine() 方法返回的是敲回车键之前的所有字符
- 可以获得空白

package Java流程控制;

import java.util.Scanner;

public class 用户交互Scanner2 {

    public static void main(String[] args) {

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

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

        //判断用户是否还有输入
        if (scanner.hasNextLine()==true){
            //使用nextLine方式接收：
            String str = scanner.nextLine();//这句话一旦执行，程序会等待用户输入完毕
            System.out.println("输出的内容为："+str);
        }

        //凡是属于IO流(输入输出流)的类如果不关闭会一直占用资源，要养成好习惯，用完就关掉
        scanner.close();
    }

}

总结和梳理

package Java流程控制;

import java.util.Scanner;

public class 用户交互Scanner3 {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);//1.开始接收键盘数据

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

        String str = scanner.nextLine();//2.在此停止，直到用户输入完毕按下回车，将输入的数据变成一个变量保存到str这个字符串里

        System.out.println("输出的内容为："+str);//3.根据用户的输入进行输出

        scanner.close();//4.关闭这个IO流

    }

}

由于 next() 有空格就会断，所以平时 nextLine() 用得比较多，next() 的运用场景少一些

Scanner进阶使用案例1

package Java流程控制;

import java.util.Scanner;

public class Scanner进阶使用 {

    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()==true){
            i = Scanner.nextInt();
            System.out.println("整数数据：" + i);
        }else{
            System.out.println("输入的不是整数数据！");
        }


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

        //如果。。。那么
        if (Scanner.hasNextFloat()==true){
            f = Scanner.nextFloat();
            System.out.println("小数数据：" + f);
        }else{
            System.out.println("输入的不是小数数据！");
        }

        Scanner.close();//关闭IO流的代码可以先写，然后再中间写代码，就不会忘记关闭
    }

}

Scanner进阶使用案例2

package Java流程控制;

import java.util.Scanner;

public class Scanner进阶使用_例 {

    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;//这路也可以使用m++ (自增)
            sum = sum + X;
            System.out.println("傻逼，你输入了第"+ m +"个数据，然后当前总和="+ sum);
        }

        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值是" + (sum / m));

        scanner.close();
    }
}

2.顺序结构

Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行
顺序结构是最简单的算法结构
语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本结构

package Java流程控制;

public class 顺序结构 {

    public static void main(String[] args) {

        System.out.println("hello 1");
        System.out.println("hello 2");
        System.out.println("hello 3");
        System.out.println("hello 4");
        System.out.println("hello 5");

        //按照自上而下的顺序输出了 hello 12345

    }
}

3.选择结构

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

  if(布尔表达式)｛
      //如果布尔表达式为true将执行的语句
  ｝

举例：

package Java流程控制;

import java.util.Scanner;

public class 选择结构_if单选择结构 {

    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();

        /*输入hello 会输出hello和end ；输入其他字符 会直接输出end
        这就是选择结构的特点，如果成立(true/false)就执行下一语句，否则就跳过*/

    }
}

if 双选择结构
- 假如现在有个需求，公司要收购一个软件，成功的话，给人支付100万元，如果失败，就自己找人开发。这样子的需求，用刚才的if单选择就无法完成了，需要一个双选择结构，所以就有了if-else结构
- 语法：

    if(布尔表达式)｛
        //如果布尔表达式的值为true
    ｝else｛
        //如果布尔表达式的值为false

解析：布尔表达式之后：如果true--执行语句1 ； 如果false--执行语句2

package Java流程控制;

import java.util.Scanner;

public class 选择结构_if双选择结构 {

    public static void main(String[] args) {

        //分数大于等于60分就是合格，小于60分就是不及格

        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();

        //布尔表达式之后：如果true--执行语句1 ； 如果false--执行语句2
    }

}

if 多选择结构
- 当遇到更加复杂的情况，如有ABCD多种情况（存在区间多级判断），比如成绩 90-100为A，80-90为B...等等，在生活中我们很多时候的选择往往也不知两个，所以我们需要一个多选择结构来处理这些问题
- 语法

    if(布尔表达式1)｛
        //如果布尔表达式1的值为true执行代码
    ｝else if（布尔表达式2）｛
        //如果布尔表达式2的值为true执行代码
    ｝else if（布尔表达式3）｛
        //如果布尔表达式3的值为true执行代码
    ｝else if（布尔表达式4）｛
        //如果布尔表达式4的值为true执行代码
    ｝

举例：

package Java流程控制;

import java.util.Scanner;

public class 选择结构_if多选择结构 {

    public static void main(String[] args) {

        //分数90-100为A；80-89为B；70-79为C；60-69为D；60以下为不合格

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");

        int score = scanner.nextInt();

        if (score>=90 && score=80 && score=70 && score=60 && score=0){
            System.out.println("不及格 :( ");
        } else {
            System.out.println("成绩不合法");
        }

        scanner.close();

/*if 语句至多有 1 个 else 语句，else 语句应在所有 else if 语句之后
if 语句可以有若干个 else if 语句，它们必须在 else 语句之前
一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行*/

    }

}

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

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

? 所有的流程控制语句都可以相互嵌套而互不影响

package Java流程控制;

import java.util.Scanner;

public class 选择结构_嵌套的if结构 {

    public static void main(String[] args) {

        //以超市购物 会员/非会员和消费金额不同 享受不同折扣举例：

        Scanner input = new Scanner(System.in);

        System.out.println("请输入是否为会员：是（Y）否（N）");

        String name = input.next();

        System.out.println("请输入消费金额：");

        double money = input.nextDouble();


        if (name.equals("Y")){    //判断是否为会员  如果是会员：
            if (money >= 200){
                money = money * 0.7;    //会员且消费大于等于200，打7折
                System.out.println("会员且消费满200，七折优惠，你需要支付" + money + "元人民币，欢迎下次光临！");
            }else if (money = 0 ){
                money = money * 0.8;    //会员消费小于200，打8折
                System.out.println("会员且消费未满200，八折优惠，你需要支付" + money + "元人民币，欢迎下次光临！");
            }

            else{
                System.out.println("输入的消费金额不合法");    //输入其他数据，如负数，输出“不合法”
            }

        }else if (name.equals("N")){    //如果不是会员
            if (money >=100) {
                money = money * 0.9;    //非会员消费大于等于100，打9折
                System.out.println("非会员且消费满100，九折优惠，你需要支付" + money + "元人民币，欢迎下次光临！");
            }else if (money = 0){
                money = money * 1;    //非会员消费小于100，原价支付
                System.out.println("非会员且未满100，需要原价支付" + money + "元人民币，欢迎下次光临！");

            }else{
                System.out.println("输入的消费金额不合法");    //输入其他数据，如负数，输出“不合法”
            }


        }else {
            System.out.println("注意 由于之前未正确输入否为会员，无法得出应付金额！");    
            //输入除YN的其他数据，输出“无法得出金额”
        }
        input.close();    //关闭流
    }
    
}

switch 多选择结构
- 多选择结构还有一个实现方式就是 switch case 语句
- switch case 语句判断一个变量与一系列值中某个值是否相等，每个值成为一个分支
- 语法：
```
switch(expression){
    case value :
        //语句
        break;//可选
    case value ：
        //语句
        break;//可选
    //你可以有任意数量的 case 语句
    default ： //可选
        //语句
}
```
- switch 语句中的变量类型可以是：
  - byte、short、int 或者 char (示例为 switch多选择结构 1)
  - 从 Java SE 7 开始，switch 支持字符串 String 类型了(示例为 switch多选择结构 2)
  - 同时 case 标签必须为字符串常量或字面量

package Java流程控制;

public class switch多选择结构1 {

    public static void main(String[] args) {

        //case 穿透 ?-1 会解释 //switch 会匹配一个具体的值

        char grade = ‘A‘;

        switch (grade){
            case ‘A‘ :
                System.out.println("优秀");
                break;//输出将会这里停止 (break 为可选) 不会被 case 穿透 ?-1
            case ‘B‘ :
                System.out.println("良好");
                break;//停止输出下面的内容
            case ‘C‘ :
                /* -1 由于下面没有 break，如果输入C 将会把下面全部输出 直到遇到 break
                这就叫 case 穿透现象 (这里输入 C 会在输出 再接再厉 后停止)*/
                System.out.println("及格");
            case ‘D‘ :
                System.out.println("再接再厉");
                break;//停止 case 穿透
            case ‘E‘ :
                System.out.println("挂科");
                break;//停止 case 穿透
            default:
                System.out.println("未知等级");

            /*由于 case穿透现象 的存在，
            所以一般每写一个 case，都应该在后面加上 break */

        }

    }

}

package Java流程控制;

public class switch多选择结构2 {

    public static void main(String[] args) {

        /*从 Java SE 7 开始，switch 支持字符串 String 类型了
        也就是从 JDK7开始 支持字符串的比较了，表达式的结果可以是字符串 */

        /*拓展：这是因为 字符的本质还是数字，编译是java--class(字节码文件)
        在 反编译class(可以用IDEA进行) 之后 发现其实字符串也是根据哈希值比较的 */

        String name = "X";

        switch (name){
            case "低密度脂蛋白":
                System.out.println("低密度脂蛋白");
                break;
            case "木日雨林":
                System.out.println("木日雨林");
                break;
            default:
                System.out.println("???!!!");

        /*怎么用 IDEA 进行反编译？在资源管理器中，将输出的 class文件 拷贝到java类文件夹里
        然后再打开IDEA，打开那个class(字节码文件 图标为01)文件就可以 */

        }

    }

}

4.循环结构

while 循环
- 是最基本的循环，它的结构为
```
while(布尔表达式){
    //循环内容
}
```
- 只要布尔表达式为 true，循环就会一直循环下去
- 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环
- 少部分情况需要循环一直执行，比如服务器的请求响应监听等
- 循环条件一直为true就会造成无限循环（也就是死循环），我们正常的业务编程中，应当尽量避免死循环产生，它会影响程序性能或造成程序卡死/崩溃
- 案例：1、输出 1~100； 2、无限循环； 3、暴力计算 1+2+3+ ... +100 = ?

package Java流程控制;

public class 循环结构_while循环1从1到100 {

    public static void main(String[] args) {

        //输出1~100

        int i = 0;

        while (i

package Java流程控制;

public class 循环结构_while循环2无限循环 {

    public static void main(String[] args) {

        // 无限循环 死循环

        while (true){    //这个循环将一直为 true 无限循环， 如等待客户端连接时、定时检查时...会用到

            System.out.println("123");    //运行代码将会一直输出 123  :(

        }

    }
}

package Java流程控制;

public class 循环结构_while循环3暴力计算 {

    public static void main(String[] args) {

        //用 while 计算 1+2+3+...+100= ?

        int i = 1;
        int sum = 0;

        while (i

do...while 循环
- 对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次
- do ... while 循环和 while 循环相似，不同的是，do ... while 循环至少会被执行一次
```
do {
    //代码语句
}while(布尔表达式);
```
- while 和 do ... while 的区别：
  - while 先判断后执行；do ... while 是先执行后判断
  - do ... while 总是保证循环体至少被执行一次，这是它们的主要差别
- 案例：1、使用 do...while 循环计算1+2+3+ ... +100 = ? ； 2、while 循环和 do...while 循环的对比

package Java流程控制;

public class 循环结构_dowhile循环1暴力计算 {

    public static void main(String[] args) {

        //用 do...while 计算 1+2+3+...+100= ?

        int i = 1;
        int sum = 0;

        do {
            sum = sum + i;
            i ++;
        }while ( i

package Java流程控制;

public class 循环结构_dowhile循环2和while对比 {

    public static void main(String[] args) {

        int a = 0;

        while (a

for 循环
- 虽然所有循环结构都可以用 while 或者 do...while 表示，但 Java 提供了另一种语句--for 循环，使一些循环结构变得更加简单
- for 循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构
- for 循环执行次数是在执行前就确定的。语法格式如下：
```
for (初始值；布尔表达式（条件判断）；迭代){
    //代码语句
}
```
- 下面代码依次是：
  - 用 while 和 for 实现相同功能的对比
  - 练习1：计算0到100 奇数和偶数的和
  - 练习2：用while或for循环输出1~1000 能被5整除的数，并且每行输出3个
  - 练习3：打印九九乘法表

package Java流程控制;

public class 循环结构_for循环1效率很高 {

    public static void main(String[] args) {

        //用 while 和 for 实现相同功能  的对比

        int a = 1;    //初始化值

        while (a

package Java流程控制;

public class 循环结构_for循环2练习1 {

    public static void main(String[] args) {

        //练习1：计算 0 到 100 奇数和偶数的和

        int oddSum = 0;    //定义 oddSum 用来保存奇数的和
        int evenSum = 0;    //定义 evenSum 用来保存偶数的和

        for (int i = 0; i

package Java流程控制;

public class 循环结构_for循环3练习2 {

    public static void main(String[] args) {

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

        for (int i = 5; i

package Java流程控制;

public class 循环结构_for循环4练习3_1打印第一列 {

    public static void main(String[] args) {

        // 打印九九乘法表_1

        /*
        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×8=16  3×9=27  4×9=36  5×9=45  6×9=54  7×9=63  8×9=72  9×9=81  */

        for (int i = 1; i

package Java流程控制;

public class 循环结构_for循环4练习3_2嵌套 {

    public static void main(String[] args) {

        // 打印九九乘法表_2

        for (int j = 1; j

package Java流程控制;

public class 循环结构_for循环4练习3_3去除重复 {

    public static void main(String[] args) {

        // 打印九九乘法表_2

        /*总结
        1.先打印第一列，比较简单
        2.把固定的 1 再用一个循环包起来
        3.用 i

在 Java 5 中引入了一种主要用于数组的增强型 for 循环
- 这里只是先了解一下，之后数组会重点使用
- 这是Java 5 引入的一种主要用于数组或集合的增强型 for 循环
- Java 增强 for 循环语法格式：
```
for (声明语句 : 表达式)
{
    //代码句子
}
```
- 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等
- 表达式：表达式是要访问的数组名，或者是返回值为数组的方法

package Java流程控制;

public class 循环结构_增强型for循环 {

    public static void main(String[] args) {

        int [] numbers = {10,20,30,40,50};    //这就是定义了一个数组

        //遍历数组中的元素 ：

        //1.用普通 for 循环

        for (int i = 0; i

5.break & continue

break 在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强制退出循环，不执行循环中的剩余语句。(break 语句也在 switch 语句中使用可以防止 case 穿透)

package Java流程控制;

public class break和continue1_break {

    public static void main(String[] args) {

        int i = 0;

        while (i

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

package Java流程控制;

public class break和continue2_continiu {

    public static void main(String[] args) {

        int i = 0;

        while (i

关于 goto 关键字（拓展只需要了解不用完全掌握）
- goto 关键字很早就在程序设计语言中出现。尽管 goto 仍是 Java 的一个保留字，但并未在语言中得到正式使用；Java 没有 goto。然而，在 break 和 continiu 这两个关键字身上，我们仍能看吃 goto 的影子---带标签的 break 和 continiu
- "标签" 是指后面跟着冒号的标识符，例如 label :
- 对 Java 来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于 break 和 continiu 关键字通常只中断当前循环，但若随同标签使用，他们就会中断在存在标签的地方

package Java流程控制;

public class 关于goto关键字_拓展 {

    //打印 101 - 150 之间的所有质数

    //质数是在大于1的自然数中，只有1和它本身 两个因数 的自然数

    public static void main(String[] args) {
        int count = 0 ;

        outre:for (int i = 101;i

6.练习

package Java流程控制;

public class 流程控制的练习 {

    public static void main(String[] args) {

        //打印三角形  5 行

        for (int i = 1; i = i ; j --){
                System.out.print(" ");
            }
            for (int j =1; j

end .

Java流程控制

标签：遍历统计区别客户端连接表示迭代字符串的比较未在图标

原文地址：https://www.cnblogs.com/muriyulin/p/14520822.html

上一篇：C#ThreadPool学习

下一篇：二、SpringBoot配置文件

文章来自：搜素材网的编程语言模块，转载请注明文章出处。
文章标题：Java流程控制
文章链接：http://soscw.com/essay/92311.html

亲，登录后才可以留言！

Java流程控制

Java流程控制

1.用户交互Scanner

Scanner对象

Scanner对象的分类

总结和梳理

Scanner进阶使用案例1

Scanner进阶使用案例2

2.顺序结构

3.选择结构

4.循环结构

5.break & continue

6.练习

评论

热门文章

推荐文章

最新文章

置顶文章