Java语言基础4 --程序流程控制

一、程序流程控制

1.  顺序结构
2. 分支结构
3. 循环结构

1.顺序结构

程序从上到下逐行地执行，中间没有任何判断和跳转 。

2.分支结构

根据条件，选择性地执行某段代码。
有if…else和switch-case两种分支语句。

2.1分支语句1： if-else结构

举个例子：

public class HelloWorld {
    public static void main(String[] args){
        int age = 75;
        if (age< 0) {
            System.out.println("不可能！");
        } else if (age>250) {
            System.out.println("是个妖怪！");
        } else {
            System.out.println("人家芳龄 " + age +" ,马马乎乎啦！");
        }

    }
}

//结果：
//人家芳龄 75 ,马马乎乎啦！

Scanner包举例子：

具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化：Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法(next()/nextXxx()),来获取指定类型的变量。

注意：需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchExce
,导致程序终止。

/*
如何从键盘获取不同类型的变量：需要使用Scanner类

具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化：Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法(next()/nextXxx()),来获取指定类型的变量。

注意：需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchExce
,导致程序终止。
*/

//1.导包：import java.util.Scanner;
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){
        //2.Scanner的实例化：Scanner scan = new Scanner(System.in);
        Scanner scan =  new Scanner(System.in); 
        
        //3.调用Scanner类的相关方法(next()/nextXxx()),来获取指定类型的变量。
        System.out.println("请输入姓名：");
        String name = scan.next();
        System.out.println(name);

        System.out.println("请输入芳龄：");
        int age = scan.nextInt();
        System.out.println(age);

        System.out.println("请输入你的体重：");
        double weight = scan.nextInt();
        System.out.println(weight);

        System.out.println("你是否相中我了呢？(true/false)");
        boolean isLove = scan.nextBoolean();
        System.out.println(isLove);

        //对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串
        System.out.println("请输入你的性别：（男/女）");
        String gender = scan.next();
        char genderChar = gender.charAt(0);
        System.out.println(isLove);

    }
}

例题1：

键盘输入，导入Scanner包

/*
如何从键盘获取不同类型的变量：需要使用Scanner类

具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化：Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法(next()/nextXxx()),来获取指定类型的变量。

注意：需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchExce
,导致程序终止。
*/

//1.导包：import java.util.Scanner;
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){
        //2.Scanner的实例化：Scanner scan = new Scanner(System.in);
        Scanner scan =  new Scanner(System.in);

        //3.调用Scanner类的相关方法(next()/nextXxx()),来获取指定类型的变量。
        System.out.println("请输入成绩：");
        int score = scan.nextInt();

        if (score == 100) {
        System.out.println("奖励一辆BMW");
        } else if (score>80 && score <= 99) {
        System.out.println("奖励一台iPhone xs max");
        } else if (score>=60 && score <=80){
        System.out.println("奖励一个iPad");
        } else {
        System.out.println("什么奖励都没有");
        }

    }
}

方法二： else if 执行完之后就不会往下执行了

//方法二： else if 执行完之后就不会往下执行了
 if (score == 100) {
        System.out.println("奖励一辆BMW");
        } else if (score>80) {
        System.out.println("奖励一台iPhone xs max");
        } else if (score>=60 ){
        System.out.println("奖励一个iPad");
        } else {
        System.out.println("什么奖励都没有");
        }

说明：

1. else结构是可选的。
2. 针对条件表达式：
   ①如果多个条件表达式之间是“互斥”关系，（或没有交集的关系），哪个判断和执行语句声明在上面还是下面，无所谓。
   ②若多条件表达式之间有交集关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面
   ③若多个条件之间有包含关系，通常情况下，需要将范围小的声明在范围大的上面。否则范围小的就没机会执行了

例题2：

编写程序：由键盘输入三个整数分别存入变量num1、num2、num3， 对它们进行排序(使用 if-else if-else),并且从小到大输出。

