2021.4.12 Day 05 Java流程控制

Java流程控制

01 用户交互Scanner

• 之前学习的基本语法中没有实现程序和人的交互，但Java给我们提供了这样一个工具类，我们可以获取用户的输入。java…util.Scanner 是 Java5 的新特性，我们可以通过scanner 类来获取用户的输入

• 基本语法：

  Scanner s = new Scanner(System.in);
  

• System.out代表标准输出流，而System.in代表标准输入流。直接使用System.in读取用户输入虽然是可以的，但需要更复杂的代码，而通过Scanner就可以简化后续的代码。

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

  • next()： Demo01
    1. 一定要读取到有效字符后才可以结束输出；
    2. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉；
    3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符；
    4. next()不能得到带有空格的字符串。
  • nextLine()： Demo02
    1. 以Enter为结束符，也就是所nextLine()方法返回的是输入回车之前的所有字符。
    2. 可以获得空白。

​ Demo04 : 输入整数数据

import java.util.Scanner;

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

        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接受：");

        //判断用户有没有输入字符串   if中 ==true可以省略，会默认==true
        if (scanner.hasNext()==true){
            //使用next方式接受
            String str = scanner.next();  //程序会等待用户输入完毕 变成变量保存到str里
            //输入Hello World
            System.out.println("输出的内容为："+str);  //输出Hello
        }

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

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();  //等待输入  输入Hello World
            System.out.println("输出的内容为："+str);  //输出Hello World
        }

        scanner.close();
    }
}

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据：");

        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();           //输入1       输入1.1
            System.out.println("整数数据："+i);//输出1          ↓
        }else {
            System.out.println("输入的不是整数数据！");     //输出字符串
        }

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

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

        scanner.close();
    }
}

IDEA . C:\Users\KT 166\Desktop\java\java SE\基础语法\src\com\haha\scanner\Deam01

格式化输出：使用System.out.printf()，通过使用占位符%?，printf()可以把后面的参数格式化成指定格式

public class Main {
    public static void main(String[] args) {
        double d = 3.1415926;
        System.out.printf("%.2f\n", d); // 显示两位小数3.14
        System.out.printf("%.4f\n", d); // 显示4位小数3.1416
    }
}

//把一个整数格式化成十六进制，并用0补足8位
public class Main {
    public static void main(String[] args) {
        int n = 12345000;
        System.out.printf("n=%d, hex=%08x", n, n); // 注意，两个%占位符必须传入两个数
    }
}

占位符	说明
%d	格式化输出整数
%x	格式化输出十六进制整数
%f	格式化输出浮点数
%e	格式化输出科学计数法表示的浮点数
%s	格式化字符串

连续两个%%表示一个%字符本身。详细的格式化参数请参考JDK文档java.util.Formatter

02 Scanner进阶使用

package com.haha.scanner;

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;//相当于 m = ++m
            sum = sum + x;
            System.out.println("你输入了第"+m+"个数据，然后当前结果sum="+sum);
        }  //输入一个数字-->输出：你输入了第m个数据，然后当前结果sum=sun+x，
           //如：10-->你输入了第1个数据，然后当前结果sum=10
           //   20你输入了第2个数据，然后当前结果sum=30……
        
           //输入非数字-->3个数的和为60.0   3个数的平均值是20.0
        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值是" + (sum / m));

        scanner.close();
    }
}

03 顺序结构

• Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。

• 顺序结构是最简单的算法结构：

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

04 if选择结构

1. if单选择结构

• 我们很多时候需要去判断一个东西是否可行，然后才去执行，这个过程在程序中用if语句来表示。

• 语法：

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

  package com.haha.struct;
  
  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();
      }
  }
  

• 引用类型判断内容相等要使用equals()，注意避免NullPointerException。

• 在Java中，判断值类型的变量是否相等，可以使用==运算符。但是，判断引用类型的变量是否相等，==表示“引用是否相等”，或者说，是否指向同一个对象。例如，下面的两个String类型，它们的内容是相同的，但是，分别指向不同的对象，用==判断，结果为false：

