哈希集与树集

Question

我一直很喜欢树木，很漂亮O(n*log(n)) 和它们的整洁。然而，我认识的每一位软件工程师都尖锐地问我为什么要使用TreeSet。从 CS 的背景来看，我认为你使用什么并不重要，我也不想乱用哈希函数和存储桶（在 Java 的情况下）。

在哪些情况下我应该使用HashSet 而不是TreeSet？

Answer 1

HashSet 比 TreeSet 快得多（对于添加、删除和包含等大多数操作而言，HashSet 是常数时间与日志时间），但不提供像 TreeSet 那样的排序保证。

HashSet

• 该类为基本操作（添加、删除、包含和大小）提供恒定的时间性能。
• 它不保证元素的顺序会随着时间的推移保持不变
• 迭代性能取决于HashSet的初始容量和负载因子。
  • 接受默认负载因子是相当安全的，但您可能希望指定一个大约是您期望集合增长到的大小的两倍的初始容量。

TreeSet

• 保证基本操作（添加、删除和包含）的 log(n) 时间成本
• 保证 set 的元素将被排序（升序、自然或您通过其构造函数指定的排序）（实现 SortedSet）
• 不提供任何迭代性能的调整参数
• 提供了一些方便的方法来处理有序集，例如first()、last()、headSet() 和tailSet() 等

要点：

• 两者都保证元素的无重复集合
• 向 HashSet 添加元素然后将集合转换为 TreeSet 以进行无重复排序遍历通常更快。
• 这些实现都不同步。也就是说，如果多个线程同时访问一个集合，并且至少有一个线程修改了该集合，则它必须在外部同步。
• LinkedHashSet 在某种意义上介于HashSet 和TreeSet 之间。但是，它实现为带有链表的哈希表，它提供了与 TreeSet 保证的排序遍历不同的插入顺序迭代。

所以使用方式的选择完全取决于你的需求，但我觉得即使你需要一个有序的集合，你仍然应该更喜欢 HashSet 来创建 Set 然后将其转换为 TreeSet。

• 例如SortedSet<String> s = new TreeSet<String>(hashSet);

Answer 2

TreeSet 尚未提及的一个优点是它具有更大的“局部性”，这是表示 (1) 如果两个条目在顺序中靠近，TreeSet 将它们彼此靠近放置在数据结构，因此在内存中； (2) 这种布局利用了局部性原则，即应用程序经常以相似的频率访问相似的数据。

这与HashSet 形成对比，HashSet 将条目分布在整个内存中，无论它们的键是什么。

当从硬盘读取的延迟成本是从缓存或 RAM 读取的成本的数千倍时，并且当数据真正通过本地访问时，TreeSet 可能是更好的选择。

Answer 3

HashSet 是 O(1) 访问元素，所以它确实很重要。但是保持集合中对象的顺序是不可能的。

TreeSet 如果维护订单（就价值而非插入顺序而言）对您很重要，则很有用。但是，正如您所指出的，您正在交易订单以换取访问元素的更慢时间：基本操作为 O(log n)。

来自javadocs for TreeSet：

此实现为基本操作（add、remove 和 contains）提供有保证的 log(n) 时间成本。

Answer 4

根据@shevchyk 在地图上可爱的visual answer，这是我的看法：

╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║   Property   ║       HashSet       ║      TreeSet      ║     LinkedHashSet   ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║  no guarantee order ║ sorted according  ║                     ║
║   Order      ║ will remain constant║ to the natural    ║    insertion-order  ║
║              ║      over time      ║    ordering       ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ Add/remove   ║        O(1)         ║     O(log(n))     ║        O(1)         ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║                     ║   NavigableSet    ║                     ║
║  Interfaces  ║         Set         ║       Set         ║         Set         ║
║              ║                     ║    SortedSet      ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║                     ║    not allowed    ║                     ║
║  Null values ║       allowed       ║ 1st element only  ║      allowed        ║
║              ║                     ║     in Java 7     ║                     ║
╠══════════════╬═════════════════════╩═══════════════════╩═════════════════════╣
║              ║   Fail-fast behavior of an iterator cannot be guaranteed      ║
║   Fail-fast  ║ impossible to make any hard guarantees in the presence of     ║
║   behavior   ║           unsynchronized concurrent modification              ║
╠══════════════╬═══════════════════════════════════════════════════════════════╣
║      Is      ║                                                               ║
║ synchronized ║              implementation is not synchronized               ║
╚══════════════╩═══════════════════════════════════════════════════════════════╝

