DAY08_数组&一维数组&二维数组

最新推荐文章于 2024-07-21 22:27:18 发布

_-Mr-sun

最新推荐文章于 2024-07-21 22:27:18 发布

阅读量70

点赞数

分类专栏： 1.JavaSE基础文章标签： java

本文链接：https://blog.csdn.net/m0_57075290/article/details/128994090

版权

1.JavaSE基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1 一维数组

1.1 数组概述

那什么是数组呢？为了帮助大家理解，这里我们来看这样的一个场景：
在这里插入图片描述
看这里，有一个学员的考试成绩，为了存储这个学员的考试成绩，我们可以采用一个变量进行存储。但是，假如这里有很多个学员的考试成绩，我们要存储该怎么办呢？

采用多个变量存储不就行了吗。对，想的没错。确实可以采用多个变量进行存储，只不过将来要对这多个变量进行操作就比较麻烦了，比如说：找到成绩最高的学员。按照我们学过的获取两个数的较大值，需要编写大量的判断逻辑才能完成这个操作。很明显，采用多个变量存储不是好的解决方案。
目前出现的问题是：
1：一次性声明大量的用于存储数据的变量，
2：要存储的数据通常都是同类型数据，例如：考试成绩。
为了解决这种大量的同类型的数据存储，Java就提供了数组供我们使用。
比如说：下面这种格式，就是定义了一个存储多个考试成绩的数组。

int[] scores = {100,100,100,100,100,100,100…};

对比一下，比定义多个变量要方便多了，而且操作起来也是很方便的。

数组(array)： 是一种用于存储多个相同数据类型的存储模型(可以理解为容器)。

1.2 数组定义

数组有两种定义格式：

格式1： 数据类型[] 变量名;
- 范例： int[] arr;
- 定义了一个int类型的数组，数组名是arr
格式2： 数据类型变量名[];
- 范例： int arr[];
- 定义了一个int类型的变量，变量名是arr数组

这两种格式在使用上是没有区别的，但是在阅读的时候是有一个小区别的？
格式1：定义了一个int类型的数组，数组名是arr；
格式2：定义了一个int类型的变量，变量名是arr数组

格式1明确告诉我们定义的是一个数组，所以在定义数组的时候推荐使用格式1

1.3 数组初始化----静态初始化

所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值
注意：数组中的每一个数据，我们称之为数组中的元素

数组初始化分为两种方式：

静态初始化和动态初始化

定义数组但是数组中没有数据。必须先初始化然后才能使用。

静态初始化： 初始化时指定每个数组元素的初始值，由系统决定数组长度
格式： 数据类型[] 变量名 = new 数据类型[]{数据1,数据2,数据3,…};
- 范例： int[] arr = new int[]{1,2,3};

Java提供了一种简化的格式:

简化格式： 数据类型[] 变量名 = {数据1,数据2,数据3,…};
- 范例： int[] arr = {1,2,3};

1.4 数组元素访问(获取和修改)

数组变量的访问方式
- 格式：数组名

我们可以通过输出语句，输出数组名，就能够得到一个数据。

数组内部保存的数据的访问方式
- 格式：数组名[索引]

索引是什么呢？我们来看一下这样的一个场景：

索引是数组中数据的编号方式
作用：用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名
它还有这样的几个特征：
- 特征①：索引从0开始
- 特征②：索引是连续的
- 特征③：索引逐一增加，每次加1

/*
数组变量访问方式
格式：数组名
数组内部保存的数据的访问方式
格式：数组名[索引]
*/
public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组，并进行初始化
        // int[] scores = new int[]{93,96,99};
        int[] scores = {93, 96, 99};
        //输出数组名
        System.out.println(scores); //[I@1b6d3586
        //输出数组中的元素
        System.out.println(scores[0]);
        System.out.println(scores[1]);
        System.out.println(scores[2]);
        System.out.println("-----------");
        //修改数组中的元素
        scores[0] = 100;
        scores[1] = 98;
        scores[2] = 95;
        //再次输出数组中的元素
        System.out.println(scores[0]);
        System.out.println(scores[1]);
        System.out.println(scores[2]);
    }
}

1.5 案例1(数组常见操作之遍历)

什么是数组遍历：
- 获取数组中的每一个元素，我们可以把获取到的元素输出在控制台
获取数组长度(元素个数)：
- 格式： 数组名.length
  - 范例： arr.length
数组遍历通用格式：