public class Main {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO".toLowerCase();
        System.out.println(s1);		//hello
        System.out.println(s2);		//hello
        if (s1 == s2) {
            System.out.println("s1 == s2");
        } else {
            System.out.println("s1 != s2");//输出s1 != s2
        }
    }
}

public class Main {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO".toLowerCase();
        System.out.println(s1);		//hello
        System.out.println(s2);		//hello
        if (s1.equals(s2)) {
            System.out.println("s1 equals s2");//输出s1 equals s2
        } else {
            System.out.println("s1 not equals s2");
        }
    }
}

• 执行语句s1.equals(s2)时，如果变量s1为null，会报NullPointerException
• 要避免NullPointerException错误，可以利用短路运算符&&
• 还可以把一定不是null的对象"hello"放到前面：例如：if ("hello".equals(s)) { ... }。

public class Main {
    public static void main(String[] args) {
        String s1 = null;
        if (s1.equals("hello")) {
            System.out.println("hello");
        }
    }
}
/*
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "<local1>" is null
at Main.main(Main.java:5)
*/

public class Main {
    public static void main(String[] args) {
        String s1 = null;
        if (s1 != null && s1.equals("hello")) {
            System.out.println("hello");
        }
    }
}

2. if双选择结构

• 现在有个需求，公司要收购一个软件，成功了，给人支付100w元，失败了，自己找人开发。这样的需求用一个if就搞不定了，我们需要由两个判断，需要一个双选择结构，所以就有了if-else结构。

• 语法：

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

package com.haha.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();
    }

}

//浮点数在计算机中常常无法精确表示，并且计算可能出现误差，因此，判断浮点数相等用==判断不靠谱
//利用差值小于某个临界值来判断
public class Main {
    public static void main(String[] args) {
        double x = 1 - 9.0 / 10;
        if (Math.abs(x - 0.1) < 0.00001) {
            System.out.println("x is 0.1");
        } else {
            System.out.println("x is NOT 0.1");
        }
    }
}
//x is NOT 0.1

3. if多选择结构

• 我们发现刚才的代码不符合实际情况，真实情况还可能存在ABCD，存在区间多级判断，因此需要一个多选择结构来处理这类问题！

• 语法：

if(布尔表达式 1){
    //如果布尔表达式 1的值为true将执行的语句
}else if(布尔表达式 2){
    //如果布尔表达式 2的值为true将执行的语句
}else if(布尔表达式 3){
    //如果布尔表达式 3的值为true将执行的语句
}else {
    //如果以上布尔表达式的值都不为true将执行的语句
}

package com.haha.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 语句至多由1个 else 语句，语句在所有的 else if 语句之后；
        if 语句可以由若干个 else if 语句，它们必须在 else 语句之前；
        一旦 if 或 其中一个 else if 语句检测为true，其他的 else if 以及 else 语句都将跳过执行
         */

        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("成绩不合法");
        }

        scanner.close();
    }
}

按照判断范围从大到小依次判断：

// 从大到小依次判断：
if (n >= 90) {
    // ...
} else if (n >= 60) {
    // ...
} else {
    // ...
}

或者改写成从小到大依次判断：

// 从小到大依次判断：
if (n < 60) {
    // ...
} else if (n < 90) {
    // ...
} else {
    // ...
}

练习：彩票游戏

//获取一个随机数：10-99		公式：[a,b]：(int)(Math.random()*(b-a+1)+a)
int value = (int)(Math.random()*90+10);//[0.0,1.0)-->[0.0,90.0)-->[10.0,100.0)-->[10,99]
    
package com.haha.struct;