//1.导包：import java.util.Scanner;
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){
        //2.Scanner的实例化：Scanner scan = new Scanner(System.in);
        Scanner scan = new Scanner(System.in);

        //3.调用Scanner类的相关方法(next()/nextXxx()),来获取指定类型的变量。
        System.out.println("请输入第一个整数： ");
        int num1 = scan.nextInt();
        System.out.println("请输入第二个整数： ");
        int num2 = scan.nextInt();
        System.out.println("请输入第三个整数： ");
        int num3 = scan.nextInt();

        //两种情况 ： _n1_n2_  或者 _n2_n1_  其中_为n3放的位置

        if (num1 < num2) {                                              //情况1：_n1_n2_
            if(num3 < num1){
                System.out.println(num3 +" , "+ num1 +" , "+ num2);
            }else if(num3 > num2){
                System.out.println(num1 +" , "+ num2 +" , "+ num3);     //n3选择两边
            }else {
                System.out.println(num1 +" , "+ num3 +" , "+ num2);     //n3选择中间
            }
        } else {                                                        //情况2：_n2_n1_
            if( num3 < num2){
                System.out.println(num3 +","+ num2 +","+ num1);
            } else if (num3 > num1){
                System.out.println(num2 +","+ num1 +","+ num3);         //n3选择两边
            }else{
                System.out.println(num1 + ","+ num3 + ","+num2);        //n3选择中间
            }

        }

    }

说明：

1. if-else结构是可以嵌套的
2. 如果if-else结构中的执行语句只有一行时候，对应的一对{ }可以省略。但是不建议省略。

//1.导包：import java.util.Scanner;
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){
        //2.Scanner的实例化：Scanner scan = new Scanner(System.in);
        Scanner scan = new Scanner(System.in);

        //3.调用Scanner类的相关方法(next()/nextXxx()),来获取指定类型的变量。
        System.out.println("请输入第一个整数： ");
        int num1 = scan.nextInt();
        System.out.println("请输入第二个整数： ");
        int num2 = scan.nextInt();
        System.out.println("请输入第三个整数： ");
        int num3 = scan.nextInt();

        //两种情况 ： _n1_n2_  或者 _n2_n1_  其中_为n3放的位置

        if (num1 < num2) {                                              //情况1：_n1_n2_
            if(num3 < num1)
                System.out.println(num3 +" , "+ num1 +" , "+ num2);
            else if(num3 > num2)
                System.out.println(num1 +" , "+ num2 +" , "+ num3);     //n3选择两边
            else 
                System.out.println(num1 +" , "+ num3 +" , "+ num2);     //n3选择中间
        } else {                                                        //情况2：_n2_n1_
            if( num3 < num2)
                System.out.println(num3 +","+ num2 +","+ num1);
             else if (num3 > num1)
                System.out.println(num2 +","+ num1 +","+ num3);         //n3选择两边
            else
                System.out.println(num1 + ","+ num3 + ","+num2);        //n3选择中间
        }

    }
}

练习1 if-else if - else

1）

public class HelloWorld {
    public static void main(String[] args){
        int x = 4;
        int y = 1;
        if (x > 2) {
            if (y > 2) System.out.println(x + y);
        System.out.println("atguigu");
        } else System.out.println("x is " + x);

    }
}

输出结果为：atguigu

.
2）

//1.导包：import java.util.Scanner;
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){
        boolean b = true;//如果写成if(b=false)能编译通过吗？如果能，结果是？
        if(b == false) System.out.println("a");
        else if(b)
            System.out.println("b");
        else if(!b)
            System.out.println("c");
        else
            System.out.println("d");
    }
}

输出结果为：b

练习2：if-else

我家的狗5岁了，5岁的狗相当于人类多大呢？其实，狗的前两年每 一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗 相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。

public class HelloWorld {
    public static void main(String[] args){
        int dogAge = 5;
        if(dogAge   >=0 && dogAge <= 2){
            System.out.println("相当于人的年龄：" + dogAge* 10.5);
        }else if (dogAge > 2){
            System.out.println("相当于人的年龄： " + (2 * 10.5+ (dogAge - 2) * 4));
        }else{
            System.out.println("狗狗还没出生呢");
        }
    }
}

练习3:彩票游戏

假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入 一个两位数，然后按照下面的规则判定用户是否能赢。

