HashSet 与 LinkedHashSet

Question

它们之间有什么区别？我知道

LinkedHashSet 是 HashSet 的有序版本， 维护一个跨所有元素的双向链接列表。使用此类代替 HashSet 当您关心迭代顺序时。当你迭代 HashSet 时 顺序是不可预测的，而 LinkedHashSet 允许您迭代元素 按照它们插入的顺序。

但是在LinkedHashSet的源代码中，只有调用HashSet的构造函数。那么双链表和插入顺序在哪里呢？

Answer 1

HashSet 是无序且未排序的集合。
LinkedHashSet 是 HashSet 的有序版本。

HashSet 和 LinkedHashSet 之间的唯一区别是：
LinkedHashSet 维护插入顺序。

当我们迭代HashSet时，顺序是不可预测的，而LinkedHashSet的顺序是可预测的。

LinkedHashSet 维护插入顺序的原因是：
底层使用的数据结构是双向链表。

Answer 2

LinkedHashSet 的构造函数调用以下基类构造函数：

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
  map = new LinkedHashMap<E, Object>(initialCapacity, loadFactor);
}

如您所见，内部映射是一个 LinkedHashMap。如果您查看 LinkedHashMap 内部，您会发现以下字段：

private transient Entry<K, V> header;

这是有问题的链接列表。

Answer 3

我建议您大多数时候使用LinkedHashSet，因为它总体性能更好）：

1. 可预测 迭代顺序LinkedHashSet (Oracle)
2. LinkedHashSet 的插入操作比 HashSet 更昂贵；
3. 一般来说，性能比HashMap稍好，因为大多数时候我们使用Set结构进行迭代。

性能测试：

------------- TreeSet -------------
 size       add  contains   iterate
   10       746       173        89
  100       501       264        68
 1000       714       410        69
10000      1975       552        69
------------- HashSet -------------
 size       add  contains   iterate
   10       308        91        94
  100       178        75        73
 1000       216       110        72
10000       711       215       100
---------- LinkedHashSet ----------
 size       add  contains   iterate
   10       350        65        83
  100       270        74        55
 1000       303       111        54
10000      1615       256        58

您可以在此处查看源测试页面：最终性能测试示例

Answer 4

您应该查看它调用的 HashSet 构造函数的源代码...它是一个特殊的构造函数，使支持 Map 成为 LinkedHashMap 而不仅仅是一个HashMap。

Answer 5

HashSet 不维护插入项的顺序
LinkedHashSet 维持插入项的顺序

示例

Set<String> set = ...;// using new HashSet<>() OR new LinkedHashSet<>()
set.add("2");
set.add("1");
set.add("ab");
for(String value : set){
   System.out.println(value);
}  

HashSet 输出

1
ab
2

LinkedHashSet 输出

2
1
ab

Answer 6

哈希集：
实际上是无序的。
如果你传递参数意味着

Set<Integer> set=new HashSet<Integer>();
for(int i=0;i<set.length;i++)
{
  SOP(set)`enter code here`
}

Out Put：
可能2,1,3不可预测。下次再下单。

LinkedHashSet() 产生 FIFO 顺序。

Answer 7

HashSet：

下划线的数据结构是Hashtable。
不允许重复的对象。插入顺序不会保留，并且基于对象的哈希码。
可以插入空值（仅一次）。
它实现了 Serializable、Clonable 但没有 RandomAccess 接口。
如果频繁的操作是查找操作，最好选择HashSet。

在 HashSet 中不允许重复。如果用户在我们不会得到任何编译或运行时异常的情况下尝试插入重复。 add 方法返回 false。

构造函数：

HashSet h=new HashSet();创建一个空的 HashSet 对象，默认初始容量为 16，默认填充率（负载因子）为 0.75 。

HashSet h=new HashSet(int initialCapacity);创建一个具有指定initialCapacity的空HashSet对象，默认填充率为0.75。

HashSet h=new HashSet(int initialCapacity, float fillRatio);

HashSet h=new HashSet(集合c);为给定集合创建一个等效的 HashSet 对象。该构造函数用于集合对象之间的相互转换。

LinkedHashSet：

它是HashSet的子类。它与 HashSet 完全相同，包括（构造函数和方法），但有以下差异。

差异
HashSet：

1. 下划线的数据结构就是Hashtable。
2. 不保留插入顺序。
3. 推出1.2版本。

LinkedHashSet：

1. 下划线的数据结构是LinkedList和Hashtable的组合。
2. 保留插入顺序。
3. 1.4版本引入。

Answer 8

如果您查看从 LinkedHashSet 类调用的构造函数，您会发现在内部它是一个用于支持目的的 LinkedHashMap。

Answer 9

所有方法和构造函数都是相同的，但只有一个区别是 LinkedHashset 将保持插入顺序，但不允许重复。

哈希集不会维护任何插入顺序。
它是 List 和 Set 的简单组合:)

Answer 10

正如您所说，两者之间的区别是：

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

至于你的问题：

但是LinkedHashSet的源代码中只有调用HashSet的构造函数。

答案在于 LinkedHashSet 使用哪些构造函数来构造基类：

public LinkedHashSet(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor, true);      // <-- boolean dummy argument
}

...

public LinkedHashSet(int initialCapacity) {
    super(initialCapacity, .75f, true);            // <-- boolean dummy argument
}

...

public LinkedHashSet() {
    super(16, .75f, true);                         // <-- boolean dummy argument
}

...

public LinkedHashSet(Collection<? extends E> c) {
    super(Math.max(2*c.size(), 11), .75f, true);   // <-- boolean dummy argument
    addAll(c);
}

以及采用布尔参数的 HashSet 构造函数（一个示例）被描述，看起来像这样：

/**
 * Constructs a new, empty linked hash set.  (This package private
 * constructor is only used by LinkedHashSet.) The backing
 * HashMap instance is a LinkedHashMap with the specified initial
 * capacity and the specified load factor.
 *
 * @param      initialCapacity   the initial capacity of the hash map
 * @param      loadFactor        the load factor of the hash map
 * @param      dummy             ignored (distinguishes this
 *             constructor from other int, float constructor.)
 * @throws     IllegalArgumentException if the initial capacity is less
 *             than zero, or if the load factor is nonpositive
 */
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
}