1. Overview
1.概述
In this article, we’ll explore the LinkedHashSet class of the Java Collections API. We’ll dive into the features of this data structure and demonstrate its functionalities.
在这篇文章中，我们将探讨Java Collections API的LinkedHashSet类。我们将深入探讨这一数据结构的特性，并演示其功能。
2. Introduction to LinkedHashSet
2.介绍LinkedHashSet
The LinkedHashSet is a generic data structure that belongs to the Java.util library. It’s a direct descendant of the HashSet data structure, hence, contains non-duplicate elements at every given time.
LinkedHashSet是一个属于Java.util库的通用数据结构。它是HashSet数据结构的直接后裔，因此，在每个给定时间内都包含非重复的元素。
In addition to having a doubly-linked list running through all of its entries, its implementation is different from that of the HashSet in that it maintains a predictable iteration order. The iteration order is defined by the insertion order of the elements into the set.
除了有一个贯穿其所有条目的双链接列表之外，它的实现与HashSet不同，它保持了一个可预测的迭代顺序。迭代顺序是由元素在集合中的插入顺序定义的。
The LinkedHashSet saves the client from the unpredictable ordering provided by HashSet, without incurring the complexity that comes with a TreeSet.
LinkedHashSet将客户端从HashSet提供的不可预测的排序中解救出来，而不会产生TreeSet带来的复杂性。
While its performance is likely to be just slightly less than that of HashSet, due to the added expense of maintaining the linked list, it has constant-time (O1) performance for add(), contains() and remove() operations.
虽然其性能可能仅略低于HashSet，但由于维护链表的费用增加，它在add()、contains()和remove()操作中具有恒定时间（O1）的性能。
3. Create a LinkedHashSet
3.创建一个LinkedHashSet
There are several constructors available to create a LinkedHashSet. Let’s have a look at each one of them:
有几个构造函数可以用来创建一个LinkedHashSet。让我们来看看它们中的每一个。
3.1. Default No-Arg Constructor
3.1.默认的无机关构造函数
Set<String> linkedHashSet = new LinkedHashSet<>();
assertTrue(linkedHashSet.isEmpty());3.2. Create with an Initial Capacity
3.2.用初始容量创建
The initial capacity represents the initial length of the LinkedHashSet. Providing an initial capacity prevents any unnecessary resizing of the Set as it grows. The default initial capacity is 16:
初始容量代表LinkedHashSet的初始长度。提供一个初始容量可以防止在Set增长时进行任何不必要的大小调整。默认的初始容量是16。
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>(20);3.3. Create from a Collection
3.3.从一个集合创建
We can also use the content of a Collection to populate a LinkedHashSet object at the point of creation:
我们还可以在创建时使用Collection的内容来填充LinkedHashSet对象。
@Test
void whenCreatingLinkedHashSetWithExistingCollection_shouldContainAllElementOfCollection(){
Collection<String> data = Arrays.asList("first", "second", "third", "fourth", "fifth");
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>(data);
assertFalse(linkedHashSet.isEmpty());
assertEquals(data.size(), linkedHashSet.size());
assertTrue(linkedHashSet.containsAll(data) && data.containsAll(linkedHashSet));
}3.4. Create with Initial Capacity and Load Factor
3.4.用初始容量和负载系数创建
When the size of the LinkedHashSet grows to exceed the value of the initial capacity, the new capacity is the multiplication of the load factor and the previous capacity. In the below snippet, the initial capacity is set to 20 and the load factor is 3.
当LinkedHashSet的大小增长到超过初始容量的值时，新的容量是负载因子和先前容量的乘法。在下面的片段中，初始容量被设置为20，负载因子为3。
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>(20, 3);The default load factor is 0.75.
默认的负载系数是0.75。
4. Adding an Element to the LinkedHashSet
4.向LinkedHashSet添加一个元素
We can either add a single element or a Collection of elements to the LinkedHashSet by using the add() and addAll() methods respectively. An element will be added if it doesn’t already exist in the Set. These methods return true when an element is added to the set, otherwise, they return false.
我们可以通过使用add()和addAll()方法分别向LinkedHashSet中添加单个元素或Collection中的元素。 如果一个元素在Set中不存在，它将被添加。当一个元素被添加到集合中时，这些方法返回true，否则，它们返回false。
4.1. Add a Single Element
4.1.添加单一元素
Here’s an implementation to add an element to a LinkedHashSet:
这里有一个实现，向LinkedHashSet添加一个元素。
@Test
void whenAddingElement_shouldAddElement(){
Set<Integer> linkedHashSet = new LinkedHashSet<>();
assertTrue(linkedHashSet.add(0));
assertFalse(linkedHashSet.add(0));
assertTrue(linkedHashSet.contains(0));
}4.2. Add a Collection of Elements
4.2.添加一个元素的集合
As mentioned earlier, we can also add a Collection of elements to a LinkedHashSet:
如前所述，我们也可以将元素的Collection添加到LinkedHashSet。
@Test
void whenAddingCollection_shouldAddAllContentOfCollection(){
Collection<Integer> data = Arrays.asList(1,2,3);
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
assertTrue(linkedHashSet.addAll(data));
assertTrue(data.containsAll(linkedHashSet) && linkedHashSet.containsAll(data));
}The rule of not adding duplicates also applies to the addAll() method as demonstrated below:
不添加重复的规则也适用于addAll()方法，如下图所示。
@Test
void whenAddingCollectionWithDuplicateElements_shouldMaintainUniqueValuesInSet(){
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(2);
Collection<Integer> data = Arrays.asList(1, 1, 2, 3);
assertTrue(linkedHashSet.addAll(data));
assertEquals(3, linkedHashSet.size());
assertTrue(data.containsAll(linkedHashSet) && linkedHashSet.containsAll(data));
}Notice that the data variable contains duplicate values of 1 and the LinkedHashSet already contains the Integer value 2 before invoking the addAll() method.
注意，data变量包含重复的值1，而LinkedHashSet在调用addAll()方法之前已经包含Integer值2。
5. Iterating through a LinkedHashSet
5.遍历一个LinkedHashSet
Like every other descendant of the Collection library, we can iterate through a LinkedHashSet. Two types of iterators are available in a LinkedHashSet: Iterator and Spliterator.
像其他Collection库的后代一样，我们可以通过LinkedHashSet进行迭代。在LinkedHashSet中，有两种类型的迭代器可用。Iterator和Spliterator。
While the former is only able to traverse and perform any basic operation on a Collection, the latter splits the Collection into subsets and performs different operations on each subset in parallel, thereby making it thread-safe.
前者只能对Collection进行遍历和执行任何基本操作，而后者将Collection分割成子集，并对每个子集并行执行不同的操作，从而使其成为线程安全的。
5.1. Iterating with an Iterator
5.1.用一个迭代器进行迭代
@Test
void whenIteratingWithIterator_assertThatElementIsPresent(){
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(0);
linkedHashSet.add(1);
linkedHashSet.add(2);
Iterator<Integer> iterator = linkedHashSet.iterator();
for (int i = 0; i < linkedHashSet.size(); i++) {
int nextData = iterator.next();
assertEquals(i, nextData);
}
}5.2. Iterating with a Spliterator
5.2.用分割器进行迭代
@Test
void whenIteratingWithSpliterator_assertThatElementIsPresent(){
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(0);
linkedHashSet.add(1);
linkedHashSet.add(2);
Spliterator<Integer> spliterator = linkedHashSet.spliterator();
AtomicInteger counter = new AtomicInteger();
spliterator.forEachRemaining(data -> {
assertEquals(counter.get(), (int)data);
counter.getAndIncrement();
});
}6. Remove Elements from the LinkedHashSet
6.从 LinkedHashSet中移除元素
Here are the different ways to remove an element from the LinkedHashSet:
下面是从LinkedHashSet中移除一个元素的不同方法。
6.1. remove()
6.1.remove()
This method removes an element from the Set given that we know the exact element we want to remove. It accepts an argument that’s the actual element we want to remove and returns true if successfully removed, otherwise false:
这个方法从Set中移除一个元素，前提是我们知道我们想要移除的确切元素。它接受一个参数，即我们想要移除的实际元素，如果成功移除，则返回true，否则false。
@Test
void whenRemovingAnElement_shouldRemoveElement(){
Collection<String> data = Arrays.asList("first", "second", "third", "fourth", "fifth");
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>(data);
assertTrue(linkedHashSet.remove("second"));
assertFalse(linkedHashSet.contains("second"));
}6.2. removeIf()
6.2.removeIf()
The removeIf() method removes an element that satisfies specified predicate conditions. The example below removes all elements in the LinkedHashSet that are greater than 2:
removeIf()方法删除了满足指定谓词条件的元素。下面的例子删除了LinkedHashSet中所有大于2的元素。
@Test
void whenRemovingAnElementGreaterThanTwo_shouldRemoveElement(){
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(0);
linkedHashSet.add(1);
linkedHashSet.add(2);
linkedHashSet.add(3);
linkedHashSet.add(4);
linkedHashSet.removeIf(data -> data > 2);
assertFalse(linkedHashSet.contains(3));
assertFalse(linkedHashSet.contains(4));
}6.3. Removing with an Iterator
6.3.用一个迭代器来删除
The iterator is also another option we can use to remove elements from the LinkedHashSet. The remove() method of the Iterator removes the element that the Iterator is currently on:
iterator也是我们可以用来从LinkedHashSet中移除元素的另一个选项。迭代器的remove()方法会移除迭代器当前所在的元素。
@Test
void whenRemovingAnElementWithIterator_shouldRemoveElement(){
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(0);
linkedHashSet.add(1);
linkedHashSet.add(2);
Iterator<Integer> iterator = linkedHashSet.iterator();
int elementToRemove = 1;
assertTrue(linkedHashSet.contains(elementToRemove));
while(iterator.hasNext()){
if(elementToRemove == iterator.next()){
iterator.remove();
}
}
assertFalse(linkedHashSet.contains(elementToRemove));
}7. Conclusion
7.结语
In this article, we studied the LinkedHashSet data structure from the Java Collections library. We demonstrated how to create a LinkedHashSet through its different constructors, adding and removing elements, as well as iterating through it. We also, learned the underlying layers of this data structure, its advantage over the HashSet as well as the time complexity for its common operations.
在这篇文章中，我们研究了JavaCollections库中的LinkedHashSet数据结构。我们演示了如何通过不同的构造函数创建LinkedHashSet，添加和删除元素，以及迭代它。我们还学习了这种数据结构的底层，它相对于HashSet的优势，以及其常见操作的时间复杂性。
As always, code snippets can be found over on GitHub.
像往常一样，代码片段可以在GitHub上找到over。