1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。 4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。 5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。

练习4:

大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出 一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
 如果这三个条件同时满足，则：“我一定要嫁给他!!!”
 如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
 如果三个条件都不满足，则：“不嫁！”

提示：
Sysout(“身高: (cm))
scanner.nextInt();
Sysout(“财富: (千万))
scanner.nextDouble();
Sysout(“帅否: (true/false)) (是/否) scanner.nextBoolean(); scanner.next();
“是”.equals(str)

import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){

        //2.Scanner的实例化：Scanner scan = new Scanner(System.in);
       Scanner scan = new Scanner(System.in);

       //3.调用Scanner类的相关方法(next()/nextXxx()),来获取指定类型的变量。
       System.out.println("请输入你的身高：（cm）");
       int height = scan.nextInt();
       System.out.println("请输入你的财富:(千万)");
       Double wealth = scan.nextDouble();
       System.out.println("请输入是否帅：（true/false）");
       boolean isHandsome = scan.nextBoolean();

       if(height >= 180 && wealth > 1 && isHandsome){
                   System.out.println("我一定要嫁给他！！！");
       }else if (height >= 180 || wealth >= 1 || isHandsome){
           System.out.println("嫁吧，比上不足，比下有余。");
       }else{
           System.out.println("不嫁");
       }

    }
}

说明：
1.isHansome 可以不用写成 ==true.
2.isHansome 若写成是/否 就不能用scanner。而是用isHansome.equals

方式二：

import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){

        //2.Scanner的实例化：Scanner scan = new Scanner(System.in);
       Scanner scan = new Scanner(System.in);

       //3.调用Scanner类的相关方法(next()/nextXxx()),来获取指定类型的变量。
       System.out.println("请输入你的身高：（cm）");
       int height = scan.nextInt();
       System.out.println("请输入你的财富:(千万)");
       Double wealth = scan.nextDouble();
       System.out.println("请输入是否帅：（是/否）");
       String isHandsome = scan.next();

       if(height >= 180 && wealth > 1 && isHandsome.equals("是")){
                   System.out.println("我一定要嫁给他！！！");
       }else if (height >= 180 || wealth >= 1 || isHandsome.equals("是")){
           System.out.println("嫁吧，比上不足，比下有余。");
       }else{
           System.out.println("不嫁");
       }

    }
}
//第一处修改：String isHandsome = scan.next();
// 第二处修改：isHandsome.equals("是")

2.2分支语句2：switch-case结构

说明：
①根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。

②break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。

③case 之后只能声明常量；

④ default 想当于if- else结构中的else.
defailt 结构是可选的，而且位置是灵活的。

例题1

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

       int number = 2;
       switch (number){
           case 0:
               System.out.println("zero");
               break;
           case 1:
               System.out.println("one");
               break;
           case 2:
               System.out.println("two");
               break;
           case 3:
               System.out.println("three");
               break;
               default:
                   System.out.println("other");
                   break;
       }

    }
}

// 结果：2

public class HelloWorld {
    public static void main(String[] args){
        String season = "summer";
        switch (season){
            case "spring":
                System.out.println("春暖花开");
                break;
            case "summer":
                System.out.println("夏日炎炎");
                break;
             case "autumn":
                System.out.println("秋高气爽");
             break;
             case "winter":
                 System.out.println("冬雪皑皑");
                 break;
                 default:
                    System.out.println("季节输入有误");
                    break;
     }
    }
}
//结果：夏日炎炎

例题2：输出成绩是否合格

1）对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

public class HelloWorld {
    public static void main(String[] args){
        int score = 78;
        switch ( score / 10){
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("不及格");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:
                System.out.println("及格");
                break;
     }
    }
}

//方法2：更优的解决方案
 int score = 78;
        switch ( score / 60){
            case 0:
                System.out.println("不及格");
                break;
            case 1:
                System.out.println("及格");
                break;
     }
//结果：及格

说明：如果switch - case结构中的多个case 的执行语句相同时，则可以考虑进行合并。

2）根据用于指定月份，打印该月份所属的季节。 3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季