注意：
数组遍历指的是把数组中的元素取出来，取出来之后可以(打印，求和，判断…)
数组遍历通用格式： for (int i = 0; i < scores.length; i++) { scores[i] }
选择哪种操作，得根据我们的实际需求来看。

/*
遍历
*/
public class ArrayTest01 {
    public static void main(String[] args) {
        //定义数组并初始化
        int[] arr = {77, 88, 99, 66, 55, 44};
        //获取数组中的元素
        // System.out.println(arr[0]);
        // System.out.println(arr[1]);
        // System.out.println(arr[2]);
        // System.out.println(arr[3]);
        // System.out.println(arr[4]);
        // System.out.println(arr[5]);
        //用循环改进
        // for (int i=0; i<5; i++) {
        // System.out.println(arr[i]);
        // }
        //格式：数组名.length
        // System.out.println(arr.length);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

1.6 案例2(数组常见操作之获取最大值)

先通过一个场景，让大家对最值有一个认知
这是一组家庭成员：
在这里插入图片描述
给出一组数据，这些数据表示的是他们的年龄。68是最大年龄，4是最小年龄，所以，68和4就可以被称之为值。

再给出一组数据，这些数据表示的是他们的身高，171是最高身高，81是最低身高，所以，171和81就可以被称之为最值。
在这里插入图片描述
我们需要进行比较，我们采用数组把这些数据给保存起来。这些数据从头到尾比较了一遍，最终找到了最高身高171。
知道了大量同类型数据用数组保存和最值的知识后，我们来看一下我们的需求：

我这里有一个数组，我现在要获取数组中的最大值

如何实现呢？思路：

因为我们最终要得到最大值，所以我们定义一个变量用于保存最大值。但是它没有初始值，总不能拿数组以外的数据进来，所以我们就要从数组中找一个值作为初始值。一般来说我们取数组中第一个元素作为参照值。
这样我们的最大值变量就有初始值了，接下来我们与数组中剩余的数据逐个比较，比完之后，max中最终保存的是最大值。获取索引1-4，因为0索引位置的值已经作为初始值了。
我们每次比较，需要把最大值保存到max变量中，可以通过if语句实现。
当循环结束后，这个max里面保存的就是最大值。

/*
获取最大值
*/
public class ArrayTest02 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {12, 45, 98, 73, 60};
        //定义变量max存储最大值，取第一个数据为变量的初始值
        int max = arr[0];
        //与数组中剩余数据逐个比对，每次比对将最大值保存到变量max中
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        //循环结束后输出变量max的值
        System.out.println("max:" + max);
    }
}

1.7 案例3(数组常见操作之元素打乱)

那什么是元素打乱呢？

元素打乱就是把数组中的元素随机交换位置，每次运行都可能产生不一样的结果
比如：arr = {12, 45, 98, 73, 60};

遍历：

正常情况下：12,45,98,73,60
元素打乱后：45,73,12,60,98

涉及到的操作：

获取数组中元素的随机索引
- Random r = new Random();
- int index = r.nextInt(arr.length);
数组中元素交换

通过场景来理解数据交换：
把啤酒杯和红酒杯里面的酒进行交换
在这里插入图片描述
第一步：找来一个同类型的空酒杯

第二步：把红酒倒入到空酒杯中

第三步：把啤酒倒入到曾经装红酒的杯子中

第四步：把红酒从临时找来的杯子中倒入到曾经装啤酒的杯子中

这样我们就实现了啤酒杯和红酒杯里面的酒进行交换。这种思想同样也适合我们程序中的数据交换。

/*
数据交换
*/
public class DataSwap {
    public static void main(String[] args) {
        // int a = 10;
        // int b = 20;
        // System.out.println("交换前：a=" + a + ",b=" + b);
        // int temp = a;
        // a = b;
        // b = temp;
        // System.out.println("交换后：a=" + a + ",b=" + b);
        int[] arr = {11, 22, 33, 44, 55};
        System.out.println("交换前：arr[0]=" + arr[0] + ",arr[4]=" + arr[4]);
        int temp = arr[0];
        arr[0] = arr[4];
        arr[4] = temp;
        System.out.println("交换后：arr[0]=" + arr[0] + ",arr[4]=" + arr[4]);
    }
}

数据的交换演示完毕后，下面我们就可以来实现把数组中的元素打乱了：

import java.util.Random;
import java.util.Random;

