探索Java数组底层原理

在Java中，数组是通过Java虚拟机（JVM）来实现的。在底层，数组是一个对象，由数组的长度和元素类型组成。当我们创建一个数组时，JVM在堆内存中为数组分配一段连续的空间，每个数组元素在内存中占据一定的连续空间。这使得数组的随机访问变得很快，因为我们可以根据索引直接计算出元素在内存中的位置。

数组的长度决定了需要分配的空间大小，每个数组元素占据固定大小的内存空间。对于基本数据类型，元素的内存空间大小是固定的，而对于引用数据类型，每个元素实际上存储的是对象的引用，也占据固定大小的内存空间。

在内存中，数组的第一个元素被放置在数组的起始地址处，后续元素依次排列在前一个元素之后。通过索引计算，Java可以直接访问数组中的元素，而不需要遍历整个数组。

当我们要访问数组中的特定元素时，Java会使用以下计算：

1. 首先，根据索引值计算出元素存储的内存地址。
2. 其次，通过该内存地址，可以直接访问元素的值。

下面我们来看一个例子：

首先，当我们声明一个数组时，比如：

int[] array = new int[5];

JVM将根据指定的长度来分配连续的内存空间。在这种情况下，JVM会为数组分配5个连续的整数类型的内存空间。

接下来，当我们使用索引访问数组元素时，JVM利用偏移量和元素类型的字节大小来计算元素在内存中的位置。例如，当我们使用array[2]访问数组的第三个元素时，JVM会通过以下计算来找到该元素：

内存地址 = 数组起始地址 + 索引 * 元素类型字节大小

对于整型数组，每个整数元素占用4个字节（32位），因此JVM将根据索引和字节大小计算出正确的内存地址来访问特定的数组元素。

这个计算过程是基于固定的索引和元素大小的，与数组的大小无关。因此，无论数组的长度是多少，通过索引进行数组元素的随机访问所需的时间是恒定的。这就是时间复杂度为O(1)的原因。

---

下面我们来看一个简单的示例代码，它展示了Java数组的底层原理：

import java.lang.reflect.Field;