3.break 在switch-case 中是可选的。

例题3：出输入的日期为2019年的第几天

编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序 输出输入的日期为2019年的第几天。

//1.导包：import java.util.Scanner;

import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){

        Scanner scan = new Scanner(System.in);

        System.out.println("请输入2019年的month: ");
        int month = scan.nextInt();
        System.out.println("请输入2019年的day: ");
        int day = scan.nextInt();

        int sumDays = 0;
        switch (month){
            case 12:
                sumDays += 30;
            case 11 :
                sumDays += 31;
            case 10:
                sumDays += 30;
            case 9:
                sumDays += 31;
            case 8:
                sumDays += 31;
            case 7:
                sumDays += 30;
            case 6:
                sumDays += 31;
            case 5:
                sumDays += 30;
            case 4:
                sumDays += 31;
            case 3:
                sumDays += 28;
            case 2:
                sumDays += 31;
            case 1:
                sumDays += day;
        }
        System.out.println("2019年"+ month +"月" + day + "日是当年的第" + sumDays + "天");

    }
}

方式一：冗余

        if(month == 1){
            sumDays = day;
        }else if(month == 2){
            sumDays = 31 + day;
        }else if(month == 3){
            sumDays = 31+28+day;
        }else if(month == 4){
            sumDays = 31+28+31+day;
        }
        else{//month == 12
            //sumDays = …… + day
        }

方式二：冗余

        switch (month){
            case 1:
                sumDays = day;
                break;
            case 2 :
                sumDays = 31 + 28 + day;
                break;
            case 3:
                sumDays = 31 + 28 + day;
                break;
                ....

练习1

从键盘分别输入年、月、日，判断这一天是当年的第几天？
注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
或
2）可以被400整除

//1.导包：import java.util.Scanner;
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){

        Scanner scan = new Scanner(System.in);

        System.out.println("请输入年year: ");
        int year = scan.nextInt();
        System.out.println("请输入月month: ");
        int month = scan.nextInt();
        System.out.println("请输入日day: ");
        int day = scan.nextInt();

        int sumDays = 0;
        switch (month){
            case 12:
                sumDays += 30;
            case 11 :
                sumDays += 31;
            case 10:
                sumDays += 30;
            case 9:
                sumDays += 31;
            case 8:
                sumDays += 31;
            case 7:
                sumDays += 30;
            case 6:
                sumDays += 31;
            case 5:
                sumDays += 30;
            case 4:
                sumDays += 31;
            case 3:
                if((year % 4 == 0 && year / 100 != 0 )|| year % 400 == 0 ){
                    sumDays += 29;
                }else{
                    sumDays += 28;
                }
            case 2:
                sumDays += 31;
            case 1:
                sumDays += day;
        }
        System.out.println(year + "年"+ month +"月" + day + "日是当年的第" + sumDays + "天");
    }
}

练习2

使用switch语句改写下列if语句

		int a = 3;
        int x = 100;
        
        if(a==1) 
            x+=5;
        else if(a==2)
            x+=10;
        else if(a==3)
            x+=16;
        else
            x+=34;
        System.out.println(x);
        
//结果为：116

使用switch 结果：

public class HelloWorld {
    public static void main(String[] args){
        int a = 3;
        int x = 100;
        switch (a){
            case 1:
                x+=5;
                break;
            case 2:
                x+=10;
                break;
            case 3:
                x+=16;
                break;
                default:
                    break;
        }
        System.out.println(x);
    }
}
// 结果为116

练习3

编写程序：从键盘上读入一个学生成绩，存放在变量score中，根据score的
值输出其对应的成绩等级：
score>=90 等级: A
70<=score<90 等级: B
60<=score<70 等级: C
score<60 等级: D

方式一：使用if-else
方式二：使用switch-case: score / 10: 0 - 10

//1.导包：import java.util.Scanner;
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){

        Scanner scan = new Scanner(System.in);

        System.out.println("请输入成绩: ");
        int score = scan.nextInt();

        switch (score / 10 ) {
            case 10:
            case  9:
            System.out.println("A");
            break;
            case  8:
            case  7:
            System.out.println("B");
            break;
            case  6:
            System.out.println("C");
            break;
            case  5:
            case  4:
            case  3:
            case  2:
            case  1:
            System.out.println("C");
            break;
            default:
                break;
        }
    }
}

