JAVA流程控制

1-Scanner对象

基本语法

//创建一个扫描器，用于扫描键盘输入的数据   
Scanner scanner = new Scanner(Systeam.in)
//在读取前我们一般需要 使用 hasNext() 与 hasNextLine() 判断是否还有输入的数据。
    if(scanner.hasNextLine){
     //使用next或nextLine方式接收，并封装在字符串里
    String str = scanner.nextLine();
    System.out.println("输出的语句为"+str);
    }
/*
凡是属于IO流的类如果不关闭会一直占用资源.要养成好习惯用完就关掉.就好像你接水完了要关
水龙头一样.很多下载软件或者视频软件如果你不彻底关,都会自己上传下载从而占用资源,你就会觉得
卡,这一个道理.
*/
scanner.close;

接收数据方式：next和nextLine的二者区别

next():

1、一定要读取到有效字符后才可以结束输入。

2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。

3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

4、next() 不能得到带有空格的字符串。

nextLine()：

1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。

2、可以获得空白。

  //打印输入数据的个数以及平均数
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double sum = 0;
        int number = 0;
        //判断是否有下一个数字输入
        while (scanner.hasNextDouble()){
            //使用next接收输入的数据
            double d = scanner.nextDouble();
            //统计输入数字的个数
            number++;
            //统计输入数据的总和
            sum = sum+d;
        }
        System.out.println("个数为"+number+"平均数为"+(sum/number));
        scanner.close();
    }

 

2-顺序结构

JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。 顺序结构是最简单的算法结构。

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

顺序结构在程序流程图中的体现就是用流程线将程序框自上而地连接起来，按顺序执行算法步骤。

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");
}
//按照自上而下的顺序执行！依次输出。

3-选择结构

if选择结构

• if单选择结构

//语法
if(布尔表达式){
//如果布尔表达式为true将执行的语句
}

//演示
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    //接收用户输入
    System.out.print("请输入内容：");
    String s = scanner.nextLine();
    //equals 判断两个字符串是否相等
    if (s.equals("Hello")){
        System.out.println("输入的是："+s);
        }
    System.out.println("End");
    scanner.close();
}

• if双选择结构

//语法
if(布尔表达式){
//如果布尔表达式为true将执行的语句
    }else{
        //如果布尔表达式为false将执行的语句
    }

//练习：公司正在外包开发一个项目：如果成功就支付给技术人员一百万，如果失败就自己开发。
public static void main(String[] args) {
        //创建一个扫描输入的Scanner对象
        Scanner scanner = new Scanner(System.in);
​
        System.out.println("请输入成功还是失败");
        //使用nextLine接收
        String s = scanner.nextLine();
        if(s.equals("成功")){
            System.out.println("支付一百万");
​
            }else if (s.equals("失败")){
​
                System.out.println("自己开发");
            }else {
​
                System.out.println("非法字符");
            }
        }
    scanner.close();
}

//练习：成绩：大于等于60分为及格，小于60分为不及格
public static void main(String[] args) {
        //创建一个扫描输入的Scanner对象
        Scanner scanner = new Scanner(System.in);
​
        System.out.println("请输入成绩");
        //使用next接收
        int score = scanner.nextInt();
        if(score>=60&&score<100){
            System.out.println("及格");
            }else {
​
                System.out.println("不及格");
            }
        }
    scanner.close();
}

if多选择结构

//语法
if(布尔表达式){
//如果布尔表达式为true将执行的语句
    }else if{
        //如果布尔表达式为false将执行的语句
	}
	else if{
        //如果布尔表达式为false将执行的语句
	}
	else{
        //如果布尔表达式为false将执行的语句
	}

//练习：根据分数高低将成绩分为4个等级S,A,B,C,D
   public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩");
        int score = scanner.nextInt();
        if(score>=90&&score<=100){
            System.out.println("您的成绩是"+score+"等级为A");
        } else if (score>=60&&score<=100) {
            System.out.println("您的成绩是"+score+"等级B");

        }else if (score<60&&score>=20) {
            System.out.println("您的成绩是"+score+"等级为C");
        }else if (score<20&&score>=0) {
            System.out.println("您的成绩是"+score+"等级为D");
        }
      else {
            System.out.println("输入错误，非法字符");
        }
        scanner.close();
    }

if嵌套结构

//语法
if(布尔表达式 1){
////如果布尔表达式 1的值为true执行代码
    if(布尔表达式 2){
    ////如果布尔表达式 2的值为true执行代码
    }
}

//练习：成绩
public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩");
        int score = scanner.nextInt();
        if(score>=60&&score<=100){
            if(score>=90&&score<=100){
                System.out.println("您的成绩是"+score+"你很优秀");
            }else {
                System.out.println("您的成绩是" + score + "你很一般");
            }
        }
        else if(score>0&&score<60){
            System.out.println("不及格");
        }
        scanner.close();
    }

有时候我们在解决某些问题的时候，需要缩小查找范围，需要有层级条件判断，提高效率。

比如：我们 需要寻找一个数，在1-100之间，我们不知道这个数是多少的情况下，我们最笨的方式就是一个个去对比，看他到底是多少，这会花掉你大量的时间，如果可以利用if嵌套比较，我们可以节省大量的成本。

switch多选择结构

//语法
switch(expression){
        case value:  //语句（表达式）
        break;  //可选
        case value:
        break;  
        case value:
        break;  
        defaule://可选
        //语句
}