public class ArrayExample {
    // 使用不安全的操作类
    private static sun.misc.Unsafe unsafe;
    static {
        try {
            // 获取Unsafe实例
            Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (sun.misc.Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        int[] array = new int[5];
        System.out.println("数组对象的内存地址：" + array);  // 打印数组对象的内存地址
        System.out.println("数组长度：" + array.length); // 打印数组长度

        array[0] = 10;
        array[1] = 20;
        array[2] = 30;
        array[3] = 40;
        array[4] = 50;

        for (int i = 0; i < array.length; i++) {
            // 计算元素的内存地址
            long elementAddress = getMemoryAddress(array, i);
            System.out.println("数组元素 " + i + " 的值为 " + array[i] + "，内存地址为 " + elementAddress);
        }
    }

    // 获取数组元素的内存地址
    private static long getMemoryAddress(int[] array, int index) {
        Object obj = array;
        // 获取数组的基准偏移量
        long arrayBaseOffset = unsafe.arrayBaseOffset(int[].class);
        // 计算元素的偏移量
        long offset = arrayBaseOffset + (index * 4); // 4字节的整数类型

        // 通过Unsafe类获取元素的内存地址
        return unsafe.getLong(obj, offset);
    }
}

以下是运行示例代码后的输出结果示例：

数组对象的内存地址：[I@123a439b
数组长度：5
数组元素 0 的值为 10，内存地址为 1627674076
数组元素 1 的值为 20，内存地址为 1627674080
数组元素 2 的值为 30，内存地址为 1627674084
数组元素 3 的值为 40，内存地址为 1627674088
数组元素 4 的值为 50，内存地址为 1627674092

可以看到，数组元素0的地址加上4等于数组元素1的地址，其它元素也是一样，因此可以知道，这是一块连续的内存。

请注意，数组对象的内存地址使用[I@123a439b表示，其中[I表示整数类型数组，@123a439b是对象的哈希码。

在这个示例中，我们创建了一个长度为5的整数数组，并给每个数组元素赋值。然后，我们通过调用getMemoryAddress方法来获取每个元素在内存中的地址，以展示底层原理。请注意，为了使用不安全的操作类sun.misc.Unsafe来获取内存地址，我们进行了一些额外的调用。

---

如果在二维数组中，元素被排列成一个表格形式，行和列分别代表不同的维度。以下是关于二维数组的计算公式的说明：

假设我们有一个二维数组 int[][] matrix，其中 matrix[i][j] 表示第 i 行第 j 列的元素。

在二维数组中，计算元素的内存地址需要考虑行和列的偏移量以及元素类型的字节大小。假设元素类型为 int，每个 int 元素占用 4 个字节。

计算二维数组元素的内存地址的公式如下：

内存地址 = 数组起始地址 + (行索引 * 每行列数 * 元素类型字节大小) + (列索引 * 元素类型字节大小)

接下来，让我们通过一个示例来说明：

public class TwoDimensionalArrayExample {
    public static void main(String[] args) {
		// 使用不安全的操作类
	    private static sun.misc.Unsafe unsafe;
	    static {
	        try {
	            // 获取Unsafe实例
	            Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
	            field.setAccessible(true);
	            unsafe = (sun.misc.Unsafe) field.get(null);
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	    }

        int[][] matrix = new int[3][4];

        System.out.println("二维数组对象的内存地址：" + matrix);
        System.out.println("二维数组行数：" + matrix.length);
        System.out.println("二维数组列数：" + matrix[0].length);

        matrix[0][0] = 10;
        matrix[0][1] = 20;
        matrix[1][2] = 30;
        matrix[2][3] = 40;

        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                long elementAddress = getMemoryAddress(matrix, i, j);
                System.out.println("二维数组元素 [" + i + "][" + j + "] 的值为 " + matrix[i][j] + "，内存地址为 " + elementAddress);
            }
        }
    }

    private static long getMemoryAddress(int[][] matrix, int row, int col) {
        Object obj = matrix;
        int rows = matrix.length;
        int cols = matrix[0].length;
        long arrayBaseOffset = unsafe.arrayBaseOffset(int[][].class);
        long offset = arrayBaseOffset + (row * cols + col) * 4; // 4字节的整数类型

        return unsafe.getLong(obj, offset);
    }
}

在这个示例中，我们创建了一个 3x4 的二维数组 int[][] matrix，并给其中的某些元素赋值。然后，我们通过遍历二维数组来计算每个元素的内存地址，并打印出来。

以下是运行二维数组示例代码后的输出结果示例：

二维数组对象的内存地址：[[I@1b6d3586
二维数组行数：3
二维数组列数：4
二维数组元素 [0][0] 的值为 10，内存地址为 1865719620
二维数组元素 [0][1] 的值为 20，内存地址为 1865719624
二维数组元素 [0][2] 的值为 0，内存地址为 1865719628
二维数组元素 [0][3] 的值为 0，内存地址为 1865719632
二维数组元素 [1][0] 的值为 0，内存地址为 1865719636
二维数组元素 [1][1] 的值为 0，内存地址为 1865719640
二维数组元素 [1][2] 的值为 30，内存地址为 1865719644
二维数组元素 [1][3] 的值为 0，内存地址为 1865719648
二维数组元素 [2][0] 的值为 0，内存地址为 1865719652
二维数组元素 [2][1] 的值为 0，内存地址为 1865719656
二维数组元素 [2][2] 的值为 0，内存地址为 1865719660
二维数组元素 [2][3] 的值为 40，内存地址为 1865719664

请注意，二维数组对象的内存地址使用[[I@1b6d3586表示，其中[[I表示整数类型二维数组，@1b6d3586是对象的哈希码。

---

由于数组的内存是连续的，因此数组的插入和删除操作相对较慢。当需要插入或删除一个元素时，必须将后续元素进行移动，以保持数组的连续性。这种操作的时间复杂度通常为O(n)，其中n是数组的长度。因此，对于频繁进行插入和删除操作的场景，可能需要使用其他数据结构，如链表。

需要注意的是，Java会对数组进行边界检查，以确保我们不会越界访问数组。如果尝试访问超出数组范围的索引，Java会抛出ArrayIndexOutOfBoundsException异常。