2.3 switch和if语句的对比

说明：
1.凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
2.我们写分支结构的时，当发现既可以使用switch-case,(同时，switch中表达式的取值情况不太多)，又可以只用if- else 时，我们优先选择使用switch-case。
原因 ：switch-case执行效率稍高。

3.循环结构

根据循环条件，重复性的执行某段代码。
有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

3.1 循环结构2：for循环

练习:

练习1：输出5个Hello World !

public class HelloWorld {
    public static void main(String[] args){
        for(int i = 1; i <= 5 ;i++){
        System.out.println("Hello World !");
        }

    }
}

练习2

public class HelloWorld {
    public static void main(String[] args){
        int num = 1;
        for(System.out.println("a"); num <= 5 ;System.out.println("a"),num++){
        System.out.println("b");
        }

    }
}
//结果：abcbcbc

练习3：
遍历100以内的偶数，输出所有偶数的和，输出偶数的个数。

public class HelloWorld {
    public static void main(String[] args){
        int sum = 0;
        int count = 0;
        for(int i = 1; i <=100 ;i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
                count ++;
            }
            //System.out.println("总和为："+ sum)不能放在这里。
        }
        System.out.println("总和为："+ sum);//当整个循环结束之后，告诉我总和等于多少就行
        System.out.println("个数为：" + count);
    }
}

例题1

编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行 上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印 输出“baz”。

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

        for(int i = 1; i <=150 ;i++) {
            System.out.print(i + " ");
            if (i % 3 == 0) {
                System.out.print("foo ");
            }
            if (i % 5 == 0) {
                System.out.print("biz ");
            }
            if (i % 7 == 0) {
                System.out.print("baz ");
            }
            //换行
            System.out.println();
        }
    }
}

例题2

题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用

//1.导包：import java.util.Scanner;
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){

        Scanner scan = new Scanner(System.in);

        System.out.println("请输入第一个正整数：");
        int m = scan.nextInt();

        System.out.println("请输入第二个正整数：");
        int n = scan.nextInt();
        
        //①获取最大公约数
        //获取两个数中的较小值
        int min = (m <= n)? m : n;
        for(int i = min;i >= 1;i--){
            if(m % i == 0 && n % i == 0){
            System.out.println("最大公约数为： " + i);
            break;
        }
        }

        //获取最小公倍数
        //1.获取两个数中的较大值
        int max = (m >= n)? m : n ;
        //遍历
        for (int i = max;i <= m * n;i++){
            if(i % m == 0 && i % n == 0){
                System.out.println("最小公倍数：" + i);
                break;
            }
        }
    }
}

3.2循环结构2： while循环

练习：

遍历100以内的所有偶数

public class HelloWorld {
    public static void main(String[] args){
        //遍历100以内的所有偶数
        int i = 1;
        while (i <= 100){
            if(i % 2 == 0){
                System.out.println(i);
            }
            i++;
        }
    }
}

说明：

1. for循环和while循环是可以相互转换的！
2. 区别：for循环和while循环的初始化条件部分的作用范围不同。

3.3 循环结构3： do-while循环

在开发中，使用for 和while更多一些。较少使用do-while。

练习：

遍历100以内的偶数，并计算所有偶数的和及所有偶数的个数

public class HelloWorld {
    public static void main(String[] args){
        //遍历100以内的所有偶数
        int i = 1;
        int sum = 0;
        int count = 0;
        do{
           if( i % 2 == 0){
            System.out.println(i);
            sum += i;
            count++;
           }
           i ++ ;
        }while(i <= 100);
        System.out.println("总和为：" + sum);
        System.out.println("个数为：" + count);
    }
}

循环语句综合例题

从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入 为0时结束程序。

