Question

我有以下代码，其中我使用HashMap（使用两个并行数组）来存储键值对（键可以有多个值）。现在，我必须存储并加载它以备将来使用，这就是我使用文件通道存储和加载它的原因。这段代码的问题是：我可以在我的8 GB服务器中存储近1.2亿个键值对（实际上，我可以从8 gb中为我的JVM分配近5 gb，而这两个并行阵列需要近2.5 gb，其他内存用于我的代码的各种处理）。但是，我必须存储近600/700万个键值对。 anybdoy可以帮我修改这段代码，因此我可以存储近600/700万个键值对。或者对此有任何评论对我来说都很好。另一点，我必须将hashmap加载并存储到内存中。使用文件通道需要很长时间。根据Stack Overflow的各种建议，我找不到更快的一个。我也使用了ObjectOutputStream，Zipped输出流，但是比下面的代码慢。无论如何以这种方式存储这两个并行阵列，因此加载时间会快得多。我在下面的代码中给出了一个测试用例。对此的任何评论对我也有帮助。

import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Arrays;
import java.util.Random;
import java.nio.*;
import java.nio.channels.FileChannel;
import java.io.RandomAccessFile;

public class Test {

    public static void main(String args[]) {


        try {

            Random randomGenerator = new Random();

            LongIntParallelHashMultimap lph = new LongIntParallelHashMultimap(220000000, "xx.dat", "yy.dat");

            for (int i = 0; i < 110000000; i++) {
                lph.put(i, randomGenerator.nextInt(200000000));
            }

            lph.save();

            LongIntParallelHashMultimap lphN = new LongIntParallelHashMultimap(220000000, "xx.dat", "yy.dat");
            lphN.load();

            int tt[] = lphN.get(1);

            System.out.println(tt[0]);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class LongIntParallelHashMultimap {

    private static final long NULL = -1L;
    private final long[] keys;
    private final int[] values;
    private int size;
    private int savenum = 0;
    private String str1 = "";
    private String str2 = "";

    public LongIntParallelHashMultimap(int capacity, String st1, String st2) {
        keys = new long[capacity];
        values = new int[capacity];
        Arrays.fill(keys, NULL);
        savenum = capacity;
        str1 = st1;
        str2 = st2;
    }

    public void put(long key, int value) {
        int index = indexFor(key);
        while (keys[index] != NULL) {
            index = successor(index);
        }
        keys[index] = key;
        values[index] = value;
        ++size;
    }

    public int[] get(long key) {
        int index = indexFor(key);
        int count = countHits(key, index);
        int[] hits = new int[count];
        int hitIndex = 0;

        while (keys[index] != NULL) {
            if (keys[index] == key) {
                hits[hitIndex] = values[index];
                ++hitIndex;
            }
            index = successor(index);
        }

        return hits;
    }

    private int countHits(long key, int index) {
        int numHits = 0;
        while (keys[index] != NULL) {
            if (keys[index] == key) {
                ++numHits;
            }
            index = successor(index);
        }
        return numHits;
    }

    private int indexFor(long key) {
        return Math.abs((int) ((key * 5700357409661598721L) % keys.length));
    }

    private int successor(int index) {
        return (index + 1) % keys.length;
    }

    public int size() {
        return size;
    }

    public void load() {
        try {
            FileChannel channel2 = new RandomAccessFile(str1, "r").getChannel();
            MappedByteBuffer mbb2 = channel2.map(FileChannel.MapMode.READ_ONLY, 0, channel2.size());
            mbb2.order(ByteOrder.nativeOrder());
            assert mbb2.remaining() == savenum * 8;
            for (int i = 0; i < savenum; i++) {
                long l = mbb2.getLong();
                keys[i] = l;
            }
            channel2.close();

            FileChannel channel3 = new RandomAccessFile(str2, "r").getChannel();
            MappedByteBuffer mbb3 = channel3.map(FileChannel.MapMode.READ_ONLY, 0, channel3.size());
            mbb3.order(ByteOrder.nativeOrder());
            assert mbb3.remaining() == savenum * 4;
            for (int i = 0; i < savenum; i++) {
                int l1 = mbb3.getInt();
                values[i] = l1;
            }
            channel3.close();
        } catch (Exception e) {
            System.out.println(e);
        }
    }

    public void save() {
        try {
            FileChannel channel = new RandomAccessFile(str1, "rw").getChannel();
            MappedByteBuffer mbb = channel.map(FileChannel.MapMode.READ_WRITE, 0, savenum * 8);
            mbb.order(ByteOrder.nativeOrder());

            for (int i = 0; i < savenum; i++) {
                mbb.putLong(keys[i]);
            }
            channel.close();

            FileChannel channel1 = new RandomAccessFile(str2, "rw").getChannel();
            MappedByteBuffer mbb1 = channel1.map(FileChannel.MapMode.READ_WRITE, 0, savenum * 4);
            mbb1.order(ByteOrder.nativeOrder());

            for (int i = 0; i < savenum; i++) {
                mbb1.putInt(values[i]);
            }
            channel1.close();
        } catch (Exception e) {
            System.out.println("IOException : " + e);
        }
    }
}

Answer 1

鉴于您声明的数据类型，我怀疑这是可能的。只需乘以基元类型的大小即可。

每行需要4个字节来存储int，8个字节来存储long。 6亿行*每行12个字节= 7200 MB = 7.03 GB。您说您可以为JVM分配5 GB。所以即使它只是堆并且只存储了这个自定义的HashMap，它也不适合。考虑缩小所涉及的数据类型的大小或将其存储在除RAM之外的其他位置。

Answer 2

将数据库放在磁盘上，而不是内存中。重写您的操作，使它们不在数组上运行，而是在缓冲区上运行。然后，您可以打开一个足够大的文件，并让操作使用映射缓冲区访问它们所需的部分。尝试在实现少数最近映射的内存区域的缓存时，您的应用程序是否表现更好，因此您不必经常映射和取消映射公共区域，而是可以将它们映射到。

这应该会给你两全其美，磁盘和内存：

随时访问数据结构的任何部分都很容易实现
将缓存对表格中常用部分的访问
很少使用表中的部分不会占用任何内存

正如您所看到的，这在很大程度上取决于地点：如果某些键比其他键更常见，那么事情就会很好，而分布良好的键会导致每次访问都有新的磁盘操作。因此，虽然大多数内存中的散列映射都需要很好的发行版，但是将常用键映射到类似位置的其他结构在这里表现更好。但这些会干扰碰撞处理。

Answer 3

最好使用像sqlite这样的内存数据库，这样可以获得良好的效果。

自定义HashMap代码问题

3 个答案: