【Java基础】12.数组

---

前言

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
Java 语言中提供的数组是用来存储固定大小的同类型元素。
你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，…，number99。
本教程将为大家介绍 Java 数组的声明、创建和初始化，并给出其对应的代码。

一、创建数组

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

1. 使用 dataType[arraySize] 创建了一个数组。
2. 把新创建的数组的引用赋值给变量 arrayRefVar。

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

// 方法一
dataType[] arrayRefVar = new dataType[arraySize];
// 方法二
dataType[] arrayRefVar = {value0, value1, ..., valuek};

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。
实例：

public class ArrayDemo1 {
    public static void main(String[] args) {
        // 数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,...}
        // double类型的数组
        double[] scores = new double[]{99.5, 88.0, 75.5};
        double[] scores1 = {99.5, 88.0, 75.5}; // 简化写法

        // int类型的数组
        int[] ages = new int[]{12, 24, 36};
        int[] ages1 = {12, 24, 36}; // 简化写法

        int size = 5; // 设置数组大小是10
        String[] names = new String[size]; // 定义数组
        names[0] = "孙悟空";
        names[1] = "贝吉塔";
        names[2] = "弗利萨";
        names[3] = "沙鲁";
        names[4] = "魔人布欧";
        // 编译不报错，运行报错，因为数组大小是5，这是数组里第6个元素，数组越界ArrayIndexOutOfBoundsException
        // names[5] = "布尔玛";
        // 数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1
        for (int i = 0; i < names.length; i++) {
            System.out.print("索引：" +i + names[i] + " ");
        }

        System.out.println();

        // 数组变量名存储的是数组在内存种的地址，数组是引用类型
        // [ 指的是 数组
        // D 指的是 数据类型double
        // @ 指的是 在哪里
        System.out.println(scores); // [D@776ec8df,指的是数组的十六进制地址
    }
}

编译运行结果如下：

索引：0孙悟空 索引：1贝吉塔 索引：2弗利萨 索引：3沙鲁 索引：4魔人布欧 
[D@16b98e56

二、处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 For-Each 循环。

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] ages = {12, 24, 36, 5, 77};
        //            0   1   2   3  4

        // 1.取值：数组名称[索引]
        System.out.println("ages[0] = " + ages[0]); // ages[0] = 12
        System.out.println("ages[2] = " + ages[2]); // ages[2] = 36

        // 2.赋值：数组名称[索引] = 数据;
        ages[2] = 100; // 索引2的元素改成100，36 -> 100
        System.out.println("ages[0] = " + ages[0]); // ages[0] = 12
        System.out.println("ages[2] = " + ages[2]); // ages[2] = 100

        // 3.数组的长度
        System.out.println("数组长度：" + ages.length); // 数组长度：5

        // 4.最大索引
        System.out.println("最大索引：" + (ages.length - 1)); // 最大索引：4

        // 5.打印所有数组元素
        for (int i = 0; i < ages.length; i++) {
            System.out.print(ages[i] + ",");
        } // 12,24,100,5,77,

        System.out.println();

        // 6.计算所有元素的总和
        double total = 0;
        for (int i = 0; i < ages.length; i++) {
            total += ages[i];
        }
        System.out.println("元素总和：" + total); // 元素总和：218.0

        // 7.查找最大元素
        int max = ages[0];
        for (int i = 1; i < ages.length; i++) {
            if (ages[i] > max) max = ages[i];
        }
        System.out.println("最大的数组：" + max); // 最大的数组：100

    }
}

编译运行结果如下：

ages[0] = 12
ages[2] = 36
ages[0] = 12
ages[2] = 100
数组长度：5
最大索引：4
12,24,100,5,77,
元素总和：218.0
最大的数组：100

三、For-Each 循环/加强型循环

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。
语法：

for(type element: array)
{
    System.out.println(element);
}

实例：

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] ages = {12, 24, 36, 5, 77};
        //            0   1   2   3  4
        // 2.赋值：数组名称[索引] = 数据;
        ages[2] = 100; // 索引2的元素改成100，36 -> 100
        // 8.For-Each 循环,打印所有数组元素
        System.out.println("----For-Each循环----");
        for (int element: ages) {
            System.out.println(element);
        }

    }
}

编译运行结果如下：

----For-Each循环----
12
24
100
5
77

四、数组作为函数的参数

数组可以作为参数传递给方法。

public class ArrayDemo2 {
    public static void main(String[] args) {
        // 9.数组作为函数的参数
        printArray(new int[]{99, 66, 33, 45}); // 99,66,33,45,

    }

    /**
     * 打印int数组的方法
     *
     * @param array
     */
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + ",");
        }
    }

}

编译运行结果如下：

99,66,33,45,

五、数组元素工具类Arrays

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

public class ArraysDemo1 {
    public static void main(String[] args) {
        int[] arr = {10, 2, 55, 23, 24, 100};

        // 返回的是数组的地址
        System.out.println("数组地址：" + arr); // 数组地址：[I@6d311334

        // 1、返回数组内容的toString(数组)
        System.out.println("数组内容：" + Arrays.toString(arr)); // 数组内容：[10, 2, 55, 23, 24, 100]

        // 2、排序的API：sort(默认自动对数组元素进行升序排序)
        Arrays.sort(arr);
        System.out.println("数组排序：" + Arrays.toString(arr)); // 数组排序：[2, 10, 23, 24, 55, 100]

        // 3、二分搜索技术binarySearch（前提数组必须排好序才支持，否则出bug）
        int index = Arrays.binarySearch(arr, 55);
        System.out.println("元素55的索引：" +index); // 元素55的索引：4

        // 4、equals对比(因为数组是引用类型，引用的是数组地址，地址不一样，所以不相等)
        // 所以相对数组内容进行对比，需要重写equals方法
        int[] arr1 = {10, 2, 55};
        System.out.println("数组arr1地址：" + arr1); // 数组arr1地址：[I@568db2f2
        int[] arr2 = {10, 2, 55};
        System.out.println("数组arr2地址：" + arr2); // 数组arr2地址：[I@378bf509
        boolean rs = arr1.equals(arr2);
        System.out.println("没重写equals方法时数组比较：" + rs); // 没重写equals方法时数组比较：false
    }

}

编译运行结果如下：

数组地址：[I@6d311334
数组内容：[10, 2, 55, 23, 24, 100]
数组排序：[2, 10, 23, 24, 55, 100]
元素55的索引：4
数组arr1地址：[I@568db2f2
数组arr2地址：[I@378bf509
没重写equals方法时数组比较：false