最简单“无限” 循环格式：while(true) , for(;😉,无限循环存在的原因是并不
知道循环多少次，需要根据循环体内部某些条件，来控制循环的结束。

import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args){
        
        Scanner scan = new Scanner(System.in);

        int positiveNumber = 0;//记录正数的个数
        int negativeNumber = 0;//记录负数的个数

        while(true){

            int number =  scan.nextInt();

            //判断number的正负情况
            if(number > 0){
                positiveNumber++;
            }else if (number < 0){
                negativeNumber++;
            }else{
                //一旦执行break,跳出循环
                break;
            }
        }
        System.out.println("输入的正数个数为："+ positiveNumber);
        System.out.println("输入的负数个数为："+ negativeNumber);
    }
}


//************************

int positiveNumber = 0;//统计正数的个数
        int negativeNumber = 0;//统计负数的个数
        int[] array = new int[]{1, 8, -9, 78, 45, 0, -23, -14, 45, 78, -69};
        int index = 0;
        while (index < array.length){
            int value = array[index];
            if (value > 0){
                positiveNumber++;
            }
            else  if (value < 0){
                negativeNumber++;
            }
            else {
                break;
            }
            index++;
        }
        String str = "";
        for (int i = 0; i < 10; i++){
            if (i == 5)
                return;
            str += i + ",";
        }
        System.out.println("输出的值：" + str);
//        System.out.println("正整数个数：" + positiveNumber);
//        System.out.println("负数的个数：" + negativeNumber);
    }
}

说明：
1.不在循环条件部分限制次数的结构：for(;;)或while(true)
2.结束循环存在以下两种方式：
方式一：循环条件部分返回false;
方式二：在循环体中，执行break;

3.4 嵌套循环

嵌套循环 ，通常不超过三层；

说明：
① 内层循环结构遍历一遍，只相当于外层循环循环体执行一次。
②假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m* n次。
③外层循环控制行数，内层循环控制列数

练习：

练习1：生成如下形状：
******
******
******
******

思路：①先生成一行6个*号；
②生成4行；

public class HelloWorld {
    public static void main(String[] args){
        for (int j = 1; j<=4; j++){
            for(int i=1 ;i <= 6; i++){
                System.out.print("*");
            }
            System.out.println("");
        }
    }
}

练习2：生成如下形状：
*
**
***
****
*****

		i(行号)		j(*)的个数**
*          1          1     
**         2          2
***        3          3
****       4          4
*****      5          5

