Java中处理超20亿元素大型数组的解决方案问询

哥们儿，我太懂你被Java原生数组int索引上限（2^31-1，约20亿）卡脖子的痛苦了！结合之前同行们的深度探讨，给你梳理几个能完美覆盖你需求的方案，每个操作都给你讲明白怎么实现：

一、最实用的自定义分段数组（Chunked Array） #

这是目前业界用得最多的替代方案，核心思路是把超大规模的数组拆成多个固定大小的「子数组（Chunk）」，用long类型索引来定位元素所在的子数组和偏移位置。你可以把它封装成一个通用类，对外暴露和原生数组类似的API，完全兼容你要的所有操作：

1. 创建新数组 #

先定义每个子数组的大小（比如选1024*1024=1MB元素，或者根据你的内存情况调整），然后初始化一个用来存子数组的容器。如果想节省内存，可以在第一次访问某个子数组时再创建它：

public class BigArray<T> {
    private final int chunkSize;
    private Object[][] chunks;
    private long length;

    // 创建指定长度的大数组，chunkSize可自定义
    public BigArray(long length, int chunkSize) {
        this.chunkSize = chunkSize;
        this.length = length;
        int chunkCount = (int) ((length + chunkSize - 1) / chunkSize); // 向上取整计算需要的子数组数量
        this.chunks = new Object[chunkCount][];
    }
}

2. 获取/设置第i个元素 #

通过long索引计算对应的子数组下标和内部偏移，直接操作子数组即可：

@SuppressWarnings("unchecked")
public T get(long i) {
    if (i < 0 || i >= length) throw new IndexOutOfBoundsException();
    int chunkIdx = (int) (i / chunkSize);
    int offset = (int) (i % chunkSize);
    // 按需初始化子数组
    if (chunks[chunkIdx] == null) {
        chunks[chunkIdx] = new Object[Math.min(chunkSize, (int) (length - chunkIdx * chunkSize))];
    }
    return (T) chunks[chunkIdx][offset];
}

public void set(long i, T value) {
    if (i < 0 || i >= length) throw new IndexOutOfBoundsException();
    int chunkIdx = (int) (i / chunkSize);
    int offset = (int) (i % chunkSize);
    if (chunks[chunkIdx] == null) {
        chunks[chunkIdx] = new Object[Math.min(chunkSize, (int) (length - chunkIdx * chunkSize))];
    }
    chunks[chunkIdx][offset] = value;
}

3. 数组扩容（创建更大数组并复制内容） #

和原生数组扩容逻辑类似，创建一个新的分段数组，然后把旧数组的子数组直接复制过去（比逐个元素遍历高效得多）：

public BigArray<T> resize(long newLength) {
    BigArray<T> newArray = new BigArray<>(newLength, this.chunkSize);
    long copyLength = Math.min(this.length, newLength);
    int copyChunkCount = (int) ((copyLength + chunkSize - 1) / chunkSize);
    
    // 批量复制子数组
    for (int i = 0; i < copyChunkCount; i++) {
        if (this.chunks[i] != null) {
            int copySize = Math.min(chunkSize, (int) (copyLength - (long)i * chunkSize));
            System.arraycopy(this.chunks[i], 0, newArray.chunks[i], 0, copySize);
        }
    }
    return newArray;
}

4. 复制小数组到当前大数组 #

直接遍历小数组的每个元素，调用set方法写入大数组指定位置即可：

public void copyFrom(T[] smallArray, long startIndex) {
    if (startIndex + smallArray.length > this.length) throw new IndexOutOfBoundsException();
    for (int i = 0; i < smallArray.length; i++) {
        this.set(startIndex + i, smallArray[i]);
    }
}

二、基于内存映射文件的方案（适合超大规模、可持久化的场景） #

如果你的数组大到堆内存都装不下，可以用Java NIO的MappedByteBuffer（内存映射文件）来实现。它把文件直接映射到虚拟内存，支持超大容量（只要磁盘空间够），而且可以用long类型的位置来访问。不过这个方案更适合基本数据类型（比如int、long），如果是对象的话需要自己处理序列化/反序列化：

核心操作示例（以int数组为例） #

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class MappedBigIntArray {
    private final MappedByteBuffer buffer;
    private final long length;

    public MappedBigIntArray(long length, String filePath) throws Exception {
        this.length = length;
        RandomAccessFile raf = new RandomAccessFile(filePath, "rw");
        // 映射整个文件到内存，每个int占4字节
        this.buffer = raf.getChannel().map(FileChannel.MapMode.READ_WRITE, 0, length * 4);
        raf.close();
    }

    public int get(long i) {
        if (i < 0 || i >= length) throw new IndexOutOfBoundsException();
        return buffer.getInt((int)(i * 4)); 
    }

    public void set(long i, int value) {
        if (i < 0 || i >= length) throw new IndexOutOfBoundsException();
        buffer.putInt((int)(i * 4), value);
    }

    // 扩容需重新创建更大的映射文件并复制旧内容；复制小int数组可直接用buffer.put批量写入
}

注意：如果总大小超过Integer.MAX_VALUE字节（约2GB），需要分块映射多个ByteBuffer，用long索引计算对应的块和偏移，逻辑和分段数组类似。

三、关于原生long索引数组的进展 #

之前有同行提出过Java原生支持long索引数组的提案，但目前还没正式纳入JDK。所以上面的两种方案是现阶段最靠谱的落地方式：分段数组对对象类型友好，实现简单，性能接近原生数组；内存映射方案适合超大规模、需要持久化的场景。

内容的提问来源于stack exchange，提问作者Denis Kulagin