在需要唯一元素和按索引访问时设置 vs 列表

Question

我需要保留一个唯一的元素列表，并且我还需要不时从它们中随机选择一个。我有两种简单的方法可以做到这一点。

1. 让元素出现在一个集合中——这让我拥有了元素的独特性。当需要随机选择一个时，请执行以下操作：

   elementsSeen.toArray()[random.nextInt(elementsSeen.size())]
   

2. 保留在列表中看到的元素 - 这样不需要转换为数组，因为当我需要随机请求时，有 get() 函数。但是这里我需要在添加时这样做。

   if (elementsSeen.indexOf(element)==-1) {elementsSeen.add(element);}
   

所以我的问题是哪种方式更有效？转换为数组更消耗还是 indexOf 更糟？如果尝试添加元素的次数增加了 10 次、100 次或 1000 次怎么办？

我对如何以最高效的方式将列表的功能（按索引访问）与集合的功能（唯一添加）结合起来很感兴趣。

Answer 1

如果使用更多内存不是问题，那么您可以通过在包装器中同时使用 list 和 set 来获得两者的最佳效果：

public class MyContainer<T> {
    private final Set<T> set = new HashSet<>();
    private final List<T> list = new ArrayList<>();

    public void add(T e) {
        if (set.add(e)) {
            list.add(e);
        }
    }

    public T getRandomElement() {
        return list.get(ThreadLocalRandom.current().nextInt(list.size()));
    }
    // other methods as needed ...
}

Answer 2

HashSet 和 TreeSet 都扩展了AbstractCollection，其中包括toArray() 的实现，如下所示：

public Object[] toArray() {
    // Estimate size of array; be prepared to see more or fewer elements
    Object[] r = new Object[size()];
    Iterator<E> it = iterator();
    for (int i = 0; i < r.length; i++) {
        if (! it.hasNext()) // fewer elements than expected
            return Arrays.copyOf(r, i);
        r[i] = it.next();
    }
    return it.hasNext() ? finishToArray(r, it) : r;
}

如您所见，它负责为数组分配空间，以及创建一个Iterator 对象进行复制。因此，对于Set，添加是 O(1)，但由于元素复制操作，检索随机元素将是 O(N)。

另一方面，List 允许您快速访问支持数组中的特定索引，但不保证唯一性。您必须重新实现 add、remove 和相关方法以保证插入时的唯一性。添加唯一元素将是 O(N)，但检索将是 O(1)。

因此，这实际上取决于哪个区域是您潜在的高使用点。是否会大量使用添加/删除方法，而很少使用随机访问？或者这将是一个最重要的检索容器，因为在程序的生命周期内几乎没有添加或删除元素？

如果是前者，我建议使用Set 和toArray()。如果是后者，实现一个唯一的 List 以利用快速检索可能对您有利。显着的缺点是add 包含许多边缘情况，标准 Java 库非常注意以有效的方式处理这些情况。您的实施会达到相同的标准吗？

Answer 3

编写一些测试代码并为您的用例输入一些实际值。如果性能对您来说是一个真正的问题，那么这两种方法都不会太复杂以至于不值得付出努力。

我根据您所描述的确切两种方法快速尝试了该方法，由于indexOf 方法的速度较慢，如果您添加的内容远远多于检索的内容，那么 Set 实现似乎会更快。但我真的建议您自己进行测试 - 您是唯一知道细节可能是什么的人。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

public class SetVsListTest<E> {
    private static Random random = new Random();
    private Set<E> elementSet;
    private List<E> elementList;

    public SetVsListTest() {
        elementSet = new HashSet<>();
        elementList = new ArrayList<>();
    }

    private void listAdd(E element) {
        if (elementList.indexOf(element) == -1) {
            elementList.add(element);
        }
    }

    private void setAdd(E element) {
        elementSet.add(element);
    }

    private E listGetRandom() {
        return elementList.get(random.nextInt(elementList.size()));
    }

    @SuppressWarnings("unchecked")
    private E setGetRandom() {
        return (E) elementSet.toArray()[random.nextInt(elementSet.size())];
    }

