Java流程控制

scanner对象

之前学的基本语法没有实现程序与人的交互，现在可以使用scanner类来获取用户的输入（之前都是我们在输出程序，现在可以搞个程序然后输入数据得到结果）

基本语法

Scanner s=new Scanner(System.in);

通过scanner类的next（）和nextLine（）获取输入字符串，在读取前一般需要使用hasNext（）和hasNextLine（）判断是否还有输入的数据

以下使用next方法

package com.wang.base.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语句）
        if(scanner.hasNext()){
            String str=scanner.next();//程序会一直等待用户输入
            System.out.println("输出的内容为："+str);
        }
        //用完scanner后，要关掉，节约资源
        scanner.close();
    }
}

以下使用nextline方法

package com.wang.base.scanner;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接受键盘数据
        Scanner scanner =new Scanner(System.in);
        System.out.println("使用nextLine方法接收：");
        //判断用户有没有输入字符串（可以不判断，删去if语句）
        if(scanner.hasNextLine()){
            String str=scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        //用完scanner后，要关掉，节约资源
        scanner.close();
    }
}

发现，如果输入hello world，next方法只输出了hello，而nextline输出了hello world

这就涉及到他们的不同：

next：

1. 一定要读到有效字符后才可以结束输入
2. 不能得到带有空格的字符串
3. 以空格为结束符

nextline：

1. 以enter为结束符
2. 可以获得空白

进阶使用

具体到数据类型

package com.wang.base.scanner;

import java.util.Scanner;

public class Demo03 {
    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("输入的不是整数数据！");
        }

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

        if (scanner.hasNextFloat()){
            f= scanner.nextFloat();
            System.out.println("小数数据："+f);
        }else {
            System.out.println("输入的不是小数数据！");
        }
        scanner.close();
    }
}

输入多个数字，并求总和与平均数

package com.wang.base.scanner;

import java.util.Scanner;

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

顺序结构

从上而下运行

他是任何一个算法都离不开的基本算法结构

选择结构

1. if单选择
2. if双选择
3. if多选择
4. 嵌套的if结构
5. switch多选择

if单选择

package com.wang.base.struct;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);//打开输入的门口
        System.out.println("请输入内容：");
        String s=scanner.nextLine();
        if (s.equals("Hello"))//equals是用来判断字符串是否相等
        {
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();
    }
}

if双选择

package com.wang.base.struct;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入成绩：");
        int s=scanner.nextInt();
        if (s>=60){
            System.out.println("及格");
        }else System.out.println("不及格");
        scanner.close();
    }
}

if多选择

package com.wang.base.struct;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入成绩：");
        int s=scanner.nextInt();
        if (s==100){
            System.out.println("恭喜满分");
        }else if(s<100&&s>=90) {
            System.out.println("A");
        }else if(s<90&&s>=80) {
            System.out.println("B");
        }else if(s<80&&s>=70) {
            System.out.println("C");
        }else if(s<70&&s>=60) {
            System.out.println("D");
        }else if (s<60&&s>=0){
            System.out.println("不及格");
        }else {
            System.out.println("成绩不合法");
        }
        scanner.close();
    }
}

注意事项：

1. if至多有一个else，else必须在所有elseif的后面

2. if可以有很多个elseif语句，他们必须在else之前

3. 一旦有一个elseif检测为true，其他elseif和else跳过执行

嵌套if结构

switch多选择

package com.wang.base.struct;

public class Demo04 {
    public static void main(String[] args) {

        char grade='C';//自行输入一个数据
        //switch匹配具体一个数值
        switch(grade){
            case 'A':
                System.out.println("优秀");
                break;//有break可以解决case穿透问题
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("不及格");
                break;
            default://解决输入错误值时的情况（以后要考虑到）
                System.out.println("未知");
        }
    }
}

还可以支持输入string，因为字符的本质是数字，idea反编译了，所以可以输入字符串。

循环结构

1. while循环
2. do。。。while循环
3. for循环

while循环

记得需要一个失效表达式结束循环

package com.wang.base.struct;

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

package com.wang.base.struct;

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

do...while循环

