1.循环跳转

• break: 是用来终止循环的, 循环不再继续执行.

//案例: 打印10次`HelloWorld`,  当打印第五次的时候, 结束循环.
public class BreakDemo01 {
    public static void main(String[] args) {
        System.out.println("start");
        //1. 定义for循环, 打印10次HelloWorld
        for (int i = 1; i <= 10 ; i++) {
            //2.当i等于5的时候, 结束循环
            if (i == 5)
                break;
            System.out.println("Hello World! " + i);
        }
        System.out.println("end");
    }

• continue: 用来结束本次循环, 进行下一次循环的, 循环还会继续执行.

//案例; 打印1~10之间, 所有不是3倍数的整数.
public class ContinueDemo02 {
    public static void main(String[] args) {
        System.out.println("start");
        //1. 通过for循环, 获取1 - 10之间所有的整数
        for (int i = 1; i <= 10; i++) {
            //2. 判断该数字是否是3的倍数.
            if (i % 3 == 0)
                //3. 如果是, 就结束本次循环
                continue;
            //4. 如果不是, 就打印该数字的值.
            System.out.println(i);
        }
        System.out.println("end");
    }
}

2.循环嵌套

所谓的循环嵌套指的是循环结构中还包裹着循环结构, 外边的循环结构叫外循环, 里边的循环结构叫内循环.

循环嵌套用的最多的就是for循环的嵌套, 具体格式如下:

for(初始化条件; 判断条件; 控制条件) {        //外循环, 例如: 5   1      2
   for(初始化条件; 判断条件; 控制条件) {     //内循环, 例如: 3   1,2,3  1,2,3
      //循环体;
   }
}

执行流程

1.外循环执行一次, 内循环执行一圈.
2.循环嵌套的总执行次数 = 外循环的次数 * 内循环的次数.

案例：打印2020年1月至2023年12月之间所有的月份, 格式为: XXXX年XX月

//案例: 打印年月
public class ForForDemo04 {
    public static void main(String[] args) {
        //1. 定义外循环, 控制年份的变化.
        for (int i = 2020; i <= 2023 ; i++) {       //外循环执行一次, 内循环执行一圈.
            System.out.println("start");
            //变量i的取值: 2021, 2022, 2023
            //2. 定义内循环, 控制月份的变化.
            for (int j = 1; j <= 12 ; j++) {
                System.out.print(i + "年" + j + "月\t");
            }
            System.out.println();   //记得加换行
            System.out.println("end\r\n");
        }
    }

3.带标号的循环操作

public class ForForDemo10 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {      //外循环, 控制行.    i的值: 1,   
            for (int j = 1; j <= 5 ; j++) { //内循环, 控制列.    j的值: 1,2,3(整个循环结束)
                if (j == 3) {
                    break;   //这个break, 是用来结束哪个循环呢? 
                }
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

上述的代码, 打印结果是一个5行2列的矩形星星图案, 而我的需求是获取一个1行2列的星星图案, 这就意味着, 上述代码中的break, 只要能直接结束外循环即可.
实际开发中, 为了方便我们操作循环嵌套中的指定循环, 就需要用到带标号的循环操作了.

格式

A: for(初始化条件; 判断条件; 控制条件) {     //外循环
    B: for(初始化条件; 判断条件; 控制条件) { //内循环
        循环体;
    }
}

案例一 ： break用法

优化上述的代码, 改为打印一个1行2列的星星图案

public class ForForDemo10 {
    public static void main(String[] args) {
        A: for (int i = 1; i <= 5; i++) {      //外循环, 控制行.
            B: for (int j = 1; j <= 5 ; j++) { //内循环, 控制列.
                if (j == 3) {
                    break A;   //这个break, 是用来结束哪个循环呢?
                }
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

案例二: continue用法

打印1~100之间所有的质数, 并按照3个一行的形式进行输出.

public class ForForDemo10 {
    public static void main(String[] args) {
        //打印1~100之间所有的质数, 并按照3个一行的形式进行输出.
        //定义变量, 用来记录1-100之间的 质数个数.
        int count = 0;
        //定义变量, 用来记录一行打印几个数.
        int flag = 3;
        a: for (int i = 2; i < 100; i++) {
            for (int j = 2; j < i ; j++) {
                if (i % j == 0) {
                    //走到这里, 说明i不是质数.
                    continue a;
                }
            }
            System.out.print(i + (++count % flag == 0 ? "\r\n" : "\t"));
        }
    }
}

4.生成随机数

• Random类似Scanner，也是Java提供好的API(Application Programming Interface)，内部提供了产生随机数的功能.

1.导入包

import java.util.Random;

2.创建随机数Random对象.

Random r = new Random();

3.调用方法, 产生随机数

int num = r.nextInt(10); //小括号中可以传入任意的正整数
double num = r.nextDouble();  // [0, 1.0)之间的任意小数
boolean num = r.nextBoolean(10); // 生成均等的布尔值

r.setSeed()
public void setSeed(long seed)

该方法的作用是重新设置Random对象中的种子数。
设置完种子数以后的Random对象和相同种子数使用
new关键字创建出的Random对象相同。

随机种子案例：

public class RandomDemo08 {
    public static void main(String[] args) {
        Random random = new Random(666);
//        Random random = new Random(666);
        random.setSeed(666);
        for (int i = 0; i <10 ; i++) {
            System.out.print(" " + random.nextInt(100));

        }
    }
}

解释：
1.小括号中写的整数是生成的随机数的上限.
2.例如: 小括号中写10 , 说明生成0~10之间的随机数, 包含0, 但是不包含10, 即: 包左不包右.
3.小括号中必须传入正整数, 否则会报IllegalArgumentException(非法参数异常).

数组的定义

方式一

• 格式一：

数组存储的数据类型[] 数组名字;
String[] str;

• 方式二
  格式：

数组存储的数据类型 数组名字[];
   String str2[];

数组的动态初始化

• 格式：

 数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
       int[] arr = new int[5];

注意：数组有定长特性，长度一旦指定，不可更改。

数组的静态初始化

//标准格式：
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[]{值1，值2，值3，}
        int[] arr2 = new int[]{1,3,5,7,9};
  //简写形式：
数据类型[] 数组名 = {元素1,元素2,元素3...};
        int[] arr3 = {1, 4, 6, 8};

数组的访问

格式：

数组名[索引]
System.out.println(arr[2]);

• 长度属性， 数组名.length 表示数组中元素的个数;
• 数组的最大索引值为数组名.length-1;

索引访问数组中的元素：

• 数组名[索引]=数值，为数组中的元素赋值
• 变量=数组名[索引]，获取出数组中的元素

public static void main(String[] args) {
    //定义存储int类型数组，赋值元素1，2，3，4，5
    int[] arr = {1,2,3,4,5};
    //为0索引元素赋值为6
    arr[0] = 6;
    //获取数组0索引上的元素
    int i = arr[0];
    System.out.println(i);
    //直接输出数组0索引元素
    System.out.println(arr[0]);
  //数组的遍历，一个一个取出来
        for (int i = 0; i < arr.length ; i++) {
            System.out.println(arr[i]);
}