Question

每条记录都有ID，价格和数量。如果id已存在，则添加新记录时，新记录将替换旧记录，id在数据集中是唯一的。我经常需要获取排序数据（按价格）。像数据集中的前100或25-50位置。好的是每次我需要排序的数据都来自数据集的启动。（我可以使用Comparable compareTo（Object o）。）

我已尝试将数据存储到：

当id相同时，ArrayList替换元素或在末尾添加元素。在需要数据时对其进行排序。太慢了。
ArrayDeque删除旧元素（如果存在）并添加新元素。在需要数据时对其进行排序。太慢了。
HashMap有助于使用唯一ID并替换现有ID。排序时，我从HashMap中获取值并将它们排序为ArrayList。更快但仍然不够。
TreeMap有助于使用唯一ID，但无法按键对其进行排序。将值排序为ArrayList。与HashMap相同。
SortedSet（TreeSet）删除旧元素（如果存在）并添加新元素。使用迭代器获取已排序的元素。现在最快但仍然不够。

我已根据操作here和here检查了Java集合 - 性能（时间复杂度）。

如果有人建议使用哪种数据类型/排序或如何尽可能快地进行此操作。

我需要一些时间，例如有1亿条记录已更新（添加/替换）并按要求排序。不使用och / quad核心（八线程CPU）上的任何基准软件，4Ghz应该是大约2,3分钟。请记住，随着添加/替换和排序的记录增加时间的数量越来越多。

Answer 1

作为suggested by László van den Hoek，您应该考虑将数据实际存储在可以处理大量数据的数据库中，并且可以将数据编入索引以便更快地进行排序查找。

但是，对于您自己开发的内存数据“store”，您应该HashMap进行id查找，TreeSet进行排序访问。

您没有指定您正在使用的排序，因此下面我假设您打算按price排序。

TreeSet要求元素是唯一的，因此要按price排序，您还需要按id进行排序，以使排序键唯一。 奖金副作用：对具有相同price的记录进行一致排序。

首先，我们完全定义您的Record类：

class Record implements Comparable<Record> {
    private int id;
    private double price;
    private int quantity;

    public Record(int id, double price, int quantity) {
        this.id = id;
        this.price = price;
        this.quantity = quantity;
    }

    public Record(double price, int id) {
        this.id = id;
        this.price = price;
    }

    public int getId() {
        return this.id;
    }

    public double getPrice() {
        return this.price;
    }

    public int getQuantity() {
        return this.quantity;
    }

    @Override
    public int compareTo(Record that) {
        int cmp = Double.compare(this.price, that.price);
        if (cmp == 0)
            cmp = Integer.compare(this.id, that.id);
        return cmp;
    }

    @Override
    public boolean equals(Object obj) {
        if (! (obj instanceof Record))
            return false;
        Record that = (Record) obj;
        return (this.id == that.id);
    }

    @Override
    public int hashCode() {
        return this.id;
    }
}

备用构造函数是下面DataStore的便利助手。

equals逻辑不需要hashCode和DataStore方法，但如果相等的定义很明确，那么实现它们总是一个好主意。

现在我们实现DataStore类，该类封装了同时拥有HashMap和TreeSet的逻辑：

class DataStore {
    private Map<Integer, Record> recordsById = new HashMap<>();
    private TreeSet<Record> recordsByPrice = new TreeSet<>();

    public Optional<Record> addOrReplace(Record newRecord) {
        Record oldRecord = this.recordsById.put(newRecord.getId(), newRecord);
        if (oldRecord != null)
            this.recordsByPrice.remove(oldRecord);
        this.recordsByPrice.add(newRecord);
        return Optional.ofNullable(oldRecord);
    }

    public Optional<Record> remove(int id) {
        Record oldRecord = this.recordsById.remove(id);
        if (oldRecord != null)
            this.recordsByPrice.remove(oldRecord);
        return Optional.ofNullable(oldRecord);
    }

    public Optional<Record> getById(int id) {
        return Optional.ofNullable(this.recordsById.get(id));
    }

    public NavigableSet<Record> getByPrice(double price) {
        return this.recordsByPrice.subSet(new Record(price, Integer.MIN_VALUE), true,
                                          new Record(price, Integer.MAX_VALUE), true);
    }

    public NavigableSet<Record> getByPriceRange(double fromPriceInclusive, double toPriceExclusive) {
        return this.recordsByPrice.subSet(new Record(fromPriceInclusive, Integer.MIN_VALUE), true,
                                          new Record(toPriceExclusive, Integer.MIN_VALUE), false);
    }
}

Java（openjdk版本＆＃34; 1.8.0_151＆＃34;，linux）内存中有数百万条记录。经常添加和请求排序数据

1 个答案: