Java流程控制

最新推荐文章于 2024-10-10 23:42:47 发布
最新推荐文章于 2024-10-10 23:42:47 发布
阅读量65 收藏
点赞数
文章标签： java intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49251636/article/details/119435868
版权

用户交互Scanner

Scanner对象

  • 之前我们学的基本语法中我们并没有实现程序与人的交互，但是Java给我们提供了一个工具类，用来实现程序与人的交互。java.util.Scanner是java5的新特征，我们可以通过Scanner类来获取用户的输入。
  • 基本语法
  • Scanner s= new Scanner(System.in);
  • 通过Scanner类的next（）与nextline()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。
  • next():
  • 一定要读取到有效字符后才可以结束输入。
  • 对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
  • 只有输入有效字符之后才将其后面输入的空白作为分隔符或者结束符。
  • next()不能得到带有空格的字符
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方式接收：
hello world!
输入的内容为：hello

nextLine():

  1. 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。
  2. 可以获得空白
public class Demo02 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收：");
        //判断用户有没有输入字符串
        if(scanner.hasNextLine()){
            //使用next方式接收
            String str=scanner.nextLine();//程序会等待用户输入完毕
            System.out.println("输入的内容为："+str);
        }
        //凡是属于IO流的类如果一直不关闭会一直占用资源，要养成好习惯用完就关闭
        scanner.close();
    }
}

运行结果

使用next方式接收：
hello world!
输入的内容为：hello world!

进程已结束，退出代码为 0

Scanner进阶操作：

package Scanner;

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        Scanner s= new Scanner(System.in);
        //从键盘接收数据
        int i=0;
        float f=0.0F;
        System.out.println("请输入整数：");
        //如果。。。那么。。。
        if (s.hasNextInt()){
            i = s.nextInt();
            System.out.println("整数数据"+i);
        }else {
            System.out.println("输入的不是整数数据!:");
        }
        System.out.println("请输入小数");
        //如果。。。那么。。。
        if (s.hasNextFloat()){
            f = s.nextFloat();
            System.out.println("小数数据"+f);
        }else {
            System.out.println("输入的不是小数数据!:");
        }
        s.close();
    }
}

正确输出

请输入整数：
10
整数数据10
请输入小数
1.1
小数数据1.1

进程已结束，退出代码为 0

请输入整数：
10.1
输入的不是整数数据!:
请输入小数
小数数据10.1

进程已结束，退出代码为 0

package Scanner;

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        System.out.println("请输入数据：");
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并执行结果：
        Scanner s= new Scanner(System.in);
        //和
        double sum=0;
        //计算输入了多少个数字
        int m=0;
        //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        while (s.hasNextDouble()){
             double x = s.nextDouble();
             m++;
             sum+=x;
            System.out.println("你输入了第"+m+"个数据,然后当前结果为sum="+sum);
        }
        System.out.println(m+"个数的和为："+sum);
        System.out.println(m+"个数的平均值为："+(sum/m));
        s.close();
    }
}

运行结果

请输入数据：
10
你输入了第1个数据,然后当前结果为sum=10.0
20
你输入了第2个数据,然后当前结果为sum=30.0
30
你输入了第3个数据,然后当前结果为sum=60.0
40
你输入了第4个数据,然后当前结果为sum=100.0
x
4个数的和为：100.0
4个数的平均值为：25.0

顺序结构

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

  • 顺序结构是最简单的算法结构。

  • 在这里插入图片描述

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

package Struct;

public class Demo01 {
    public static void main(String[] args) {
    //按照从上到下的顺序依次执行
        System.out.println("hello1");
        System.out.println("hello2");
        System.out.println("hello3");
        System.out.println("hello4");
        System.out.println("hello5");
    }
}


hello1
hello2
hello3
hello4
hello5

选择结构

在这里插入图片描述

在这里插入图片描述

package Struct;

import java.util.Scanner;

public class IfDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容：");
        String s = scanner.nextLine();
        //判断字符串是否相等，字符串不能用==进行判断
        if (s.equals("hello")){
            System.out.println(s);
        }
            System.out.println("End");

        scanner.close();
    }
}

请输入内容：
hello
hello
End

进程已结束，退出代码为 0

//输入不为hello时
请输入内容：
x
End

进程已结束，退出代码为 0

在这里插入图片描述

public class IfDemo02 {
    public static void main(String[] args) {
        //考试分数大于六十分就是及格，小于六十就是不及格。
        Scanner s= new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = s.nextInt();
        if (score>60){
            System.out.println("及格");
        }
        else {
            System.out.println("不及格");
        }
        s.close();
    }
}

请输入成绩：
80
及格



请输入成绩：
33
不及格

在这里插入图片描述