import java.util.Scanner;

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

        int num = (int)(Math.random()*90+10);
        int num1 = num / 10;
        int num2 = num % 10;

        System.out.println("请输入一个两位数：");
        int guess = scanner.nextInt();
        int guess1 = guess / 10;
        int guess2 = guess % 10;

        if (guess == num){
            System.out.println("奖金 10_000 美元");
        }else if (guess1 == num2 && guess2 == num1){
            System.out.println("奖金 3_000 美元");
        }else if (guess1 == num1 || guess2 == num2){
            System.out.println("奖金 1_000 美元");
        }else if (guess1 == num2 || guess2 == num1){
            System.out.println("奖金 500 美元");
        }else{
            System.out.println("没中奖");
        }

        System.out.println("中奖号码是："+num);
    }
}

4. 嵌套的if结构

• 使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。你可以像 if 语句一样嵌套 else if…else。
• 语法：

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

05 Switch选择结构

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

• switch case 语句执行效率比 if else 高

• 从Java 12开始，switch语句升级为更简洁的表达式语法，使用类似模式匹配（Pattern Matching）的方法，保证只有一种路径会被执行，并且不需要break语句。新语法使用->，如果有多条语句，需要用{}括起来。还可以直接返回值：int opt = switch(){……};。用yield返回一个值作为switch语句的返回值。

• 语法：

switch(expression){
    case value :
        //语句
        break;//可选
    case value :
        //语句
        break;//可选
    //你可以有任意数量的 case 语句
    default ://可选
        //语句
}

• switch 语句中的变量类型可以是：
  • byte、short、int 或者 char；
  • JDK 5.0 新增：枚举类型；
  • 从 Java SE 7 开始，switch 支持字符串 String 类型了；
  • 同时 case 标签必须为字符串常量或字面量。
• 可用 switch 语句给某个变量赋值

package com.haha.struct;

public class SwitchDemo01 {
    public static void main(String[] args) {
        //case 穿透     //switch 匹配一个具体的值
        char grade = 'C';// F 输出未知等级

        switch (grade){
            case'A':
                System.out.println("优秀");
                break;//跳出循环，不加break则跑完以下程序
            case'B':
                System.out.println("良好");
                break;//
            case'C':
                System.out.println("及格");
            case'D':
                System.out.println("再接再厉");
                break;//
            /*如果有几个case语句执行的是同一组语句块
            case'C':
            case'D':
                System.out.println("及格，再接再厉");
                break;
            */    
            case'E':
                System.out.println("挂科");
            default:
                System.out.println("未知等级");
            //输出为：及格  再接再厉
        }
        
        String name = "哈哈";
        //JDK的新特性，表达式结果可以是字符串
        //字符的本质还是数字

        //反编译  java--class（字节码文件）--反编译（IDEA）：将class放入IDEA查看源码
        //找到项目结构（project structure）-->项目编译输出路径（project compiler output）-->可查找class文件
        //hashCode：每一个对象都有一个对应的hashCode，通过一些特定的算法生成的，hash值
        
        switch (name){
            case "咖啡":
                System.out.println("咖啡");
                break;
            case "哈哈":
                System.out.println("哈哈");//输出
                break;
            default:
                System.out.println("弄啥嘞！");
    }
        //给某个变量赋值
        String fruit = "apple";
        int opt;
		switch (fruit) {
			case "apple":
			    opt = 1;//
			    break;
			case "pear":
			case "mango":
			    opt = 2;
			    break;
			default:
			    opt = 0;
			    break;
	}
}

06 While循环详解

• while是最基本的循环

• 语法结构：

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

• 只要布尔表达式为 true ，循环就会一直执行下去；
• 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失败的方式来结束循环；
• 少部分情况需要循环一直执行，比如服务器的请求响应监听等；
• 循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃！
• 思考：计算1+2+3+…+100=？

package com.haha.struct;

public class WhileDemo01 {
    public static void main(String[] args) {
        //输出1~100

        int i = 0;

        while (i<100) {
            i++;
            System.out.println(i);//1~100
        }
        System.out.println(i);//100

        //尝试
        int a = 0;
        while (a++<100) {  //a==99<100, a=a+1=100; a==100false,a=a+1=101
            System.out.println(a);//1~100
        }
        System.out.println(a);//101
    }
}

package com.haha.struct;

public class WhileDemo02 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;

