JAVA- 流程控制，用户交互Scanner,结构，打印三角形-优快云博客

本文链接：https://blog.youkuaiyun.com/xiaoke00/article/details/114183079

JAVA学习之流程控制

用户交互Scanner
- 结构
- - 打印三角形

用户交互Scanner

通过Scanner类来获取用户的输入，该工具类在包 java.util.Scanner 中

// 基本语法
Scanner scanner = new Scanner(System.in);

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

next() 方法：

不能得到带有空格的字符串
读取到有效字符串后才可以结束输入

package com.xiaoke.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();
                    }
    }
}

// 结果
使用next方法接收：
kun
输出的内容为：kun

Process finished with exit code 0

nextLine() 方法：

以Enter为结束符
可以获得空白

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

        System.out.println("使用nextLine方法接收：");
        String str = scanner.nextLine();
        System.out.println("输出的内容为："+str);
        scanner.close();
        }
}

// 结果
使用nextLine方法接收：
xiao ke
输出的内容为：xiao ke

Process finished with exit code 0

如果输入是整数或小数呢？

    public static void main(String[] args) {
        int i = 0;
        float f = 0.0f;
        Scanner scanner = new Scanner(System.in);
        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();
    }

// 结果
请输入数据：
16
整数数据：16
请输入数据：
21.5
小数数据：21.5

Process finished with exit code 0

练习：输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果！！！

       Scanner scanner = new Scanner(System.in);
        System.out.println("要统计的数字是：");
        double sum = 0;
        int m = 0;
        while(scanner.hasNextDouble()){
          double x =  scanner.nextDouble();
          m = m + 1;
          sum = sum + x;
        }
        System.out.println(m + "个数字的和是："+sum);
        System.out.println(m + "个数字的平均数是："+sum/m);

        scanner.close();

// 结果
要统计的数字是：
21.5
16
kun
2个数字的和是：37.5
2个数字的平均数是：18.75

Process finished with exit code 0

查看类中有什么方法！！！
ctrl+鼠标左键在类上，就会跳转

在这里插入图片描述

结构

顺序结构：它是任何一个算法都离不开的一种基本算法结构
选择结构：if 和 switch
循环结构

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容:");
        String s = scanner.nextLine();

        // equals() 方法，判断字符串是否相等
        if(s.equals("kun")){
            System.out.println("这是："+s);
        }
        System.out.println("emmmm");
        scanner.close();

请输入内容:
kun
这是：kun
emmmm

Process finished with exit code 0

练习：嗯，今年（2021）考研，上岸了就回到这里读书，失败的话就去实习！！！

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 分数大于385,则上岸，反之
        System.out.println("请输入成绩！！！：");
        int score = scanner.nextInt();
        if(score>385){
            System.out.println("按下F,提派蒙一只");
        }else{
           System.out.println("毕设答辩，调剂，科二，模电考试，实习！");
        }


        scanner.close();
    }
}

在这里插入图片描述

if多选择结构

/*
if(布尔表达式1){

}else if(布尔表达式2){

}else{

}
 */

在这里插入图片描述

嵌套的if结构

/*
if(布尔表达式1){

    if(布尔表达式2){
    }
}
 */

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

switch case 语句实现多选择结构，判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

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

byte、short、int、char
jdk7 以后，switch 支持字符串类型了
同时 case 标签必须为字符串常量或字面量？

        //case穿透,每写一个case都要加break;

       
        String name = "kun";
        switch(name){
            case "xiao ke":
                System.out.println("是：xiao ke");
                break;
            case "kun":
                System.out.println("是:kun");
                break;
            default:
                System.out.println("emmmm");
        }

//结果
是:kun

Process finished with exit code 0

反编译 java—class(字节码文件)-------反编译为（IDEA）
复制那个路径
粘贴到下图位置

在这里插入图片描述

在idea里打开.class文件（反编译之后形成的源码）

while循环

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