/*
元素打乱
*/
public class ArrayTest03 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {12, 45, 98, 73, 60};
        // Random r = new Random();
        // int index = r.nextInt(arr.length);
        //
        // //第一次交换
        // int temp = arr[0];
        // arr[0] = arr[index];
        // arr[index] = temp;
        //
        // //第二次交换
        // index = r.nextInt(arr.length);
        // temp = arr[1];
        // arr[1] = arr[index];
        // arr[index] = temp;
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            int index = r.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

1.8 数组初始化----动态初始化

静态初始化：也就是初始化时指定每个数组元素的初始值。
动态初始化：初始化时只指定数组长度由系统为数组分配初始值。

格式： 数据类型[] 变量名 = new 数据类型[数组长度];
- 范例： int[] arr = new int[3];
  - 表示我们定义了一个int类型的数组，初始化为3个元素

/*
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 变量名 = new 数据类型[数组长度];
范例：int[] arr = new int[3];
*/
public class ArrayDemo {
    public static void main(String[] args) {
        //格式：数据类型[] 变量名 = new 数据类型[数组长度];
        int[] arr = new int[3];
        //输出数组名
        System.out.println(arr); //[I@1b6d3586
        //输出数组中的元素
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//0
        System.out.println("------------");
        //修改数组中的元素
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        //再次输出数组中的元素
        System.out.println(arr[0]);//10
        System.out.println(arr[1]);//20
        System.out.println(arr[2]);//30
    }
}

总结一下数组初始化的两种方式的各自使用场景：

静态初始化： 开始就存入元素值，适合一开始就能确定元素值的业务场景
动态初始化： 指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景
注意： 两种初始化的方式是独立的，不可以混用

1.9 案例4(数组元来自键盘录入)

需求：定义一个可以存储5个元素的int数组，数据来自于键盘录入，最后遍历数组，把元素输出在控制台
分析：
这个数组可以存储5个int类型的元素，但是数据来自于键盘录入，也就是先指定数组长度，后期赋值。
这很明显适合使用数组的动态初始化，所以，这里我们将采用动态初始化对数组进行初始化。
接着，数据来自于键盘录入，我们得知道这里要使用Scanner来实现。

import java.util.Scanner;

/*
需求：定义一个可以存储5个元素的int数组，数据来自于键盘录入，最后遍历数组，把元素输出在控制台
*/
public class ArrayTest {
    public static void main(String[] args) {
        //定义一个数组，并进行动态初始化
        int[] arr = new int[5];
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        // //录入第1个数据
        // System.out.println("请输入第1个数据：");
         int i = sc.nextInt();
         arr[0] = i;
        // arr[0] = sc.nextInt();
        //
        // //录入第2个数据
        // System.out.println("请输入第2个数据：");
        // arr[1] = sc.nextInt();
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个元素：");
            arr[i] = sc.nextInt();
        }
        printArray(arr);
        //输出内容并换行
        // System.out.println("hello");
        // System.out.println("world");
        //输出内容不换行
        // System.out.print("hello");
        // System.out.print("world");
    }

    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
        System.out.println("]");
    }
    /*
    参数：int[] arr
    返回值：void
    */
    // public static void printArray(int[] arr) {
    // for (int i = 0; i < arr.length; i++) {
    // System.out.println(arr[i]);
    // }
    // }
}

我们讲到了一个新的输出语句：System.out.print()，它只输出内容，不换行。
而以前我们使用的输出语句System.out.println()，它只输出内容且换行。

1.10 数组内存图

在这里插入图片描述

/*
数组内存图代码
*/
public class ArrayTest01 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        //输出数组名及元素
        System.out.println(arr);//[I@1b6d3586
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//0
        //给数组中的元素赋值
        arr[0] = 100;
        arr[2] = 200;
        //再次输出数组名及元素
        System.out.println(arr);//[I@1b6d3586
        System.out.println(arr[0]);//100
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//200
    }
}

1.11 数组使用中的两个小问题

第一个问题：

通过内存图进行讲解：

结论：
访问了不存在的索引位置元素，正确的索引范围(0~数组长度-1)
第二个问题：

通过内存图进行讲解：

结论：
对象设置为null，不在指向堆内存数据了，对象在使用前，进行不为null的判断

/*
数组使用中的两个小问题
1：索引越界：访问了数组中不存在的索引对应的元素，造成索引越界问题
ArrayIndexOutOfBoundsException
2：空指针异常：对象不再指向堆内存，还想继续访问数据，访问失败
NullPointerException
null：空值，引用数据类型的默认值，表示不指向任何有效对象
*/
public class ArrayTest02 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        //输出元素
        //Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out ofbounds for length 3
        // System.out.println(arr[3]);
        System.out.println(arr[2]);
        //把null赋值给arr
        arr = null;
        //输出元素
        //Exception in thread "main" java.lang.NullPointerException: Cannot load from intarray because "arr" is null
        if (arr != null) {
            System.out.println(arr[0]);
        }
    }
}