    public static void main(String[] args) {
        SetVsListTest<Integer> test;
        List<Integer> testData = new ArrayList<>();
        int testDataSize = 100_000;
        int[] addToRetrieveRatios = new int[] { 10, 100, 1000, 10000 };

        for (int i = 0; i < testDataSize; i++) {
            /*
             * Add 1/5 of the total possible number of elements so that we will
             * have (on average) 5 duplicates of each number. Adjust this to
             * whatever is most realistic
             */
            testData.add(random.nextInt(testDataSize / 5));
        }

        for (int addToRetrieveRatio : addToRetrieveRatios) {
            /*
             * Test the list method
             */
            test = new SetVsListTest<>();
            long t1 = System.nanoTime();
            for(int i=0;i<testDataSize; i++) {
                // Use == 1 here because we don't want to get from an empty collection
                if(i%addToRetrieveRatio == 1) {
                    test.listGetRandom();
                } else {
                    test.listAdd(testData.get(i));
                }
            }
            long t2 = System.nanoTime();
            System.out.println(((t2-t1)/1000000L)+" ms for list method with add/retrieve ratio "+addToRetrieveRatio);

            /*
             * Test the set method
             */
            test = new SetVsListTest<>();
            t1 = System.nanoTime();
            for(int i=0;i<testDataSize; i++) {
                // Use == 1 here because we don't want to get from an empty collection
                if(i%addToRetrieveRatio == 1) {
                    test.setGetRandom();
                } else {
                    test.setAdd(testData.get(i));
                }
            }
            t2 = System.nanoTime();
            System.out.println(((t2-t1)/1000000L)+" ms for set method with add/retrieve ratio "+addToRetrieveRatio);
        }
    }
}

我机器上的输出是：

819 ms for list method with add/retrieve ratio 10
1204 ms for set method with add/retrieve ratio 10
1547 ms for list method with add/retrieve ratio 100
133 ms for set method with add/retrieve ratio 100
1571 ms for list method with add/retrieve ratio 1000
23 ms for set method with add/retrieve ratio 1000
1542 ms for list method with add/retrieve ratio 10000
5 ms for set method with add/retrieve ratio 10000

Answer 4

您可以扩展 HashSet 并跟踪对它的更改，维护所有条目的当前数组。

在这里，我保留了数组的副本，并在每次集合更改时对其进行调整。要获得更强大（但成本更高）的解决方案，您可以在 pick 方法中使用 toArray。

class PickableSet<T> extends HashSet<T> {
    private T[] asArray = (T[]) this.toArray();

    private void dirty() {
        asArray = (T[]) this.toArray();
    }

    public T pick(int which) {
        return asArray[which];
    }

    @Override
    public boolean add(T t) {
        boolean added = super.add(t);
        dirty();
        return added;
    }

    @Override
    public boolean remove(Object o) {
        boolean removed = super.remove(o);
        dirty();
        return removed;
    }
}

请注意，如果被 Iterator 删除，这将无法识别对集合的更改 - 您需要以其他方式处理。

Answer 5

所以我的问题是哪种方式更有效？

这是一个很难回答的问题，具体取决于一个人的更多操作、插入或随机选择？

我们需要查看每个操作的Big O。在this case（最好的情况下）：

• 设置：插入 O(1)
• 设置：toArray O(n)（我假设）
• 数组：访问 O(1)

对

• 列表：包含 O(n)
• 列表：插入 O(1)
• 列表：访问 O(1)

所以：

• 设置：插入：O(1)，访问 O(n)
• 列表：插入：O(n)，访问 O(1)

因此，在最好的情况下，如果您插入的数量超过您选择的数量，那么 Set 获胜，如果相反，则 List 获胜。

现在是邪恶的答案 - 选择一个（最能代表问题的那个（所以设置 IMO）），将其包装好并运行它。如果它太慢，那么稍后再处理，当你处理它时，看看问题空间。您的数据是否经常更改？不，缓存数组。

Answer 6

这取决于你更看重什么。

List Java 中的实现通常使用数组或链表。这意味着插入和搜索索引很快，但搜索特定元素需要循环考虑列表并比较每个元素，直到找到该元素。

Java 中的Set 实现主要使用数组、hashCode 方法和equals 方法。因此，当您要插入时，集合更费力，但在查找元素时胜过列表。由于集合不保证结构中元素的顺序，因此您将无法通过索引获取元素。您可以使用有序集，但这会由于排序而导致插入延迟。

如果您要直接使用索引，那么您可能必须使用List，因为将元素放入Set.toArray() 的顺序会随着您向Set 添加元素而改变。

希望这会有所帮助:)