public class IfDemo03 {
    public static void main(String[] args) {
        //考试分数大于六十分就是及格，小于六十就是不及格。
        Scanner s= new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = s.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("成绩不合法");
        }
        s.close();
    }
    }


请输入成绩：
4
不及格

 请输入成绩：
100
恭喜满分

请输入成绩：
102
成绩不合法

if语句最多有一个else语句，else语句在所有的else if 语句之后。
if语句可以有若干个else if语句，它们必须在else语句之前。
一旦其中一个else if语句检测为true，其他的else if以及else语句都将跳过执行。
在这里插入图片描述
在这里插入图片描述
cse穿透

public class SwitchDemo01 {
    public static void main(String[] args) {
        //case穿透
        char grade='C';
        switch (grade){
            case 'A':
                System.out.println("优秀");
                
            case 'B':
                System.out.println("良好");

            case 'C':
                System.out.println("及格");

            case 'D':
                System.out.println("再接再厉");

            case 'E':
                System.out.println("不及格");

        }
    }
}

及格
再接再厉
不及格

进程已结束，退出代码为 0

public class SwitchDemo01 {
    public static void main(String[] args) {
        //case穿透
        char grade='f';
        switch (grade){
            case 'A':
                System.out.println("优秀");

            case 'B':
                System.out.println("良好");

            case 'C':
                System.out.println("及格");

            case 'D':
                System.out.println("再接再厉");

            case 'E':
                System.out.println("不及格");
            default:
                System.out.println("未知等级");

        }
    }
}


未知等级

进程已结束，退出代码为 0

为了防止case穿透，我们使用break关键字

public class SwitchDemo01 {
    public static void main(String[] args) {
        //case穿透
        char grade='C';
        switch (grade){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("再接再厉");
                break;
            case 'E':
                System.out.println("不及格");
                break;
        }
    }
}

优秀
//很好的防止了case穿透

循环结构

在这里插入图片描述
在这里插入图片描述

public class WhileDemo01 {
    public static void main(String[] args) {
        //输出0~100
        int i=0;
        while (i<100){
            i++;
        }
        System.out.println(i);
    }
}

运行结果

100

public class WhileDemo03 {
    public static void main(String[] args) {
        //计算1+2+3+...+100
        int i=0;
        int sum=0;
        while (i<=100){
            sum+=i;
            i++;
        }
        System.out.println(sum);
    }
}


结果为
5050

在这里插入图片描述

//while与do while的区别
public class DoWhileDemo01 {
    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);
    }
}



运行结果
====================================
0

在这里插入图片描述

public class ForDemo02 {
    public static void main(String[] args) {
        //练习1：计算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

public class ForDemo03 {
    public static void main(String[] args) {
        //练习2：用while或for循环输出1——1000之间可以被五整除的数，并且每行输出3个
        for (int i = 0; i <= 1000; i++) {
            if (i % 5 == 0) {
                System.out.print(i + "\t");
            }
            if (i % (5 * 3) == 0) {//每行
                System.out.println();
            }
        }
    }
}
0	
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	1000	
进程已结束，退出代码为 0

使用while循环

public class ForDemo03 {
    public static void main(String[] args) {
        //练习2：用while或for循环输出1——1000之间可以被五整除的数，并且每行输出3个
       int i=0;
       int k=3;
       while (i<=1000){
           if (i%5==0) {
               System.out.print(i+"\t");
           }
           i++;
           if(i%15==0) {
               System.out.println();
           }

       }
    }
}

打印99乘法表

在这里插入图片描述

public class ForDemo04 {
    public static void main(String[] args) {
        //打印九九乘法表
        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	

进程已结束，退出代码为 0

在这里插入图片描述

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.println(numbers[i]);
        }
        System.out.println("===================================================");
        for (int x:numbers){
            System.out.println(x);
        }
    }
}



输出结果：
10
20
30
40
50
===================================================
10
20
30
40
50

break&continue

在这里插入图片描述

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


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

public class ContinueDemo01 {
    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+"\t");
        }
    }

1	2	3	4	5	6	7	8	9	
11	12	13	14	15	16	17	18	19	
21	22	23	24	25	26	27	28	29	
31	32	33	34	35	36	37	38	39	
41	42	43	44	45	46	47	48	49	
51	52	53	54	55	56	57	58	59	
61	62	63	64	65	66	67	68	69	
71	72	73	74	75	76	77	78	79	
81	82	83	84	85	86	87	88	89	
91	92	93	94	95	96	97	98	99

在这里插入图片描述

Java中go to语句的影子

public class LableDemo01 {
    public static void main(String[] args) {
        //打印101~105之间的质数
        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.print(i+" ");
        }
    }
}

