深入理解 Java 基本语法之数组

目录

一、数组基础概念

二、数组的声明

1. 基本数据类型数组声明：

2. 引用数据类型数组声明：

三、数组的创建

四、数组的初始化

五、数组的使用

​编辑1. 获取长度以及访问元素：

2. 数组作为方法的参数：

3. 数组作为方法的返回值：

六、多维数组

1. 二维数组的声明和初始化

2. 调用数组的指定位置的元素

3. 获取数组的长度

4. 遍历二维数组

5. 二维数组元素的默认初始化值

七、Arrays 类

1. 判断两个数组是否相等

2. 输出数组信息

3. 将指定值填充到数组之中

4. 对数组进行排序

5. 对排序后的数组进行二分法检索指定的值

八、数组的常见应用场景        ​编辑

---

一、数组基础概念

数组是同一种类型数据的集合，是一种容器，能给存储进来的元素自动进行编号，编号从 0 开始。数组有以下特点：

长度确定且不可变。一旦数组被初始化，其长度就不能再改变。例如在 Java 中，定义一个整型数组int[] arr = new int[5];，这个数组的长度就是 5，不能在后续的代码中增加或减少这个数组的长度。元素必须是相同类型。Java 中的数组要求数组中的元素类型统一，不能存储不同类型的元素。例如不能在一个整型数组中存储字符串类型的数据。数组变量属引用类型，数组本身也是对象，在堆中分配空间。Java 语言中的数组是一种引用类型，不属于基本数据类型。数组的父类是 Object。数组实际上是一个容器，可以同时容纳多个元素。数组因为是引用类型，所以数组对象是在堆内存当中。数组当中如果存储的是 “Java 对象” 的话，实际上存储的是对象的 “引用（内存地址）”。

二、数组的声明

数组在 Java 中有多种声明方式，主要分为基本数据类型数组声明和引用数据类型数组声明。

1. 基本数据类型数组声明：

        基本数据类型数组可以使用int[] i或int i[]的方式进行声明。例如，声明一个整型数组可以写为int[] numbers或int numbers[]。Java 中更推荐使用int[] numbers这种方式，因为它具有更好的可读性。

2. 引用数据类型数组声明：

        引用数据类型数组可以使用Car[] c或Car c[]的方式进行声明，在 Java 中推荐用Car[] c。比如，如果有一个自定义的类Person，声明一个Person类型的数组可以写为Person[] people。引用数据类型的数组在声明后也需要进行初始化才能使用。初始化的方式可以是静态初始化或动态初始化。例如，静态初始化可以这样写：Person[] people = new Person[]{new Person("张三", 1), new Person("李四", 2)}；动态初始化可以这样写：Person[] people = new Person[3]，然后再通过给每个元素赋值的方式进行初始化，如people[0] = new Person("王五", 3)。

三、数组的创建

数组在 Java 中有多种创建方式，下面分别介绍基本数据类型数组和引用数据类型数组的创建方法。

创建基本数据类型数组：可以使用int[] i = new int[2];的方式创建一个整型基本数据类型数组。这种方式在创建时指定了数组的长度为 2，创建后数组中的元素会被初始化为对应类型的默认值，对于整型来说，默认值为 0。创建引用数据类型数组：以Car[] c = new Car[100];为例，可以创建一个引用数据类型数组。假设Car是一个自定义的类，这种方式创建了一个长度为 100 的Car类型数组。创建后，数组中的每个元素初始值为 null，因为引用类型的默认值为 null。数组创建后有初始值，数字类型为 0，布尔类型为 false，引用类型为 null。例如，创建一个byte类型的数组，其元素默认初始值是 0；创建一个float类型的数组，其元素默认初始值是 0.0f；创建一个boolean类型的数组，其元素默认初始值是 false；如果创建一个自定义的引用类型数组，如Person[] people = new Person[3]，那么创建后数组中的每个元素初始值为 null。

四、数组的初始化

数组的初始化方式主要有以下几种：

初始化、创建、和声明分开： 首先进行声明：int[] i; 然后创建数组并指定长度：i = new int[2]; 最后为数组元素赋值：i[0] = 0;，i[1] = 1;。 初始化、创建、和声明在同一时间：

 