2 二维数组

2.1 二维数组概述

来看这样的一个场景：
我们要存储多个班级的学生的考试成绩，该怎么办呢？
如果要存储一个班级中多个学生的考试成绩，我们就可以采用数组来存储。
现在的问题是多个班级的考试成绩，我们针对每个班级都采用数组存储。
第一个班级：数组1
第二个班级：数组2
第三个班级：数组3 …
但是多个班级，也可以采用数组存储。
所以，Java就提供了二维数组供我们使用。

二维数组定义：
- 二维数组：元素为一维数组的数组
二维数组的定义格式：
- 数据类型[] [] 变量名; int[] [] arr; 推荐使用
- 数据类型变量名[] []; int arr[] [];
- 数据类型[] 变量名[]; int[] arr[];

2.2 二维数组初始化

二维数组初始化也有两种格式：
- 静态初始化
- 动态初始化
静态初始化：
- 格式： 数据类型[] [] 变量名 = new 数据类型[] []{{元素…},{元素…},{元素…},…};
- 范例： int[] [] arr = new int[] []{{1,2,3},{4,5,6},{7,8,9}};
  - 解读：
    - 定义了一个二维数组
    - 二维数组中有三个元素(一维数组)
    - 每一个一维数组有三个元素(int类型数据)
    - 注意：一维数组中元素的个位可以是不同的
    - 比如： int[] [] arr = new int[] []{{1,2,3},{4,5},{6,7,8,9}};
- 同样，针对静态初始化，二维数组也给出了简化格式：
  - 简化格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…},…};
  - 范例：int[] [] arr = {{1,2,3},{4,5,6},{7,8,9}};
动态初始化：
- 格式： 数据类型[] [] 变量名 = new 数据类型[m] [n];
- 范例： int[] [] arr = new int[2] [3];
  - 解读：
    - 定义了一个二维数组
    - 二维数组中有2个元素(一维数组)
    - 每一个一维数组有3个元素(int类型数据)
各自使用场景和一维数组中是一样的：
- 静态初始化：适合一开始就能确定元素值的业务场景
- 动态初始化：适合开始知道数据的数量，但是不确定具体元素值的业务场景

2.3 二维数组元素访问

获取二维数组：
- 数组名
获取每一个一维数组：
- 数组名[索引]
获取每一个二维数组元素：
- 数组名[索引] [索引]

/*
静态初始化简化格式：数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
*/
public class ArrayDemo {
    public static void main(String[] args) {
        //静态初始化简化格式：数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
        int[][] arr = {{1, 2, 3}, {4, 5, 6}};
        //输出数组名
        System.out.println(arr); //[[I@1b6d3586
        System.out.println(arr[0]); //[I@4554617c
        System.out.println(arr[1]); //[I@74a14482
        //如何获取到数据1,2,3呢？
        System.out.println(arr[0][0]);//1
        System.out.println(arr[0][1]);//2
        System.out.println(arr[0][2]);//3
        System.out.println(arr[1][0]);//4
        System.out.println(arr[1][1]);//5
        System.out.println(arr[1][2]);//6
    }
}

2.4 二维数组内存图

在这里插入图片描述

/*
二维数组内存图代码
*/
public class ArrayTest {
    public static void main(String[] args) {
        //定义二维数组
        int[][] arr = {{1, 2, 3}, {4, 5, 6}};
        //输出数组中的元素
        System.out.println(arr[0][1]);//2
        System.out.println(arr[1][1]);//5
        System.out.println(arr);//[[I@1b6d3586
        //修改数组中的元素
        arr[0][1] = 10;
        arr[1][1] = 20;
        //再次输出数组中的元素
        System.out.println(arr[0][1]);//10
        System.out.println(arr[1][1]);//20
        System.out.println(arr);//[[I@1b6d3586
    }
}

2.5 案例5(二维数组常见操作之遍历)

