第20章 数组的常见操作

作者：张子默

一、数组越界异常

运行如下程序会出现什么结果。

public static void main(String[] args) {
    int[] arr = {1,2,3};
    System.out.println(arr[3]);
}
1
2
3
4

创建数组，赋值3个元素，数组的索引就是0、1、2没有3索引，因此我们不能访问数组中不存在的索引，程序运行后，将抛出ArrayIndexOutOfBoundsException数组越界异常。在开发中，数组越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

二、数组空指针异常

运行如下程序会出现什么结果。

public static void main(String[] args) {
    int[] arr = {1,2,3};
    arr = null;
    System.out.println(arr[0]);
｝
1
2
3
4
5

arr = null这行代码，意味着变量arr将不会再保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出NullPointerException空指针异常。在开发中，数组越的空指针异常是不能出现的，一旦出现了就必须要修改我们编写的代码。

空指针异常在内存图中的表现

三、遍历数组

数组遍历就是将数组中的元素分别获取出来。遍历也是数组操作中的基石。

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    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]);
}
1
2
3
4
5
6
7
8

以上代码是可以将数组中的每个元素全部遍历出来，但是如果数组元素非常多，这种写法肯定不行，因此我们需要修改造成循环的写法。数组索引是0到length-1，可以作为循环的条件出现。

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
    }
}
1
2
3
4
5
6

四、数组获取最大元素值

1、最大值获取

从数组的所有元素中找出最大值。

2、实现思路

• 定义变量，保存数组0索引上的元素
• 遍历数组，获取出数组中的每个元素
• 将遍历到的元素和保存数组0索引上值的变量进行比较
• 如果数组元素的值大于了变量的值，变量记录住新的值
• 数组循环遍历结束，变量保存的就是数组中的最大值
  

public static void main(String[] args) {
    int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
    //定义变量，保存数组中0索引的元素
    int max = arr[0];
    //遍历数组，取出每个元素
    for (int i = 0; i < arr.length; i++) {
        //遍历到的元素和变量max比较
        //如果数组元素大于max
        if (arr[i] > max) {
            //max记录住大值
            max = arr[i];
        }
    }
    System.out.println("数组最大值是： " + max);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

五、数组反转

数组反转，即数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1

实现思想

数组最远端的元素互换位置。

• 实现反转，就是要将数组最远端元素位置交换
• 定义两个变量，保存数组的最小索引和最大索引
• 两个索引上的元素交换位置
• 最小索引++，最大索引–，再次交换位置
• 最小索引超过了最大索引，数组反转操作结束
  

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    /*
    循环中定义变量min=0最小索引
    max=arr.length‐1最大索引
    min++,max‐‐
    */
    for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) {
        //利用第三方变量完成数组中的元素交换
        int temp = arr[min];
        arr[min] = arr[max];
        arr[max] = temp;
    }
    // 反转后，遍历数组
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

六、实例

• 数组越界异常

package com.zzm.day05.demo03;

/**
 * 用途：
 * 时间：2021/5/20 13:44
 * 创建人：张子默
 */

/*
数组的索引从0开始，一直到"数组的长度-1"为止。

如果访问数组元素的时候，索引元素并不存在，那么将会发生数组索引越界异常：ArrayIndexOutOfBoundsException
原因：索引编号写错了。
解决：修改成为存在的正确索引编号。
 */
public class Demo01ArrayIndex {

