添加到集合然后对其进行排序或添加到已排序的集合是否更快？

Question 1

如果我有Map这样的话：

HashMap<Integer, ComparableObject> map;

并且我想获得使用自然顺序排序的值的集合，哪种方法最快？

（一种）

创建一个可排序集合的实例，例如ArrayList，添加值，然后对其进行排序：

List<ComparableObject> sortedCollection = new ArrayList<ComparableObject>(map.values());
Collections.sort(sortedCollection);

（B）

创建一个有序集合的实例，例如TreeSet，然后添加值：

Set<ComparableObject> sortedCollection = new TreeSet<ComparableObject>(map.values());

请注意，结果集合永远不会被修改，因此排序只需要进行一次。

Question 2

TreeSet具有方法的 log(n)时间复杂度保证add()/remove()/contains()。对ArrayListtakesn*log(n)操作进行排序，但add()/get()只进行1take操作。

因此，如果您主要是检索并且不经常排序，ArrayList则是更好的选择。如果您经常排序但不检索太多内容TreeSet将是更好的选择。

Question 3

从理论上讲，排序应该更快。在整个过程中保持排序状态可能需要更多的CPU时间。

从CS的角度来看，这两个操作都是NlogN，但是1类应具有较低的常数。

Question 4

为什么不使用两全其美？如果不再使用它，请使用TreeSet排序并使用内容初始化ArrayList

List<ComparableObject> sortedCollection = 
    new ArrayList<ComparableObject>( 
          new TreeSet<ComparableObject>(map.values()));

编辑：

我已经创建了一个基准测试（您可以在pastebin.com/5pyPMJav上访问它）来测试这三种方法（ArrayList + Collections.sort，TreeSet和我两全其美的方法），并且我的方法总是成功的。测试文件创建了一个包含10000个元素的映射，这些元素的值有一个故意比较糟糕的比较器，然后，这三种策略中的每一种都有机会a）对数据进行排序并b）对其进行迭代。这是一些示例输出（您可以自己测试）：

编辑：我添加了一个方面，可以记录对Thingy.compareTo（Thingy）的调用，并且我还添加了一个基于PriorityQueues的新策略，该策略比以前的任何一种解决方案都快得多（至少在排序方面）。

compareTo() calls:123490
Transformer ArrayListTransformer
    Creation: 255885873 ns (0.255885873 seconds) 
    Iteration: 2582591 ns (0.002582591 seconds) 
    Item count: 10000

compareTo() calls:121665
Transformer TreeSetTransformer
    Creation: 199893004 ns (0.199893004 seconds) 
    Iteration: 4848242 ns (0.004848242 seconds) 
    Item count: 10000

compareTo() calls:121665
Transformer BestOfBothWorldsTransformer
    Creation: 216952504 ns (0.216952504 seconds) 
    Iteration: 1604604 ns (0.001604604 seconds) 
    Item count: 10000

compareTo() calls:18819
Transformer PriorityQueueTransformer
    Creation: 35119198 ns (0.035119198 seconds) 
    Iteration: 2803639 ns (0.002803639 seconds) 
    Item count: 10000

奇怪的是，我的方法在迭代中表现最佳（我本以为在迭代中与ArrayList方法没有区别，基准测试中是否有错误？）

免责声明：我知道这可能是一个糟糕的基准，但是它可以帮助您理解要点，我当然没有操纵它来使自己的方法成功。

（该代码具有与equals / hashcode / compareTo构建器相同的apache commons / lang依赖性，但是应该很容易将其重构）

Question 5

如果选择实现B，请务必阅读我在底部对TreeSet的评论。

如果您的应用程序仅偶尔进行排序，但要经过很多次迭代，那么我建议您最好使用简单的未排序列表。一次排序，然后受益于更快的迭代。在数组列表上，迭代特别快。

但是，如果您希望始终保证排序顺序，或者您可能经常添加/删除元素，则可以使用已排序的集合并进行迭代。

因此，在您的情况下，我会说A）是更好的选择。该列表仅排序一次，不会改变，因此可以从数组中受益。迭代应该非常快，尤其是如果您知道它的ArrayList并且可以直接使用ArrayList.get（）而不是Iterator的话。

我还要添加一个定义，TreeSet是一个Set，这意味着对象是唯一的。TreeSet通过在Comparator / Comparable上使用compareTo来确定相等性。如果尝试添加两个其compareTo返回值为0的对象，则很容易发现自己丢失了数据。例如，将“ C”，“ A”，“ B”，“ A”添加到TreeSet中将返回“ A”，“ B” “， “C”

Question 6

Collections.sort 使用具有O（nlog n）的mergeSort。

TreeSet具有底层的Red-Black树，基本操作具有O（logn）。因此，n个元素也具有O（nlog n）。

因此两者都是相同的大O算法。

Question 7

插入SortedSet中的是O（log（n））（但是，当前n，而不是最后一个n）。插入列表为1。

插入中已经包括了SortedSet中的排序，因此它为0。列表中的排序为O（n * log（n））。

所以SortedSet的总复杂度为O（n * k），除最后一种情况外，所有情况下k <log（n）。相反，列表的总复杂度为O（n * log（n）+ n），因此O（n * log（n））。

因此，SortedSet在数学上具有最佳性能。但是最后，您有了一个Set而不是一个List（因为SortedList不存在），并且Set为您提供的功能少于List。因此，我认为，针对可用功能和性能的最佳解决方案是Sean Patrick Floyd提出的解决方案：

使用SortedSet进行插入，
将SortedSet作为创建要返回的List的参数。

Question 8

好问题，好答案。只是想我会考虑一些要点：

例如，如果要排序的Collection是短暂的（例如，用作方法的参数），并且您需要在方法内对列表进行排序，则可以使用Collections.sort（collection）。或者，如果它是长期存在的对象，但是您很少需要对其进行排序。

理由：排序的集合是特定内容所必需的，您可能不会经常添加或删除。因此，对集合中的元素进行排序后，就不必再在意了。您基本上是：

排序->使用它->忘记

如果将新元素添加到已排序的集合中，则必须再次对集合进行排序，因为在插入新元素时不能保证顺序。

如果您的收藏进行排序的长寿命和/或如果它是一个类中的一个字段，你需要它的排序任何时候都那么你应该使用一个排序的数据结构，如TreeSet中。

理由：您一直在乎收款顺序。您希望始终对其进行排序。因此，如果您不断添加或删除元素，则可以保证对集合进行了排序。所以基本上：

插入/删除->使用它（只要能保证对集合进行了排序就可以）

没有特定的时刻需要对集合进行排序，相反，您希望一直对集合进行排序。

使用TreeSet的缺点是保留排序后的集合所需的资源。它使用一棵红黑树，并且获取，放置操作需要O（log n）时间成本。

而如果使用简单的集合（例如ArrayList），则get，add操作为O（1）恒定时间。