/*
需求：已知一个二维数组 arr = {{1,2,3},{4,5,6},{7,8,9}}; 请把元素在控制台输出
*/
public class ArrayTest01 {
    public static void main(String[] args) {
        //定义二维数组，并进行静态初始化
        int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        //获取数据1,2,3
        // System.out.println(arr[0][0]);
        // System.out.println(arr[0][1]);
        // System.out.println(arr[0][2]);
        // for (int i = 0; i < arr[0].length; i++) {
        // System.out.println(arr[0][i]);
        // }
        //
        // //获取数据4,5,6
         System.out.println(arr[1][0]);
         System.out.println(arr[1][1]);
         System.out.println(arr[1][2]);
        // for (int i = 0; i < arr[1].length; i++) {
        // System.out.println(arr[1][i]);
        // }
        //
        // //获取数据7,8,9
         System.out.println(arr[2][0]);
         System.out.println(arr[2][1]);
         System.out.println(arr[2][2]);
        // for (int i = 0; i < arr[2].length; i++) {
        // System.out.println(arr[2][i]);
        // }
        for (int i = 0; i < arr.length; i++) {
            //arr[i]
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

循环嵌套：
- for循环的语句体是循环语句，这种现象被称为循环嵌套。
总结：
- 在实现的过程中，我们在二维数组中使用了循环嵌套：
- ① 循环嵌套：循环语句中嵌套循环语句
- ② 通过外层循环可以得到一维数组
- ③ 在通过内存循环可以得到每一个二维数组元素

2.6 案例6(二维数组常见操作之元素打乱)

这里的思路和前面是一样的，也是要随机产生二维数组中元素的索引，并进行元素交换。
二维数组元素的索引是两个值，所以，这里要产生两个随机数。

import java.util.Random;

/*
需求：已知二维数组 arr = {{1,2,3},{4,5,6},{7,8,9}};用程序实现把数组中的元素打乱,并在控制台输出打乱后
的数组元素
*/
public class ArrayTest02 {
    public static void main(String[] args) {
        //定义二维数组，并进行静态初始化
        int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        //创建随机数对象
        Random r = new Random();
        //遍历二维数组，进行元素打乱
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                //arr[i][j]
                int x = r.nextInt(arr.length);
                int y = r.nextInt(arr[x].length);
                //元素交换
                int temp = arr[i][j];
                arr[i][j] = arr[x][y];
                arr[x][y] = temp;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

2.7 案例7(图片展示)

在这里插入图片描述
图片放在该位置：

import javax.swing.*;

/*
图片展示
*/
public class ArrayTest03 {
    public static void main(String[] args) {
        //创建窗体对象
        JFrame jf = new JFrame();
        jf.setTitle("图片展示");
        jf.setSize(380, 400);
        jf.setDefaultCloseOperation(3);
        jf.setLocationRelativeTo(null);
        jf.setAlwaysOnTop(true);
        jf.setLayout(null);
        // JLabel jLabel1 = new JLabel(new ImageIcon("itheima-array2\\images\\1.png"));
        // jLabel1.setBounds(0, 0, 90, 90);
        // jf.add(jLabel1);
        // JLabel jLabel2 = new JLabel(new ImageIcon("itheima-array2\\images\\2.png"));
        // jLabel2.setBounds(90, 0, 90, 90);
        // jf.add(jLabel2);
        // JLabel jLabel3 = new JLabel(new ImageIcon("itheima-array2\\images\\3.png"));
        // jLabel3.setBounds(180, 0, 90, 90);
        // jf.add(jLabel3);
        // JLabel jLabel4 = new JLabel(new ImageIcon("itheima-array2\\images\\4.png"));
        // jLabel4.setBounds(270, 0, 90, 90);
        // jf.add(jLabel4);

        // for (int i=0; i<4; i++) {
        // JLabel jLabel = new JLabel(new ImageIcon("itheima-array2\\images\\"+(i + 1) + ".png"));
        // jLabel.setBounds(i*90,0,90,90);
        // jf.add(jLabel);
        // }

        // JLabel jLabel5 = new JLabel(new ImageIcon("itheima-array2\\images\\5.png"));
        // jLabel5.setBounds(0, 90, 90, 90);
        // jf.add(jLabel5);
        // JLabel jLabel6 = new JLabel(new ImageIcon("itheima-array2\\images\\6.png"));
        // jLabel6.setBounds(90, 90, 90, 90);
        // jf.add(jLabel6);
        // JLabel jLabel7 = new JLabel(new ImageIcon("itheima-array2\\images\\7.png"));
        // jLabel7.setBounds(180, 90, 90, 90);
        // jf.add(jLabel7);
        // JLabel jLabel8 = new JLabel(new ImageIcon("itheima-array2\\images\\8.png"));
        // jLabel8.setBounds(270, 90, 90, 90);
        // jf.add(jLabel8);

        // for (int i=0; i<4; i++) {
        // JLabel jLabel = new JLabel(new ImageIcon("itheima-array2\\images\\"+(i + 5) + ".png"));
        // jLabel.setBounds(i*90,90,90,90);
        // jf.add(jLabel);
        // }

        // JLabel jLabel9 = new JLabel(new ImageIcon("itheima-array2\\images\\9.png"));
        // jLabel9.setBounds(0, 180, 90, 90);
        // jf.add(jLabel9);
        // JLabel jLabel10 = new JLabel(new ImageIcon("itheima-array2\\images\\10.png"));
        // jLabel10.setBounds(90, 180, 90, 90);
        // jf.add(jLabel10);
        // JLabel jLabel11 = new JLabel(new ImageIcon("itheima-array2\\images\\11.png"));
        // jLabel11.setBounds(180, 180, 90, 90);
        // jf.add(jLabel11);
        // JLabel jLabel12 = new JLabel(new ImageIcon("itheima-array2\\images\\12.png"));
        // jLabel12.setBounds(270, 180, 90, 90);
        // jf.add(jLabel12);

        // for (int i=0; i<4; i++) {
        // JLabel jLabel = new JLabel(new ImageIcon("itheima-array2\\images\\"+(i + 9) + ".png"));
        // jLabel.setBounds(i*90,180,90,90);
        // jf.add(jLabel);
        // }

        // JLabel jLabel13 = new JLabel(new ImageIcon("itheima-array2\\images\\13.png"));
        // jLabel13.setBounds(0, 270, 90, 90);
        // jf.add(jLabel13);
        // JLabel jLabel14 = new JLabel(new ImageIcon("itheima-array2\\images\\14.png"));
        // jLabel14.setBounds(90, 270, 90, 90);
        // jf.add(jLabel14);
        // JLabel jLabel15 = new JLabel(new ImageIcon("itheima-array2\\images\\15.png"));
        // jLabel15.setBounds(180, 270, 90, 90);
        // jf.add(jLabel15);
        // JLabel jLabel16 = new JLabel(new ImageIcon("itheima-array2\\images\\16.png"));
        // jLabel16.setBounds(270, 270, 90, 90);
        // jf.add(jLabel16);

        // for (int i=0; i<4; i++) {
        // JLabel jLabel = new JLabel(new ImageIcon("itheima-array2\\images\\"+(i + 13) + ".png"));
        // jLabel.setBounds(i*90,270,90,90);
        // jf.add(jLabel);
        // }

        //定义图片编号的数组
        int[][] datas = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12},
                {13, 14, 15, 16}
        };
        for (int i = 0; i < datas.length; i++) {
            for (int j = 0; j < datas[i].length; j++) {
                //datas[i][j]
                JLabel jLabel = new JLabel(new ImageIcon("itheima-array2\\images\\" + datas[i][j] + ".png"));
                jLabel.setBounds(j * 90, i * 90, 90, 90);
                jf.add(jLabel);
            }
        }
        jf.setVisible(true);
    }
}

总结：
首先我们是一张张的展示图片，简化代码后通过二维数组的方式改进了图片的存储。

2.8 案例8(图片打乱)

import javax.swing.*;
import java.util.Random;

/*
图片打乱
*/
public class ArrayTest04 {
    public static void main(String[] args) {
        //创建窗体对象
        JFrame jf = new JFrame();
        jf.setTitle("图片打乱");
        jf.setSize(380, 400);
        jf.setDefaultCloseOperation(3);
        jf.setLocationRelativeTo(null);
        jf.setAlwaysOnTop(true);
        jf.setLayout(null);
        //图片打乱
        int[][] datas = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12},
                {13, 14, 15, 16}
        };
        Random r = new Random();
        for (int i = 0; i < datas.length; i++) {
            for (int j = 0; j < datas[i].length; j++) {
                int x = r.nextInt(datas.length);
                int y = r.nextInt(datas[x].length);
                int temp = datas[i][j];
                datas[i][j] = datas[x][y];
                datas[x][y] = temp;
            }
        }
        for (int i = 0; i < datas.length; i++) {
            for (int j = 0; j < datas[i].length; j++) {
                JLabel jLabel = new JLabel(new ImageIcon("itheima-array2\\images\\" + datas[i][j] + ".png"));
                jLabel.setBounds(j * 90, i * 90, 90, 90);
                jf.add(jLabel);
            }
        }
        jf.setVisible(true);
    }
}