大多数情况下会让循环停止下来的，需要一个让表达式失效的方式来结束循环
少部分情况会让循环一直执行，比如服务器的请求响应监听等
循环条件一直为 true 就会造成无限循环（死循环），我们正常的义务编程中要尽量避免死循环，它会影响程序性能或造成程序崩溃

   public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        //输出1~100
         while (i<100){
            i++;
            //print 输出完不会换行
            System.out.print(i+"\t");
            if(i%15==0){
                System.out.println();
            }
        }
        /*
        //死循环，会影响性能，让程序崩溃
        while(true){
        //等待客户端连接
        //定时检查
        }
         */
        //练习：计算1+2+3+...+100 嗯 高斯
        i = 0;
        while (i<=100){
            sum = sum + i;
            i++;
        }
        System.out.println("\n"+sum);
    }

// 结果
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	45	
46	47	48	49	50	51	52	53	54	55	56	57	58	59	60	
61	62	63	64	65	66	67	68	69	70	71	72	73	74	75	
76	77	78	79	80	81	82	83	84	85	86	87	88	89	90	
91	92	93	94	95	96	97	98	99	100
5050

Process finished with exit code 0

do…while 循环

该循环至少会执行一次

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

while 和 do…while 的区别

while 先判断后执行，do…while 是先执行后判断！
do…whille 总是保证循环体会被至少执行一次！嗯，主要差别

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

// 结果
5050

for 循环

使一些循环结构变得简单
for 循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构
for 循环执行的次数是在执行前就确定的

//结构
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;
            }else{
                evenSum += i;
            }
        }
        System.out.println("奇数和为："+oddSum);
        System.out.println("偶数和是："+evenSum);
    }

// 结果
奇数和为：2500
偶数和是：2450

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

     //计算 0 到 100 之间的奇数和偶数的和
        //奇数和
        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("奇数和为："+oddSum);
        System.out.println("偶数和是："+evenSum);
        // 用 while 或 for 循环输出 1-1000 之间能被 5 整除的数，并且每行输出 3 个
        for (int i = 0; i < 1000; i++) {
            if(i == 0){
                System.out.println();
            }else if (i % 5 == 0){
                System.out.print(i+"\t");
            }
            if(i % (100) == 0){
                System.out.print("\n");
            }

        }
        System.out.print("\n"+"======================="+"\n");
        int i = 0;
        while(i < 1000){
            i++;
            if(i % 5 == 0){
                System.out.print(i+"\t");

                if(i % 150 == 0){
                    System.out.println();
                }
            }
        }

//结果
	
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 
=======================
 
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 
Process finished with exit code 0

练习：打印九九乘法表

        //打印九九乘法表
        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print(j+"*"+i+"="+(j*i)+"\t");
            }
            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	

Process finished with exit code 0

for 循环的执行过程：

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

//死循环
for(;;){

}

增强 for 循环

Java5 引入的，嗯，主要用于数组或集合的增强型 for 循环

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

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

        //数据类型 变量名
        int[] ages = {5,16,22};  //定义了一个数组
        //遍历数组的元素
        for(int x:ages){
            System.out.println(x);
        }
        System.out.println("=============");
        //相当于下面这个 for 循环
        for (int i = 0; i < 3; i++) {
            System.out.println(ages[i]);
        }

// 结果
5
16
22
=============
5
16
22

break 和 continue

break 在任何循环语句的主体部分，均可用 break 控制循环的流程，break 用于强行退出循环，不执行循环中剩余的语句。（break 语句也在 switch 语句中使用）
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定
关于 goto 关键字

嗯 Java 没有 goto ，不过有带标签的 break 和 continue。（欸，goto的影子叭）
”标签“是指后面跟一个冒号的标识符，像：label:
对 Java 来说唯一用到标签的地方是在循环语句之前。因为：希望在其中嵌套另一个循环，由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，它们两个就会中断到存在标签的地方

        //定义一个标签，通过continue返回到标签的位置
        //了解
        //打印 101-150 之间所有的质数
        int count = 0;
       outer: for (int i = 101; i < 150; i++) {
            for (int j =2; j < i/2; j++) {
                if(i % j == 0){
                    continue  outer;
                }
            }
           System.out.println(i+" ");
        }

// 结果
101 
103 
107 
109 
113 
127 
131 
137 
139 
149 

Process finished with exit code 0

打印三角形

        // 打印三角形 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();
        }

// 结果
     *
    ***
   *****
  *******
 *********

Process finished with exit code 0

IDEA中debug使用
 参考视频