Java流程控制

Scanner

next()

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

package com.zedhz.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()){
           String str = scanner.next();
            System.out.println("输出的内容为:"+str);
        }

        //凡是输入IO流的类如果不关闭会一直占用资源
        scanner.close();

    }
}

nextLine()

• 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
• 可以获得空白

package com.zedhz.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 (scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }

        scanner.close();
    }
}

例：

package com.zedhz.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; //m++
            sum = sum +x;
        }

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



        scanner.close();

    }
}

选择结构

If单选择结构

package com.zedhz.struct;

import java.util.Scanner;

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

        System.out.println("请输入内容：");
        String str = scanner.nextLine();

        //equals:判断字符串是否相等
        if (str.equals("Hello")){
            System.out.println(str);
        }

        System.out.println("End");

        scanner.close();
    }
}

If双选择结构

package com.zedhz.struct;

import java.util.Scanner;

public class IfDemo02 {
    public static void main(String[] args) {
        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多选择结构

package com.zedhz.struct;

import java.util.Scanner;

public class IfDemo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        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>=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("成绩不合法");
        }
    }
}

switch case

• switch case 语句判断一个变量与一系列值中某个值是否相等，每个值成为一个分支
• Jdk7以后支持字符串类型

package com.zedhz.struct;

public class SwitchDemo04 {
    public static void main(String[] args) {
        char score = 'C';

        //case穿透：如果不写break，将一直往下输出
        switch (score){
            case 'A':
                System.out.println("A");
                break;
            case 'B':
                System.out.println("B");
                break;
            case 'C':
                System.out.println("C");
                break;
        }
    }
}

循环结构

while循环

• 只要布尔表达式为true，循环会一直下去
• 需要一个让表达式失效的方法来结束循环
• 少部分情况使用死循环，比如监听服务器响应
• 循环一直为true则会造成死循环

package com.zedhz.struct;

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

do while

• do…while循环在不满足条件的情况下至少会执行一次

While和do…while的区别

• while先判断后执行，do…while是先执行后判断
• do…while总是会保证循环体至少会被执行一次

package com.zedhz.struct;

public class DowhileDemo09 {
    public static void main(String[] args) {
        int i =0;
        while (i<0){
            System.out.println(i);
            i++;
        }
        System.out.println("=============");
        do {
            System.out.println(i);
            i++;
        }while (i<0);
    }
}

For循环

• For循环是支持迭代的一种通用结果，是最有效最灵活的循环结构
• For循环的执行次数是在执行前就确定的

package com.zedhz.struct;

public class ForDemo12 {
    public static void main(String[] args) {
        /**
         * For循环实现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.println();
            }
        }

        /**
         * While循环实现1000以内能被5整除的数，每行显示3个
         */
        int i =0;
        while (i<=1000){
            if (i%5==0){
                System.out.print(i+"\t");
            }
            if (i%(5*3)==0){
                System.out.println();
            }
            i++;
        }
    }
}

println 和print的区别

• println输出完会换行
• print输出完不会换行

package com.zedhz.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
 */
public class ForDemo13 {
    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();
        }
    }
}

break continue goto

break

• break会强制跳出循环

continue

• 在循环体中用于终止某次循环过程