public class HelloWorld {
    public static void main(String[] args){
        for (int j = 1; j<=5; j++){     //控制行数
            for(int i=1 ;i <= j; i++){  //控制列数
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

练习3：生成如下形状：
*****
****
***
**
*

		i(行号)		j(*)的个数**    规律：i + j= 6  即j = 6 - i
*****      1          5
****       2          4
***        3          3
**         4          2
*          5          1

public class HelloWorld {
    public static void main(String[] args){
        for (int j = 1; j<=5; j++){     //控制行数
            for(int i=1 ;i <= 6 - j; i++){  //控制列数
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

练习4 ：九九乘法表：

public class HelloWorld {
    public static void main(String[] args){
        for (int j = 1; j<=9; j++){     //控制行数
            for(int i=1 ;i <= j ; i++){  //控制列数
                System.out.print(i + "*"+ j + "=" + (i * j)+ "  ");
            }
            System.out.println();
        }
    }
}

练习4:100以内的质数（面试）

质数：素数，只能被1和它本身整除的自然数。

//方法1：马马虎虎及格
public class HelloWorld {
    public static void main(String[] args){

        boolean isFlag = true;  //标识i是否被j除尽，一旦除尽，修改其值

        for (int i = 2; i<=100; i++){     //遍历100以内的自然数

            for(int j=2 ;j < i ; j++){    //j：被i去除

                if(i % j == 0){           //i被j除尽
                    isFlag = false;
                }
            }
            if(isFlag == true){
                System.out.println(i);
            }
            //重置isFlag
            isFlag = true;
        }

    }
}

//:优化1：添加break;
public class HelloWorld {
    public static void main(String[] args){

        boolean isFlag = true;  //标识i是否被j除尽，一旦除尽，修改其值

        //获取当前时间距离1970-01-01 00:00:00的毫秒数
        long start = System.currentTimeMillis();

        for (int i = 2; i<=100000; i++){     //遍历100以内的自然数

            for(int j=2 ;j < i ; j++){    //j：被i去除

                if(i % j == 0){           //i被j除尽
                    isFlag = false;
                    break;                 //优化1：只对本身非质数的自然数有效的
                }
            }
            if(isFlag == true){
                System.out.println(i);
            }
            //重置isFlag
            isFlag = true;
        }

        long end = System.currentTimeMillis();
        System.out.println("所花费的时间为：" +(end - start));

    }
}

优化2：Math.sqrt(i)
public class HelloWorld {
    public static void main(String[] args){

        boolean isFlag = true;  //标识i是否被j除尽，一旦除尽，修改其值

        //获取当前时间距离1970-01-01 00:00:00的毫秒数
        long start = System.currentTimeMillis();

        for (int i = 2; i<=100; i++){     //遍历100以内的自然数

            //优化2：对本身是质数的自然数是有效的。
            for(int j=2 ;j <= Math.sqrt(i) ; j++){    //j：被i去除

                if(i % j == 0){           //i被j除尽
                    isFlag = false;
                    break;                 //优化1：只对本身非质数的自然数有效的
                }
            }
            if(isFlag == true){
                System.out.println(i);
            }
            //重置isFlag
            isFlag = true;
        }

        long end = System.currentTimeMillis();
        System.out.println("所花费的时间为：" +(end - start));

    }
}


//优化3：优秀
public class HelloWorld {
    public static void main(String[] args){

        boolean isFlag = true;  //标识i是否被j除尽，一旦除尽，修改其值
        int count = 0;//记录质数的个数

        //获取当前时间距离1970-01-01 00:00:00的毫秒数
        long start = System.currentTimeMillis();

        for (int i = 2; i<=100000; i++){     //遍历100以内的自然数

            //优化2：对本身是质数的自然数是有效的。
            for(int j=2 ;j <= Math.sqrt(i) ; j++){    //j：被i去除

                if(i % j == 0){           //i被j除尽
                    isFlag = false;
                    break;                 //优化1：只对本身非质数的自然数有效的
                }
            }
            if(isFlag == true){
                // System.out.println(i);
                count++;
            }
            //重置isFlag
            isFlag = true;
        }

        long end = System.currentTimeMillis();
        System.out.println("质数的个数为： " + count);
        System.out.println("所花费的时间为：" +(end - start));

    }
}

3.5 特殊关键字的使用： break、continue

	使用范围	循环中使用的作用	相同点
break	switch-case循环中	结束当前循环	关键字后面不能声明执行语句
continue	循环结构中	结束当次循环	关键字后面不能声明执行语句

举例1：

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

        for (int i = 1; i<=10; i++){
            if(i % 4 == 0){
                // break;   //123
                continue;   //123567910
            }
            System.out.println(i);
        }
    }
}

举例2

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

      lable: for(int i = 1;i<=4 ; i++) {
            for (int j = 1; j <= 10; j++) {
                if (j % 4 == 0) {
                    //break;   //默认跳出此关键字最近的一层循环
                    //continue;

                    //break lable;//结束指定标识的一层循环结构
                    continue lable;//结束指定标识的一层循环结构当次循环
                }
                System.out.println(j);
            }
        }
    }
}

结果：

举例3：取数质数优化

public class HelloWorld {
    public static void main(String[] args){
    
        int count = 0;//记录质数的个数

        //获取当前时间距离1970-01-01 00:00:00的毫秒数
        long start = System.currentTimeMillis();

       label: for (int i = 2; i<=100000; i++){     //遍历100000以内的自然数

            for(int j=2 ;j <= Math.sqrt(i) ; j++){    //j：被i去除

                if(i % j == 0){           //i被j除尽
                    continue label;
                }
            }
            //能执行到此步骤的，都是质数
            count++;

        }

        long end = System.currentTimeMillis();
        System.out.println("质数的个数为： " + count);
        System.out.println("所花费的时间为：" +(end - start));

    }
}