可以使用int[] i = {0,1};的方式，直接在声明的同时为数组元素分配空间并赋值。

 

也可以使用int[] i = new int[]{1,2,3,4,5};的方式，先使用new关键字创建数组，同时为数组中的元素赋值，这里不需要指定数组的长度，数组长度由其后的初始化操作确定。

        数组的初始化方式还包括静态初始化、动态初始化和默认初始化。静态初始化是在定义数组的同时为数组元素分配空间并赋值，由系统决定数组的长度，例如int[] a = {1,2,3}或Man[] mans = {new Man(1, 1), new Man(2, 2)}。动态初始化是在初始化时由程序员指定数组的长度，由系统初始化每个数组元素的默认值，例如int[] a1 = new int[2]，然后再给数组元素赋值。默认初始化是对于引用类型的数组，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化，例如int a2[] = new int[2]，其默认值为0,0；boolean[] b = new boolean[2]，其默认值为false,false；String[] s = new String[2]，其默认值为null,null。

        注意：不要同时使用静态初始化和动态初始化，一旦数组完成初始化，数组在内存中所占的空间将被固定下来，所以数组的长度将不可改变。

五、数组的使用

1. 获取长度以及访问元素：

        在 Java 中，获取数组长度非常简单，可以使用arr.length表示获取数组长度。例如：

int[] numbers = {1, 2, 3, 4, 5};int length = numbers.length;System.out.println("数组的长度是: " + length);

访问数组元素可以通过System.out.println(arr[0]);的方式。还可以通过循环语句打印全部元素，如：

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

        此外，还有 for-each 遍历数组语句：for(int i : arr){System.out.println(i);}，此方法不可以改变数组的值，只是数组的复制值。

2. 数组作为方法的参数：

        可以将数组作为方法的参数来打印数组内容。理解引用类型参数传内置类型时，形参的结果不会影响实参值；参数传数组类型时，在函数内部修改数组内容，函数外部也发生改变。例如：        

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

3. 数组作为方法的返回值：

数组也可以作为方法的返回值。比如：

public class Demo02ArrayReturn {    public static void main(String[] args) {        int[] result = calculate(10, 20, 30);        System.out.println("main方法接收到的返回值数组是：");        System.out.println(result); // 地址值        System.out.println("总和：" + result[0]);        System.out.println("平均数：" + result[1]);    }    public static int[] calculate(int a, int b, int c) {        int sum = a + b + c; // 总和        int avg = sum / 3; // 平均数        int[] array = {sum, avg};        System.out.println("calculate方法内部数组是：");        System.out.println(array); // 地址值        return array;    }}

六、多维数组

1. 二维数组的声明和初始化

Java 中二维数组可以有多种声明和初始化方式，例如： int[][] arr1=new int[][]{{1,2,3},{4,5,6}};：这是一种静态初始化的方式，直接在创建数组的同时为其赋值。 String[][] arr2=new String[3][2];：动态初始化，指定了二维数组的外层长度为 3，内层长度为 2，但未为元素赋值。 String[][] arr3=new String[3][];：动态初始化，只指定了外层长度为 3，内层长度未确定。 int[] arr4[]=new int[][]{{1,2,3},{4,5,6}};：另一种声明方式，与第一种类似，也是静态初始化。 int[] arr5[]={{1,2,3},{4,5,6}};（类型推断）：简洁的初始化方式，省略了new关键字，但效果与第一种相同。

2. 调用数组的指定位置的元素

二维数组的元素可以通过指定行和列的索引来访问。例如，对于二维数组arr，内层元素可以通过arr[行索引][列索引]来访问，如arr[3][2]；外层元素可以通过只指定行索引来访问，如arr[3]。

3. 获取数组的长度

在二维数组中，可以使用arr.length来获取外层元素的数量，即数组的行数。而要获取某一行（外层元素）的长度（列数），可以使用arr[行索引].length。例如，如果有一个二维数组int[][] arr = {{1,2,3},{4,5,6}};，那么arr.length的值为 2，arr[0].length的值为 3。

4. 遍历二维数组

二维数组可以使用嵌套的for循环来遍历。外层for循环遍历外层元素，控制行数；内层for循环遍历内层元素，控制列数。例如：

int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};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();}