Answer 5

1.HashSet 允许空对象。

2.TreeSet 不允许空对象。如果您尝试添加 null 值，它将抛出 NullPointerException。

3.HashSet 比 TreeSet 快很多。

例如

 TreeSet<String> ts = new TreeSet<String>();
 ts.add(null); // throws NullPointerException

 HashSet<String> hs = new HashSet<String>();
 hs.add(null); // runs fine

Answer 6

大多数使用HashSet 的原因是操作（平均）是 O(1) 而不是 O(log n)。如果该集合包含标准项目，您将不会像已经为您完成的那样“搞乱哈希函数”。如果该集合包含自定义类，则必须实现 hashCode 才能使用 HashSet（尽管 Effective Java 显示了如何），但如果使用 TreeSet，则必须使其成为 Comparable 或提供 Comparator。如果类没有特定的顺序，这可能是个问题。

我有时将TreeSet（或实际上TreeMap）用于非常小的集合/地图（

现在，如果您需要排序，那么TreeSet 是合适的，尽管即使更新频繁并且对排序结果的需求很少，有时将内容复制到列表或数组并对其进行排序会更快.

Answer 7

如果您没有插入足够多的元素而导致频繁的重新散列（或冲突，如果您的 HashSet 无法调整大小），那么 HashSet 肯定会为您提供恒定时间访问的好处。但在具有大量增长或收缩的集合上，您实际上可能会使用 Treesets 获得更好的性能，具体取决于实现。

如果我没记错的话，使用功能红黑树的摊销时间可以接近 O(1)。冈崎的书会有比我能理解的更好的解释。 （或见his publication list）

Answer 8

HashSet 的实现当然要快得多——因为没有排序，所以开销更少。 http://java.sun.com/docs/books/tutorial/collections/implementations/set.html 提供了对 Java 中各种 Set 实现的良好分析。

那里的讨论还指出了一种有趣的“中间立场”方法来解决 Tree vs Hash 问题。 Java提供了一个LinkedHashSet，它是一个HashSet，其中运行着一个“面向插入”的链表，即链表中的最后一个元素也是最近插入到Hash中的元素。这使您可以避免无序散列的不规则性，而不会增加 TreeSet 的成本。

Answer 9

TreeSet 是两个排序集合之一（另一个是 树形图）。它使用红黑树结构（但你知道），并保证 根据自然顺序，元素将按升序排列。可选地， 您可以使用构造函数构造一个 TreeSet，该构造函数可让您为集合提供您的 自己的顺序应该是什么规则（而不是依赖于定义的顺序 通过元素的类）通过使用 Comparable 或 Comparator

而 LinkedHashSet 是 HashSet 的有序版本，它 维护所有元素的双向链表。使用此类而不是 HashSet 当您关心迭代顺序时。当您遍历 HashSet 时 顺序是不可预测的，而 LinkedHashSet 允许您遍历元素 按插入顺序

Answer 10

既然可以吃橙子，为什么还要吃苹果？

说真的，伙计们 - 如果您的集合很大，读取和写入的次数达到了无数次，并且您要为 CPU 周期付费，那么只有当您需要更好地执行该集合时，该集合的选择才是相关的。然而，在大多数情况下，这并不重要——从人类的角度来看，这里和那里的几毫秒都不会被注意到。如果它真的那么重要，你为什么不用汇编程序或 C 编写代码呢？ [提示另一个讨论]。所以关键是，如果您对使用您选择的任何集合感到满意，并且它解决了您的问题（即使它不是专门针对该任务的最佳集合类型），那么您就会被淘汰出局。该软件具有延展性。在必要时优化您的代码。 Bob 大叔说，过早优化是万恶之源。 Uncle Bob says so