        while(i<=100){
            sum = sum +i;
            i++;
            System.out.println(i);    //0~101
            System.out.println(sum);  //0~5050
        }

        //尝试
        int a =0;
        int b = 0;

        while(a++<=100){ //a==100<=100 之后a++自增a==101。先进行比较，后自增
                         //a==101 false a=a+1=102
            b = b +a;
        System.out.println(a);   //1~101
        System.out.println(b);  //1~5151
        }
        System.out.println(a);  //102
    }
}

07 DoWhile循环

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

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

• 语法：

do{
    //代码语句
}while(布尔表达式);

• while 和 do…while 的区别：
  • while 先判断后执行；dowhile先执行后判断
  • dowhile 总是保证循环体会被至少执行一次！这是他们的主要差别。

package com.haha.struct;

public class DoWhileDemo01 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;

        do {
            sum = sum + i;
            i++;
        }while (i<=100);

        System.out.println(sum);
    }
}

package com.haha.struct;

public class DoWhileDemo02 {
    public static void main(String[] args) {
        int a = 0;
        while (a<0){
            System.out.println(a);
            a++;
        }
        System.out.println("======================");//输出的0在分割线下方
        do {
            System.out.println(a);
            a++;
        }while (a<0);
    }
}

08 For循环详解

• for 循环使得一些循环结构更简单；

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

• for 循环执行的次数是在执行前就确定的。

• 语法：

for(初始化;布尔表达式;d){    
	//代码语句
}

package com.haha.struct;

public class ForDemo01 {
    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("for 循环结束！");
        
        for (int i = 0; i < 100; i++) { // 100.for + 回车键
        
        }
        
        /*
        关于 for 循环有以下几点说明：
        最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
        然后，检测布尔表达式的值。如果为 true，循环日被执行。如果为 false，循环终止开始执行循环体后面的语句。
        执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。
        再次检测布尔表达式。循环执行上面的过程。
         */
        //死循环
        for ( ; ; ) {
            
        }
    }
}

使用for循环时，计数器变量i要尽量定义在for循环中：

int[] ns = { 1, 4, 9, 16, 25 };
for (int i=0; i<ns.length; i++) {
    System.out.println(ns[i]);
}
// 无法访问i
int n = i; // compile error!

如果变量i定义在for循环外：

int[] ns = { 1, 4, 9, 16, 25 };
int i;
for (i=0; i<ns.length; i++) {
    System.out.println(ns[i]);
}
// 仍然可以使用i
int n = i;

退出for循环后，变量i仍然可以被访问，这就破坏了变量应该把访问范围缩到最小的原则。

• 练习1：计算0到100之间的奇数的和 和 偶数的和； ForDemo02
• 练习2：用 while 或 for 循环输出1-1000之间能被5整除的数，并且每行输出3个 ForDemo03
• 练习3：打印九九乘法表 ForDemo04

package com.haha.struct;

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

package com.haha.struct;

public class ForDemo03 {
    public static void main(String[] args) {
        // 练习2：用 while 或 for 循环输出1-1000之间能被5整除的数，并且每行输出3个
        //嵌套的 for 结构     for 结构中嵌套的 if 结构
        for (int i = 0; i <= 1000; i++) {
            if (i%5==0){
                System.out.print(i+"\t");//  \t相当于 Tab 键
            }
            if (i%(5*3)==0){
                System.out.println();//换行
                //或者System.out.print("\n");
            }
        }
        //println 输出完会换行
        //print 输出完不会换行

        //System.out.print(i)    输出 i 之后不换行
        //System.out.print("\t") 输出同一行 ”空格“
        //System.out.print("\n") 输出换行
    }
}

09 打印九九乘法表

• 外循环 控制行数，内循环 控制列数

/*		j（行号）i（*的个数）
*		1		1
**		2		2
***		3		3
****	4		4
*****	5		5

		j（行号）i（*的个数） 规律：i+j=5 -->j=5-i
****	1		4
***		2		3
**		3		2
*		4		1
*/
package com.haha.struct;