    public static void main(String[] args) {
        int[] array = {15, 25, 35};
        System.out.println(array[0]); // 15
        System.out.println(array[1]); // 25
        System.out.println(array[2]); // 35

        // 错误写法
        // 并不存在3号元素，所以发生异常
        System.out.println(array[3]); // 35
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

• 空指针异常

package com.zzm.day05.demo03;

/**
 * 用途：
 * 时间：2021/5/20 16:32
 * 创建人：张子默
 */

/*
所有的引用类型变量，都可以赋值为一个null值。但是代表其中什么都没有。

数组必须进行new初始化才能使用其中的元素，如果只是赋了一个null，没有进行new创建，那么将会发生空指针异常：NullPointerException
原因：忘了new
解决：补上new
 */
public class Demo02ArrayNull {

    public static void main(String[] args) {
        int[] array = null;
        // array = new int[3];
        System.out.println(array[0]);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• 获取数组长度

package com.zzm.day05.demo03;

/**
 * 用途：
 * 时间：2021/5/20 16:41
 * 创建人：张子默
 */

/*
如何获取数组的长度，格式：
    数组名称.length

这将会得到一个int数字，代表数组的长度。

数组一旦创建，程序运行期间，长度不可改变。
 */
public class Demo03ArrayLength {

    public static void main(String[] args) {
        int[] arrayA = new int[3];

        int[] arrayB = {10, 20, 30, 3, 5, 2, 4, 6, 7};

        int len = arrayB.length;
        System.out.println("arrayB数组的长度是：" + len);
        System.out.println("===============");

        int[] arrayC = new int[3];
        System.out.println(arrayC.length); // 3
        arrayC = new int[5];
        System.out.println(arrayC.length); // 5
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

• 数组遍历

package com.zzm.day05.demo03;

/**
 * 用途：
 * 时间：2021/5/20 16:51
 * 创建人：张子默
 */

/*
遍历数组：说的就是对数组当中的每一个元素进行逐一、挨个儿的处理。默认处理方式就是打印输出。
 */
public class Demo04Array {

    public static void main(String[] args) {
        int[] array = {15, 25, 30, 40, 50, 60, 75};

        // 首次使用原始方式
        System.out.println(array[0]); // 15
        System.out.println(array[1]); // 25
        System.out.println(array[2]); // 30
        System.out.println(array[3]); // 40
        System.out.println(array[4]); // 50
        System.out.println(array[5]); // 60
        System.out.println("===============");

        // 使用循环，次数其实就是数组的长度。
        for (int i = 0; i < 6; i++) {
            System.out.println(array[i]);
        }
        System.out.println("===============");

        // int len = array.length;
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

• 获取数组最大值

package com.zzm.day05.demo03;

/**
 * 用途：
 * 时间：2021/5/20 17:13
 * 创建人：张子默
 */
public class Demo05ArrayMax {

    public static void main(String[] args) {
        int[] array = {5, 15, 30, 20, 10000};

        int max = array[0]; // 比武擂台
        for (int i = 1; i < array.length; i++) {
            // 如果当前元素比max更大，则换人
            if (max < array[i]) {
                max = array[i];
            }
        }
        // 谁最后最厉害，就能在max当中留下谁的战斗力
        System.out.println("最大值：" + max);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• 获取数组最小值

package com.zzm.day05.demo03;

/**
 * 用途：
 * 时间：2021/5/20 17:13
 * 创建人：张子默
 */
public class Demo06ArrayMin {

    public static void main(String[] args) {
        int[] array = {5, 15, 30, 20, 10000};

        int min = array[0]; // 比武擂台
        for (int i = 1; i < array.length; i++) {
            // 如果当前元素比min更小，则换人
            if (min > array[i]) {
                min = array[i];
            }
        }
        System.out.println("最小值：" + min);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• 数组反转

package com.zzm.day05.demo03;

/**
 * 用途：
 * 时间：2021/5/20 17:24
 * 创建人：张子默
 */

/*
数组元素的反转：
本来的样子：[1, 2, 3, 4]
之后的样子：[4, 3, 2, 1]

要求不能使用新数组，就用原来的唯一一个数组。
 */
public class Demo07ArrayReverse {

    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};

        // 遍历打印数组本来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("===============");

        /*
        初始化语句：int min = 0, max = array.length-1
        条件判断：min < max
        步进表达式：min++, max--
        循环体：用第三个变量倒手
         */
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }

        // 再次遍历打印输出数组后来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45