//练习：成绩选择
public static void main(String[] args) {
        char score = 'B';
        switch (score){
            case 'A':
                System.out.println("成绩优秀");
                break;
            case 'B':
                System.out.println("成绩一般");
                break;
            case 'C':
                System.out.println("成绩及格");
                break;
            case 'D':
                System.out.println("成绩差");
                break;
            default:
                System.out.println("非法字符");
        }
    }

//练习：字符串选择
public static void main(String[] args) {
        String name = "张三";
        switch (score){
            case "张三":  //JDK7的新特性，表达式结果可以是字符串！！！
                System.out.println("人员为张三");
                break;
                 case "李四":
                System.out.println("人员为李四");
                break;
                 case "王二":
                System.out.println("人员为王二");
                break;            
            default:
                System.out.println("非法字符");
        }
    }

注意事项

• 【case穿透】

如果 case 语句块中没有 break 语句时，匹配成功后，从当前 case 开始，后续所有 case 的值都会输 出。如果后续的 case 语句块有 break 语句则会跳出判断。

4-循环结构

• while 循环

• do…while

• 循环 for 循环

while循环

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

//练习：0-100的和
public static void main(String[] args) {
        int i = 0;
    	int sum = 0;
        while(i<=100){
            i++;
            sum=sum+1;
             /*
              0=0+0
              0=0+1
              1=1+2
              3=1+2+3
              100=1+2+3+···+100；
              */
        }
     System.out.println(sum);
    }

do...while循环

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

//语法
do{
    //循环内容
}
while(布尔表达式)

//练习
public static void main(String[] args) {
    int i = 0;
    int sum = 0;
    do {
        sum = sum+i;
        i++;
    }while (i <= 100);
    System.out.println("Sum= " + sum);
}

While和do-While的区别：

while先判断后执行。dowhile是先执行后判断！

Do...while总是保证循环体会被至少执行一次！这是他们的主要差别。

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);
}

for循环

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

关于 for 循环有以下几点说明：

最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语 句。

然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循 环体后面的语句。

执行一次循环后，更新循环控制变量(迭代因子控制循环变量的增减)。 再次检测布尔表达式。循环执行上面的过程。

//语法
for(初始化；布尔表达式；更新){
    //循环语句
}

//对比：：while和for输出
public static void main(String[] args) {
    int a = 1; //初始化
    while(a<=100){ //条件判断
        System.out.println(a); //循环体
        a+=2; //迭代
    }
    System.out.println("while循环结束！");
    for(int i = 1;i<=100;i++){ //初始化//条件判断 //迭代
        System.out.println(i); //循环体
    }
    System.out.println("while循环结束！");
}

//练习1：计算0到100之间的奇数和偶数的和
public static void main(String[] args) {
    int oddSum = 0; //用来保存奇数的和
    int evenSum = 0; //用来存放偶数的和
    for(int i=0;i<=100;i++){
        if(i%2!=0){
        oddSum += i;
        }else{
        evenSum += i;
    }
}

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

//打印打印九九乘法表
	//第一步:先打印第一列
    for (int i = 1; i <= 9; i++) {
    System.out.println(1 + "*" + i + "=" + (1 * i));
    }
	//第二步:for循环嵌套，打印1x9-9x9
    for (int i = 1; i <= 9 ; i++) {
        for (int j = 1; j <= 9; j++) {
        System.out.print(j + "*" + i + "=" + (i * j));
        }
    }
	//第三步:去掉重复项：j<=i
 	for (int i = 1; i <= 9 ; i++) {
        for (int j = 1; j <= i; j++) {
        System.out.print(j + "*" + i + "=" + (i * j));
        }
    }
	//第四步:调整格式
 	for (int i = 1; i <= 9 ; i++) {
        for (int j = 1; j <= i; j++) {
        System.out.print(j + "*" + i + "=" + (i * j)+"\t");
        }
        System.out.println("\n");
    }

//打印三角形
 public static void main(String[] args) {
     //循环5次，每次+1
        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();
        }
    }

增强for循环

Java5 引入了一种主要用于数组或集合的增强型 for 循环。

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

//练习：增强for循环遍历输出数组元素
 public static void main(String[] args) {
    int [] numbers = {10, 20, 30, 40, 50};
     //把numbers这个数组每一项遍历出来赋值给了int x
     //x就是数组numbers每一个默认的数字
     //每次循环就会从里面取值
    for(int x : numbers ){
        System.out.print( x );
        System.out.print(",");
    }
    System.out.print("\n");
    String [] names ={"James", "Larry", "Tom", "Lacy"};
    for( String name : names ) {
        System.out.print( name );
        System.out.print(",");
    }
}

5-break & continue

• break关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。 break 跳出最里层的循环，并且继续执行该循环下面的语句。

//演示：跳出循环
public static void main(String[] args) {
    int i=0;
    while (i<100){
        i++;
        System.out.println(i);
        if (i==30){
        break;
    	}
    }
}

• continue 关键字

  continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

  在 for 循环中，continue 语句使程序立即跳转到更新语句。

  在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

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);
    }
}

• 二者区别

  break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循 环中剩余的语句。(break语句也在switch语句中使用)

  continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

带标签的continue(了解)

1. goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到 正式使用；Java没有goto。然而，在break和continue这两个关键字的身上，我们仍然能看出一些 goto的影子---带标签的break和continue。

2. “标签”是指后面跟一个冒号的标识符，例如：label:

3. 对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

4. 带标签的break和continue的例子：

//打印101-150之间所有的质数
public static void main(String[] args) {
    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+ " ");
    }
}