public class ForDemo04 {
    public static void main(String[] args) {
        //1. 先打印第一列
        //2. 把固定的 1 再用一个循环包起来
        //3. 去掉重复项，i<=j
        //4. 调整样式
        
        for (int j=1;j<=9;j++){     //控制行数
            for (int i=1;i<=j;i++){ //控制列数
                System.out.print(i+"*"+j+"="+(j*i)+"\t");
            }
            System.out.println();
        }
    }
}

10 增强for循环

• Java 5 引入了一种主要用于数组或集合的增强型 for 循环：for each循环
• Java 增强 for 循环语法格式：

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

• 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
• 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

//遍历数组
public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
        System.out.println(n);        
        }    
    }
}

11 break、continue、goto

• break 在任何循环语句的主体部分，均可用控制 break 控制循环的流程；break 用于强行退出循环，不执行循环中剩余的语句。（也可在 switch 语句中使用）
• continue 语句用在循环语句中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一 次是否执行循环的判定

package com.haha.struct;

public class BreakDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30){
                break;//用于循环语序中，不终止程序
            }
        }
        System.out.println("123");
    }
}

//要特别注意，break 语句总是跳出自己所在的那一层循环。continue也是如此
//break语句位于内层的for循环，因此，它会跳出内层for循环，但不会跳出外层for循环。
public class Main {
    public static void main(String[] args) {
        for (int i=1; i<=10; i++) {
            System.out.println("i = " + i);
            for (int j=1; j<=10; j++) {
                System.out.println("j = " + j);
                if (j >= i) {
                    break;
                }
            }
            // break跳到这里
            System.out.println("breaked");
        }
    }
}

package com.haha.struct;

public class ContinueDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i<100){
            i++;
            System.out.println(i);
            if (i%10==0){
                System.out.println();
                continue;
            }
            System.out.print(i);
        }
    }   
}

• 关于 goto 关键字：
  • goto 关键字很早就在程序设计语言中出现。尽管 goto 仍是 Java 的一个保留字，但并未在语言中得到正式使用；Java 没有 goto。然而，在 break 和 continue 这两个关键字的身上，我们仍然能看出一些 goto 的影子——带标签的 break 和 continue。
  • “标签“是指后面跟一个冒号的标识符，例如：label:
  • 对 Java 来说唯一用到标签的地方是在循环语句之前，而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，他们就会中断到存在标签的地方。

package com.haha.struct;

public class LabelDemo {
    public static void main(String[] args) {
        //打印 101 - 150 之间的所有质数
        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+" ");
        }
		System.out.println("质数的个数为：" + count);
        System.out.println();
        //打印100以内的质数
        boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
        
        //获取当前时间距离 1970-01-01 00:00:00 的毫秒数
        long start = System.currentTimeMillis();
        
        for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
            
          //for(int j = 2;j < i;j++){//j：被j去除
            for(int j = 2;j <= Math.sqrt(i);j++){//优化二：对本身是质数的自然数有效，j≤开方i	比如：21：	1 2 3 … 根号21 … 7 10.5 21
                if(i % j == 0){//i被j除尽
                    isFlag = false;
                    break;//优化一：只对本身非质数的自然数有效。比如：i=50，可除以j=2，直接跳出循环
                }
            }
            if(isFlag){
                System.out.println(i);//输出一个个质数会拖慢算法的时间
            }
            //重置isFlag	//如果isFlag放入for循环中，则不需要重置
            isFlag = true;
        }
        //获取当前时间距离 1970-01-01 00:00:00 的毫秒数
        long end = System.currentTimeMillis();
        System.out.println("所花费的时间为" + (end-start));
        //未优化：24558    优化一：2352    优化二：100
    }
}

12 打印三角形及Debug

package com.haha.struct;

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

家庭收支记账项目

package com.haha.FamilyAccount;

import java.util.Date;
import java.text.SimpleDateFormat;

