java - 是否有任何有效和优化的方法来在 long[] 数组中存储 500M+ 元素？

Question

在我考试的第一个问题中:我正在做一个小任务，我需要在一个数组中存储大约 5 亿多个元素。

但是，我遇到了堆空间问题。你能帮我解决这个最佳存储算法吗？

我找到了“BitSet”，但我不知道如何使用它。

第 1 步 - 创建 3 个长度非常大(至少 100M+)的 long[] 数组

第 2 步 - 初始值应随机生成，而不是排序，可能包含重复值

第 3 步 - 在初始化后随机合并它们(3 个 long[] 数组)

第 4 步 - 应在输出中删除重复项

我写了一些东西:

package exam1;

import java.time.Duration;
import java.time.Instant;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;

/**
 *
 * @author Furkan
 */

//VM OPTIONS -> -Xincgc -Xmx4g -Xms4g

public final class Exam1 {

private static final int LENGTH = 100000000;

private volatile long[] m_testArr1 = null;
private volatile long[] m_testArr2 = null;
private volatile long[] m_testArr3 = null;

private volatile long[] m_merged = null;

private Random m_r = new Random(System.currentTimeMillis());


public static void main(String[] args) {
    Exam1 exam = new Exam1();

    Instant start1 = Instant.now();
    System.out.println("Fill Started");
    exam.Fill();

    Instant end1 = Instant.now();
    System.out.println("Fill Ended : " + Duration.between(start1, end1)); 

    Instant start2 = Instant.now();
    System.out.println("Merge Started");
    exam.Merge();
    Instant end2 = Instant.now();
    System.out.println("Merge Ended : " + Duration.between(start1, end1)); 

    Instant start3 = Instant.now();
    System.out.println("DupRemove Started");
    exam.DupRemove();
    Instant end3 = Instant.now();
    System.out.println("DupRemove Ended : " + Duration.between(start1, end1)); 
}

private void Fill(){
    this.m_testArr1 = new long[Exam1.LENGTH];
    this.m_testArr2 = new long[Exam1.LENGTH];
    this.m_testArr3 = new long[Exam1.LENGTH];

    for (int i = 0; i < Exam1.LENGTH; i++) {
        this.m_testArr1[i] = this.m_r.nextLong();
        this.m_testArr2[i] = this.m_r.nextLong();
        this.m_testArr3[i] = this.m_r.nextLong();
    }
}

private void Merge(){
    this.m_merged = this.TryMerge(this.m_testArr1, this.m_testArr2, this.m_testArr3);
}

 private void DupRemove(){
    this.m_merged = this.RemoveDuplicates(this.m_merged);
}

public long[] TryMerge(long[] arr1, long[] arr2, long[] arr3){
    int aLen = arr1.length;
    int bLen = arr2.length;
    int cLen = arr3.length;

    int len = aLen + bLen + cLen;

    //TODO: Use BitSize for RAM optimize. IDK how to use...

    //OutOfMemory Exception on this line. 
    long[] mergedArr = new long[len];
    this.m_merged = new long[len];

    //long[] mergedArr = (long[]) Array.newInstance(long.class, aLen+bLen+cLen);

    System.arraycopy(arr1, 0, mergedArr, 0, aLen);
    System.arraycopy(arr2, 0, mergedArr, aLen, bLen);
    System.arraycopy(arr3, 0, mergedArr, (aLen + bLen), cLen);


    return mergedArr;
}

//!!!NOT WORKING!!!
private long[] RemoveDuplicates(long[] arr){
    HashSet<Long> set = new HashSet<Long>();

    final int len = arr.length;
    for(int i = 0; i < len; i++){
        set.add(arr[i]);
    }

    long[] clean = new long[set.size()];
    int i = 0;
    for (Iterator<Long> it = set.iterator(); it.hasNext();) {
        clean[i++] = it.next();
    }
    return clean;
}
}

更新

原始问题；

-实现一个有效的方法来合并 3 组非常大的(长度:100M+)long[] 数组。

-输入数据随机生成，未排序，可能包含重复项

- 应在输出中删除重复项。

(我有 8 GB 内存)

运行参数:-Xincgc -Xmx4g -Xms4g

异常:线程“主”java.lang.OutOfMemoryError 中的异常:测试时的 Java 堆空间。

Answer 1

由于您的空间有限，并且假设您可以修改 3 个随机数组，我建议如下。

1. 对于 3 个数组中的每一个:

   1. 对数组进行排序，例如使用 Arrays.sort()。

   2. 通过将非重复数字压缩到开头来消除重复项。
      例如。如果你有 {1,2,2,3,3}，你压缩到长度为 3 的 {1,2,3,?,?}，其中 ? 表示值无关紧要。

   3. (可选) 移动到正确大小的数组，并丢弃原始数组，为结果数组释放空间。

2. 创建大小为 len1 + len2 + len3 的结果数组。

3. 将 3 个数组合并到结果中，消除数组之间的重复项。
   例如。如果你有 {1,3,5}, {1,2,3}，你最终会得到 {1,2,3,5,? ,?} 长度为 4。

4. 如果需要，将结果复制到正确大小的新数组。
   如果内存不足，请在执行此操作之前释放 3 个原始数组以释放空间。