这段代码会依次输出二维数组中的每一个元素，每输出完一行元素后换行。

5. 二维数组元素的默认初始化值

对于初始化方式int[][] arr = new int[4][3];，外层元素的初始化值为地址值，内层元素的初始化值与一维数组初始化情况相同。例如，对于整型二维数组，内层元素的初始值为 0。 对于初始化方式int[][] arr=new int[4][];，外层元素的初始化值为null，内层元素的初始化值不能调用，否则会报错。例如：

int[][] arr = new int[4][];System.out.println(arr[0]); // null// System.out.println(arr[0][0]); // 会报错，空指针异常

七、Arrays 类

        Java 中的java.util.Arrays类是操作数组的工具类，包含了用来操作数组的各种方法，如判断两个数组是否相等、输出数组信息、将指定值填充到数组之中、对数组进行排序、对排序后的数组进行二分法检索指定的值。

1. 判断两个数组是否相等

        可以使用Arrays.equals(数组1，数组2)方法来判断两个数组是否相等。数组类型必须相等，该方法的返回值为boolean类型。例如：

int[] arr1 = new int[]{1,2,3,4,6};int[] arr2 = new int[]{1,2,3,4,5};boolean isEquals = Arrays.equals(arr1, arr2);System.out.println(isEquals);

2. 输出数组信息

        使用Arrays.toString(数组名)方法可以输出数组信息。例如：

int[] arr2 = new int[]{1,2,3,4,5};System.out.println(Arrays.toString(arr2));

3. 将指定值填充到数组之中

        Arrays.fill(数组名,填充值)方法可以将指定值填充到数组之中。填充值数据类型应与数组数据类型相同，该方法会把要填充的数组数据全部改为指定值。例如：

int[] arr2 = new int[]{1,2,3,4,5};Arrays.fill(arr2,9);System.out.println(Arrays.toString(arr2));

4. 对数组进行排序

        使用Arrays.sort(数组名)方法可以对数组进行排序。例如：

int[] arr2 = new int[]{5,4,1,2,3};Arrays.sort(arr2);System.out.println(Arrays.toString(arr2));

5. 对排序后的数组进行二分法检索指定的值

        使用Arrays.binarySearch(数组名,查询值)方法可以对排序后的数组进行二分法检索指定的值。使用前提是当前数组必须是有序的，返回值为int，为负则查找失败，找到了返回下标。例如：

int[] arr1 = new int[]{1,2,3,4,6};int index = Arrays.binarySearch(arr1,1);System.out.println(index);

八、数组的常见应用场景        

        数组在实际编程中有很多常见的应用场景，其中之一就是存储一组数据进行统计分析，如计算平均值、最大值、最小值等。

        例如，可以使用以下方法获取数组中的最大值和最小值：

方法一：该方法使用交换顺序来寻找最大值，但查找完以后会污染数组，不能同时运行寻最大值方法和最小值方法。