public class Start {
    public static void main(String[] args) {
        boolean isFlag = true;
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        System.out.println(df.format(new Date()));// new Date()为获取当前系统时间
        //long currentTime=0;
        String currentTime = "";
        String details = "";
        int balance = 10000;
        while (isFlag) {
            System.out.println("=======================================家庭收支记账软件===============================");
            System.out.println("              1 收入明细");
            System.out.println("              2 登记收入");
            System.out.println("              3 登记支出");
            System.out.println("              4 退   出\n");
            System.out.print("              请选择(1-4):");
            char selection = Utility.readMenuSelection();

            switch (selection) {
                case '1':
                    //System.out.println("1 收支明细");
                    System.out.println("=====================================当前收支明细记录=================================");
                    System.out.println("收支\t\t账户金额\t\t收支金额\t\t说明\t\t日期\n");
                    System.out.println(details);
                    System.out.println("---------------------------------------------------------------------------------");
                    break;
                case '2':
                    System.out.print("本次收入金额:");
                    int money = Utility.readNumber();
                    System.out.print("本次收入说明:");
                    String info = Utility.readString();

                    balance += money;
                    Date now1 = new Date();
                    currentTime = df.format(now1);
                    details += ("收入\t\t" + balance + "\t\t+" + money + "\t\t" + info + "\t\t" + currentTime + "\n");
                    System.out.println("-------------本次收入登记完成！--------------\n\n");
                    break;
                case '3':
                    System.out.print("本次支出金额:");
                    int expend = Utility.readNumber();
                    System.out.print("本次支出说明:");
                    String info2 = Utility.readString();
                    if (balance >= expend) {
                        balance -= expend;
                        Date now2 = new Date();
                        currentTime = df.format(now2);
                        details += ("支出\t\t" + balance + "\t\t-" + expend + "\t\t" + info2 + "\t\t" + currentTime + "\n");
                    } else {
                        System.out.println("本次支出超出账户额度，本次支出失败！");
                        Date now3 = new Date();
                        currentTime = df.format(now3);
                        details += ("支出\t\t" + balance + "\t\t-" + expend + "\t\t" + info2 + "(超出余额,失败)" + "\t\t" + currentTime + "\n");
                    }

                    System.out.println("-------------本次支出登记完成！--------------\n\n");
                    break;
                case '4':
                    System.out.print("确认是否退出(Y/N):");
                    char isExit = Utility.readConfirmSelection();
                    if (isExit == 'Y') {
                        isFlag = false;
                    }
                    break;
            }
        }

    }
}

package com.haha.FamilyAccount;

import java.util.Scanner;

public class Utility {
    private static Scanner scanner = new Scanner(System.in);

    //用于界面菜单的选择
    public static char readMenuSelection(){
        char c;
        for (;;){
            String str = readKeyBoard(1);
            c = str.charAt(0);
            if (c != '1'&& c != '2' && c != '3' && c != '4'){
                System.out.print("选择错误，请重新输入：");
            }else break;
        }
        return c;
    }

    //收支金额的输入。不超过4为长度的整数
    public static  int readNumber(){
        int n;
        for(;;){
            String str = readKeyBoard(4);
            try {
                n = Integer.parseInt(str);
                break;
            }catch (NumberFormatException e){
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    //收支说明，不超过8个长度的字符串
    public static String readString(){
        String str = readKeyBoard(8);
        return str;
    }

    //输入”Y“或”N“，并作为方法的返回值
    public static char readConfirmSelection(){
        char c;
        for(;;){
            String str = readKeyBoard(1).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N'){
                break;
            }else {
                System.out.print("选择错误，请重新输入");
            }
        }
        return c;
    }

    private static String readKeyBoard(int limit) {
        String line="";

        while(scanner.hasNext()) {
            line=scanner.nextLine();
            if(line.length()<1||line.length()>limit) {
                System.out.print("输入长度(不大于"+limit+")");
                continue;
            }
            else break;
        }
        return line;
    }
}

教学视频：点击跳转到 bilibili狂神说Java