Answer 11

即使在 11 年后，也没有人想到提及一个非常重要的差异。

你认为如果HashSet 等于TreeSet 那么相反的情况也是如此吗？看看这段代码：

TreeSet<String> treeSet = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
HashSet<String> hashSet = new HashSet<>();
treeSet.add("a");
hashSet.add("A");
System.out.println(hashSet.equals(treeSet));
System.out.println(treeSet.equals(hashSet));

尝试猜测输出，然后将鼠标悬停在 sn-p 下方以查看实际输出是什么。准备好？给你：

假
真的

没错，对于与 equals 不一致的比较器，它们不具有等价关系。原因是TreeSet 使用比较器来确定等价性，而HashSet 使用equals。在内部，他们使用HashMap 和TreeMap，因此您也应该预料到上述Maps 也会出现这种行为。

Originally answered

Answer 12

消息编辑（完全重写）当顺序无关紧要时，那就是时候了。两者都应该给出 Log(n) - 看看其中一个是否比另一个快 5% 以上会很有用。 HashSet 可以给 O(1) 测试，在一个循环中应该可以揭示它是否是。

Answer 13

基于技术考虑，尤其是在性能方面，已经给出了很多答案。 在我看来，TreeSet 和 HashSet 之间的选择很重要。

但我宁愿说，选择应该首先由概念考虑。

如果对于您需要操作的对象，自然排序没有意义，那么不要使用TreeSet。
它是一个排序集，因为它实现了SortedSet。所以这意味着你需要重写函数compareTo，这应该与返回函数equals的内容一致。例如，如果您有一组名为 Student 的类的对象，那么我认为 TreeSet 没有意义，因为学生之间没有自然排序。你可以按他们的平均成绩排序，好吧，但这不是“自然排序”。函数compareTo 不仅会在两个对象代表同一个学生时返回 0，而且当两个不同学生的年级相同时也会返回 0。对于第二种情况，equals 将返回 false（除非您决定让后者在两个不同学生的成绩相同时返回 true，这会使 equals 函数具有误导性的含义，而不是说错误的含义。）
请注意equals 和compareTo 之间的一致性是可选的，但强烈推荐。否则接口Set的约定被破坏，使你的代码误导其他人，从而也可能导致意外行为。

这个 link 可能是关于这个问题的一个很好的信息来源。

Answer 14

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class HashTreeSetCompare {

    //It is generally faster to add elements to the HashSet and then
    //convert the collection to a TreeSet for a duplicate-free sorted
    //Traversal.

    //really? 
    O(Hash + tree set) > O(tree set) ??
    Really???? Why?



    public static void main(String args[]) {

        int size = 80000;
        useHashThenTreeSet(size);
        useTreeSetOnly(size);

    }

    private static void useTreeSetOnly(int size) {

        System.out.println("useTreeSetOnly: ");
        long start = System.currentTimeMillis();
        Set<String> sortedSet = new TreeSet<String>();

        for (int i = 0; i < size; i++) {
            sortedSet.add(i + "");
        }

        //System.out.println(sortedSet);
        long end = System.currentTimeMillis();

        System.out.println("useTreeSetOnly: " + (end - start));
    }

    private static void useHashThenTreeSet(int size) {

        System.out.println("useHashThenTreeSet: ");
        long start = System.currentTimeMillis();
        Set<String> set = new HashSet<String>();

        for (int i = 0; i < size; i++) {
            set.add(i + "");
        }

        Set<String> sortedSet = new TreeSet<String>(set);
        //System.out.println(sortedSet);
        long end = System.currentTimeMillis();

        System.out.println("useHashThenTreeSet: " + (end - start));
    }
}