ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

JavaSE-流程控制

2022-06-28 20:33:52  阅读：153  来源： 互联网

标签：控制 scanner Scanner 流程 System println JavaSE public out


JavaSE-流程控制

Scanner对象

实现程序与人进行交互java.util.Scanner

基本语法Scanner s = new Scanner(System.in)

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

/* next hasNext
1.一定要读取到有效字符后才可以结束输入。
2.对输入有效字符之前遇到的空白，next方法会自动将其去掉。
3.只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
4.next不能得到带有空格的字符串
*/
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();
    }
}

/*nextLine hasNextLine	
1.以Enter为结束符，nextLine方法返回的是输入回车之前的所有字符
2.可以获得空白
*/
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()){
            //接受输入
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        scanner.close();
    }
}

一般写法

import java.util.Scanner;

public class Demo03 {
    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();
    }
}

进阶用法

import java.util.Scanner;

public class Demo04 {
    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("输入的不是整数数据！");
        }
        //  如果输入的与nextInt不对应，则不会接收，并且寻找下一个接收
        System.out.println("请输入小数：");
        //判断是否为小数
        if (scanner.hasNextFloat()){
            f = scanner.nextFloat();  //接收输入整数
            System.out.println(f);
        }else{
            System.out.println("输入的不是小数数据！");
        }
        scanner.close();
    }
}

简单算法

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        //输入多个数字，并且求其综合与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并且输出执行结果
        Scanner scanner = new Scanner(System.in);

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

        scanner.close();
    }
}

顺序结构

语句与语句、框与框之间，都是从上到小顺序进行。

选择结构

if 单选结构

语法

/*
if (布尔表达式){
	//True执行的语句
}
*/
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();
        // equals：判断字符串是否相等
        if (s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("end");
        scanner.close();
    }
}

if 双选结构

语法

/*
if(布尔表达式){
    //true 执行
}else{
    //false 执行
}
*/
import java.util.Scanner;

public class ifDemo02 {
    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();
    }
}

if 多选择结构

/*
if(布尔表达式1){
    //表达式1 true 执行
}else if (布尔表达式2){
    //表达式2 true 执行
}else if (布尔表达式3){
    //表达式3 true 执行
}else {
    //以上表达式都为false，执行
}
*/
import java.util.Scanner;

public class ifDemo03 {
    public static void main(String[] args) {
        //考试分数大于60就是及格，小于60分就不及格
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
		
        // 判断是否输入的为整数
        while (scanner.hasNextInt()) {
            //获得Int
            int score = scanner.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 >= 60) {
                System.out.println("C");
            } else {
                System.out.println("不及格");
            }
        }
        scanner.close();
    }
}

所有的if else 都可以合法的相互嵌套

switch 多选择结构

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

/*
// switch中的变量类型可以是 byte short int char String
switch (expression){
	case value:
		//语句
		break;	//可选，如不写，则会顺序执行下一个case
	case value:
		//语句
		break;	//可选，如不写，则会顺序执行下一个case
	case value:
		//语句
		break;	//可选，如不写，则会顺序执行下一个case
	//可以有任意数量的case
	default:	//可选	如果没有任何的case与之匹配，则输出default
		//语句
}
*/
import java.util.Scanner;

public class switchDemo {
    public static void main(String[] args) {
        //case 穿透   //switch 匹配一个具体的值
        Scanner scanner = new Scanner(System.in);
        String grade = scanner.nextLine();
        //每一个对象，都有自己的hashCode   String就是利用这个进行判断
        switch (grade){
            case "WTA":
                System.out.println("优秀");
                break;  //防止case穿透
            case "B1":
                System.out.println("良好");
                break;
            case "C1":
                System.out.println("及格");
                break;
            case "D1":
                System.out.println("再接再厉");
                break;
            case "E1":
                System.out.println("挂科");
                break;
            default:
                System.out.println("非法输入");
        }
    }
}

/*
反编译
*/
import java.util.Scanner;

public class switchDemo {
    public switchDemo() {
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String grade = scanner.nextLine();
        byte var4 = -1;
        switch(grade.hashCode()) {
        case 2095:
            if (grade.equals("B1")) {
                var4 = 1;
            }
            break;
        case 2126:
            if (grade.equals("C1")) {
                var4 = 2;
            }
            break;
        case 2157:
            if (grade.equals("D1")) {
                var4 = 3;
            }
            break;
        case 2188:
            if (grade.equals("E1")) {
                var4 = 4;
            }
            break;
        case 86276:
            if (grade.equals("WTA")) {
                var4 = 0;
            }
        }

        switch(var4) {
        case 0:
            System.out.println("优秀");
            break;
        case 1:
            System.out.println("良好");
            break;
        case 2:
            System.out.println("及格");
            break;
        case 3:
            System.out.println("再接再厉");
            break;
        case 4:
            System.out.println("挂科");
            break;
        default:
            System.out.println("非法输入");
        }

    }
}

循环结构

while 循环

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

1. 只要布尔表达式为true，则会一直循环执行下去
2. 我们大多数情况是需要一个让表达式失效的方式，使循环结束
3. 避免死循环
思考： 计算 1+2+3+4+5+...+100=？
*/
public class whileDome01 {
    public static void main(String[] args) {
        // 输出1——100
        int i = 0;
        int sum = 0;
        while (i<100){
            i++;
            sum = sum + i;
            System.out.println(i);

        }
        System.out.println(sum);
        // 永远不停止    死循环（需要避免）
        while (true){
            // 等待客户端连接
            // 定时检查
        }
    }
}

do...while 循环

/*
对于do..while循环，该循环至少保证执行一次，然后再进行判断
do{
	//代码语句
}while(布尔表达式)
*/
public class doWhileDemo {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        do{
            sum = sum +i;
            i++;
        }while (i<=100);
        System.out.println(sum);
    }
}

两个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
*/

for 循环

for循环时一种通用的，重要的循环，支持迭代的通用结构，是最简单的循环语句

/*
for(初始化;布尔表达式;更新){
	//代码语句
}
*/
public class forDemo01 {
    public static void main(String[] args) {
        for(int i=1;i<=100;i++) {
            System.out.println(i);
        }
        //死循环的写法
        for(;;){

        }
    }
}

练习

  1. 计算0到100之间的奇数和偶数的和
  2. 用while或for循环输出1-1000之间被5整除的数，并且每行输出3个
  3. 打印九九乘法表
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);
    }
}

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");
            }
            if (i%(5*3) == 0){
                System.out.print("\n");
            }
        }
        // println 输出完会换行
        // print 输出完不会换行
    }
}

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(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }
    }
}

增强For 循环

/*
for(声明 : 表达式){
	//代码语句
}
*/
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循环
        for (int x:numbers){
            System.out.println(x);
        }
    }
}

break、continue、goto

break：可以再任何时候控制循环流程，强制退出循环。但是不终止程序

continue：用于终止某一次循环，只跳出一次循环（略过剩余语句，进行下一次循环）（一般用来跳过某些语句）。不终止程序

goto：跳转到指定label

// goto
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
*/

练习

public class TestDemo {
    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();
        }
    }
}
/*
     *
    ***
   *****
  *******
 *********
 
*/

标签：控制,scanner,Scanner,流程,System,println,JavaSE,public,out
来源： https://www.cnblogs.com/WTAGO/p/16419647.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有