/*获取数组里的最大值和最小值*/public class TestFindArrayNum {    public static void main(String[] args) {        int[] arr = {500,11,12,100,11,13,1,3,5,205,7,9,2,4,6,8,400,0,300,10};        findMaxNum(arr);        //使用寻找最小值方法之前要先注释掉寻找最大值的方法        //因为使用完寻找最大值的方法后会污染数组，整个数组都会变为最大值500        //findMinNum(arr);    }    private static void findMaxNum(int[] arr) {        int maxNum = 0;        for (int i = 0; i < arr.length - 1; i++) {            if (arr[i + 1] > arr[i]) {                maxNum = arr[i + 1];            } else {                arr[i + 1] = arr[i];                maxNum = arr[i];            }        }        System.out.println("数组中最大值是" + maxNum);    }    private static void findMinNum(int[] arr) {        int minNum = 0;        for (int i = 0; i < arr.length - 1; i++) {            if (arr[i + 1] < arr[i]) {                minNum = arr[i + 1];            } else {                arr[i + 1] = arr[i];                minNum = arr[i];            }        }        System.out.println("数组中最小值是" + minNum);    }}

方法二：方法二代码更加简洁且不会污染数组

/*获取数组里的最大值和最小值*/public class TestFindArrayNum2 {    public static void main(String[] args) {        int[] arr = {500,11,12,100,11,13,1,3,5,205,7,9,2,4,6,8,400,0,300,10};        findMaxNum(arr);        findMinNum(arr);    }    private static void findMaxNum(int[] arr) {        int max = arr[0];        for (int i = 1; i <= arr.length - 1; i++) {            if (max < arr[i]) {                max = arr[i];            }        }        System.out.println("数组中最大值" + max);    }    private static void findMinNum(int[] arr) {        int min = arr[0];        for (int i = 1; i <= arr.length - 1; i++) {            if (min > arr[i]) {                min = arr[i];            }        }        System.out.println("数组中最小值" + min);    }}

方法三：

public class TestFindArrayNum3 {    private int max;    private int min;    public int getMax() {        return max;    }    public int getMin() {        return min;    }    public void FindMaxAndMin(int[] arr ) {        if(arr==null){            System.out.println("输入的数组为空");            return;        }        int i = 0;        int len = arr.length;        max = arr[0];        min = arr[0];        //两两分组，把较小的数挪到左边，较大的数挪到右边        for(i = 0; i < len - 1; i += 2){            if(arr[i]>arr[i + 1]){                int tmp = arr[i];                arr[i]= arr[i + 1];                arr[i + 1]= tmp;            }        }        //最小值放在各个分组的左边        min = arr[0];        for(i = 2; i < len ; i += 2){            if(arr[i]<min){                min = arr[i];            }        }        //最大值放在各个分组的右边        max = arr[1];        for(i = 3; i < len; i += 2){            if(arr[i]>max){                max = arr[i];            }        }        //如果数组中元素个数是奇数个，最后一个元素被分为一组，需要特殊处理        if(len%2==1){            if(max<arr[len - 1])                max = arr[len - 2];            if(min>arr[len - 1])                min = arr[len - 1];        }    }    public static void main(String[] args) {        int[] arr={500,11,12,100,11,13,1,3,5,205,7,9,2,4,6,8,400,0,300,10};        TestFindArrayNum3 f =new TestFindArrayNum3();        f.FindMaxAndMin(arr);        System.out.println("最大值是"+f.getMax());        System.out.println("最小值是"+f.getMin());    }}

        除了获取最大值和最小值，还可以计算数组的平均值。一般情况下对数组计算均值，可以采用对数组求和，再除以数组长度。实现代码：

public double doubleArrAverage(double[] arr) {    double sum = 0;    for (int i = 0; i < arr.length; i++) {        sum += arr[i];    }    return sum / arr.length;}

        但其中存在最大问题就是数组求和，如果数组内元素值较大或者数组元素非常多，很有可能出现内存溢出。解决这种问题，一种方法是采用每个元素除以数组长度，再对结果求和。实现代码：

public double doubleArrage(double[] arr) {    double result = 0;    for (int i = 0; i < arr.length; i++) {        result += arr[i] / arr.length;    }    return result;}

        另一种方法是，假定数组长度是动态的，当存在一个元素时，均值ave即为当前数组值arr[0]。当加入第二个个元素，第二个元素减去均值ave，得到的差值除以数组长度，再与均值ave相加，即可得到数组均值。以此类推，直到数组所有元素参与计算，也就完成了整个数组均值计算。实现代码：

public double doubleArrage(double[] arr) {    double result = arr[0];    for (int i = 1; i < arr.length; i++) {        double temp = arr[i];        result += (temp - result) / (i + 1);    }    return result;}

        在实际编程中，数组还可以用于对用户输入的成绩进行排序和计算平均分。例如：

Scanner scanner = new Scanner(System.in);int[] scores = new int[5];for (int i = 0; i < scores.length; i++) {    scores[i] = scanner.nextInt();}Arrays.sort(scores);double average = Arrays.stream(scores).average().orElse(Double.NaN);

        这段代码演示了如何使用数组来收集用户输入的成绩，对这些成绩进行排序，并计算平均值。

        数组的常见应用场景还包括排序算法教学、搜索引擎索引、股票市场分析等。在排序算法教学中，可以使用数组来展示冒泡排序、选择排序等算法；在搜索引擎索引中，可以使用数组作为倒排索引的一部分，快速检索关键词；在股票市场分析中，可以使用数组存储股票价格，分析市场趋势。