对于while而言，会先判断是否符合条件，如果不符合就不执行；但在一些情况下，需要就算不符合条件也至少执行一次，所以dowhile诞生了，它先执行再判断

package com.wang.base.struct;

public class Demo06 {
    public static void main(String[] args) {
        //计算1~100之和
        int i=0;
        int sum=0;
        do {
            sum=sum+i;
            i++;
        }while (i<=100);
        System.out.println(sum);
    }
}

for循环

是支持迭代的一种通用结构，是最有效，最灵活的循环结构

package com.wang.base.struct;

public class Demo07 {
    public static void main(String[] args) {
        //初始化值//条件判断//迭代
        for (int a=1;a<=100;a++){
            System.out.println(a);
        }
        
    }
}

100.for回车后自动生成for循环(100可以换成其他的)

for (int i = 0; i < 100; i++) {}    

增强for循环

package com.wang.base.struct;

public class Demo11 {
    public static void main(String[] args) {
        int[]num={10,20,30,40,50};//定义了一个数组
        for (int i = 0; i < 5; i++) {
            System.out.println(num[i]);//取出数组中的每一个数字，与下面的输出结果一致
        }
        for (int x:num){
            System.out.println(x);//输出了遍历数组的元素
        }//所以这个其实是上面的简化，可以偷懒。用来输出数组中的元素的
    }
}

练习1：计算0~100之间奇数和偶数的和

package com.wang.base.struct;

public class Demo08 {
    public static void main(String[] args) {
        int oddSum=0;//奇数和
        int evenSun=0;//偶数和
        for (int i = 0; i <= 100; i++) {
            if (i%2!=0){
                oddSum+=i;
            }else{
                evenSun+=i;
            }
        }
        System.out.println("奇数和："+oddSum+"偶数和："+evenSun);
    }
}

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

package com.wang.base.struct;

public class Demo09 {
    public static void main(String[] args) {
        //练习2：用while或for循环输出1-1000之间能被5整除的数，并每行输出三个
        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");//实现每行输出三个
                //或者是System.out.println();
                //println输出完会换行
                //print输出完不换行
            }
        }
    }
}

练习3：打印九九乘法表

package com.wang.base.struct;
/*
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
 */
//想要达到这种效果
/*1.先打印第一列
2.把固定的1用循环包起来，引入变量j
3.去掉重复项，即让i<=j
4.调整样式，加上\t,System.out.println();
并把System.out.println(j + "*" + i + "=" + (j * i)+"\t");中println改成print
因为println是自动换行，但是我们需要他们在一行
 */
public class Demo10 {
    public static void main(String[] args) {
        for (int j = 0; j <= 9; j++) {
            for (int i = 1; i <= j; i++) {//i=j,可以去掉重复项
                System.out.print(j + "*" + i + "=" + (j * i)+"\t");//\t相当于空格
            }//用print，才能达到效果
            System.out.println();
        }
    }
}

break,cintinue,goto

break和continue的区别

package com.wang.base.struct;

public class demo12 {
    public static void main(String[] args) {
        int i = 0;
        while (i < 100) {
            i++;
            System.out.println(i);
            if (i%10==0) {
                break;//只是跳出循环，但是外面还能进行
            }
        }
        //输出了12345678910
        System.out.println("123");//能输出
        int a = 0;
        while (a < 100) {
            a++;
            if (a%10==0){
                System.out.println();
                continue;
            }
            System.out.print(a);
        }
        /*输出了123456789
        111213141516171819
        212223242526272829
        313233343536373839
        414243444546474849
        515253545556575859
        616263646566676869
        717273747576777879
        818283848586878889
        919293949596979899
        */
    }
}

所以：

break：很厉害，碰到他就直接干不了了

continue：碰到他只是跳过一次循环，其他循环仍然进行

goto关键字：在Java里没有goto，只作为了解

练习

打印三角形

package com.wang.base.struct;
/*
     *     1
    ***    3
   *****   5
  *******  7
 ********* 9

 */
public class Demo13 {
    public static void main(String[] args) {
        //打印五行的三角形
        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();
        }
    }
}

可以用debug（虫子）来看具体步骤，更加清晰