101 103 107 109 113 127 131 137 139 149 
进程已结束，退出代码为 0

利用continue outer可以跳到指定的语句

练习

打印三角形

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.printf(" ");
            }
            for (int j=1;j<=i;j++){
                System.out.print("*");
            }
            for (int j=1;j<i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

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

特别感谢：

附上视频地址
狂神yyds
https://www.bilibili.com/video/BV12J41137hu?p=30

爱码代码的小陈
关注
java流程控制图_Java流程控制结构
weixin_31814585的博客
02-13 1712
一、概念类型Java程序通过控制语句来控制方法的执行流程，从而实现特定的功能Java中的流程控制结构主要有三种：顺序结构；选择结构；循环结构。三种结构的结合使用可以解决任何复杂问题。二、流程表示——程序流程图流程图的基本符号如下：程序流程图三、循环结构while语句while ( 布尔表达式 ) {循环体；}do-while语句do{循环体;}while ( 表达式 );例： DoWhileTes...
Java流程控制.md
05-13
Java流程控制，包含Scanner调用方法和简单，顺序结构，基础循环，还有简单debug方法（没有详细介绍debug，文档里有链接，其他大大有总结好的）
java流程控制
在路上
02-10 488
流程控制 4.1循环结构 4.1.1 分类 （一）while循环 While循环语句也称为条件判断语句，它的循环方式为利用一个条件来控制是否继续反复执行这个语句。语法格式如下： While（条件表达式）{ 执行语句 } 当条件表达式的返回值为真时，则执行“{}”中的语句，当执行完“{}”中的语句后，重新判断条件表达式的返回值，直到返回的结果为假时，退出循环。 （二）do..whi
Java流程控制详解
波哩个波的博客
09-08 6009
一、流程控制概述 在Java程序中，JVM默认总是顺序执行以分号;结束的语句。但是，在实际的代码中，程序经常需要做条件判断、循环，因此，需要有多种流程控制语句，来实现程序的跳转和循环等功能。 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即： 顺序结构 分支结构 ...
Java流程控制及数组实验
Szero
05-11 1819
Java流程控制及数组实验
Java流程控制语句
qq_38227085的博客
05-30 1263
Java 中的流程控制语句用于控制程序的执行流程，根据条件或循环来决定代码的执行方式。Java 提供了几种常用的流程控制语句，包括条件语句和循环语句。
Java流程控制（一）
chuxiqianye2020的博客
02-06 1940
Java流程控制（一）1.用户交互Scanner2.顺序结构3.选择结构if单选结构if双选择结构if多选择结构嵌套的if结构switch多选择结构 1.用户交互Scanner 之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特性，我们可以通过Scanner类来获取用户的输入 基本语法 Scanner s = new Scanner(System.in); 通过Scanner类的ne
java基础---Java程序流程控制
kwj258036的博客
03-10 1149
简单介绍了Java程序流程控制和产生随机数的方法
Java 流程控制语句——分支结构
业余幻想家的博客
08-17 1539
Java 流程控制语句——分支结构
Java流程控制02——顺序结构
流苏的博客
12-10 472
第二天Java学习笔记，流程控制02——顺序结构，笔记根据学习进度更新，加油，相信自己！坚持就是胜利！
java流程控制——嵌套循环
MoerPerfect的博客
04-29 3619
java的嵌套循环。九九乘法表、100以内的质数的输出、一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如：6=1+2+3.编程：找出1000以内的所有完数。（因子：除去这个数本身的其他约数）、
Java流程控制顺序结构原理解析
08-25
Java流程控制顺序结构原理解析 Java流程控制 顺序结构是 Java 编程语言中最基本的流程控制结构之一。它按照代码的编写顺序，从上往下依次执行语句，这种结构非常简单易懂，但却是 Java 编程语言中最基本的流程控制...
第三章java流程控制语句.ppt
11-12
Java 流程控制语句是 Java 语言中控制程序执行顺序的语句，是程序中非常关键和基本的部分。该类型的语句可以把单个的语句组合成有意义的、能够完成一定功能的小逻辑块。 一、Java 语句概述 Java 语言是一种面向...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1256
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 949
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
JDK1.0主要特性
FoolRabbit的专栏
10-06 368
JDK1.0主要特性。
初学java练习题【1】
最新发布
lxt135744的博客
10-10 205
【代码】初学java练习题【1】
Netty 相比原生IO模型的优势
lssffy的博客
10-09 437
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Java流程控制与Scanner输入详解
"Java流程控制是编程中的基础概念，主要涉及如何控制程序的执行流程。本文件主要讲解了在Java中如何使用Scanner类获取用户输入，以及程序的基本流程控制结构，包括顺序结构、if条件判断等。 在Java中，`Scanner`类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值