原文： https://www.programiz.com/java-programming/linkedhashset

在本教程中，我们将借助示例学习 Java LinkedHashSet类及其方法。

Java 集合框架的LinkedHashSet类提供哈希表和链表数据结构的功能。

它实现了Set接口。

Java `LinkedHashSet` - 图1

LinkedHashSet的元素存储在类似于HashSet的哈希表中。

但是，链接哈希集在内部为其所有元素维护一个双链表。 链表定义了在哈希表中插入元素的顺序。

创建一个LinkedHashSet

为了创建链接的哈希集，我们必须首先导入java.util.LinkedHashSet包。

导入包后，就可以在 Java 中创建链接的哈希集。

  1. // LinkedHashSet with 8 capacity and 0.75 load factor
  2. LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);

在这里，我们创建了一个名为number的链接哈希集。

注意，部分new LinkedHashSet<>(8, 0.75)。 在此，第一个参数是capcity，第二个参数是loadFactor。

  • capcity - 此哈希集的容量为 8。意味着，它可以存储 8 个元素。
  • loadFactor - 此哈希集的负载因子为 0.6。 这意味着，只要我们的哈希表填充了 60%，元素就会移到新哈希表中，其大小是原始哈希表的两倍。

默认容量和负载系数

无需定义其容量和负载因子就可以创建链接的哈希集。 例如，

  1. // LinkedHashSet with default capacity and load factor
  2. LinkedHashSet<Integer> numbers1 = new LinkedHashSet<>();

默认，

  • 链接哈希集的容量将为 16
  • 负载系数将为 0.75

从其他集合创建LinkedHashSet

这是我们如何创建包含其他集合的所有元素的链接哈希集。

  1. import java.util.LinkedHashSet;
  2. import java.util.ArrayList;
  4. class Main {
  5.     public static void main(String[] args) {
  6.         // Creating an arrayList of even numbers
  7.         ArrayList<Integer> evenNumbers = new ArrayList<>();
  8.         evenNumbers.add(2);
  9.         evenNumbers.add(4);
  10.         System.out.println("ArrayList: " + evenNumbers);
  12.         // Creating a LinkedHashSet from an ArrayList
  13.         LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
  14.         System.out.println("LinkedHashSet: " + numbers);
  15.     }
  16. }

输出

  1. ArrayList: [2, 4]
  2. LinkedHashSet: [2, 4]

LinkedHashSet的方法

LinkedHashSet类提供了一些方法，使我们可以对链接的哈希集执行各种操作。

将元素插入LinkedHashSet

  • add() - 将指定的元素插入链接的哈希集
  • addAll() - 将指定集合的所有元素插入到链接的哈希集中

例如，

  1. import java.util.LinkedHashSet;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         LinkedHashSet<Integer> evenNumber = new LinkedHashSet<>();
  7.         // Using add() method
  8.         evenNumber.add(2);
  9.         evenNumber.add(4);
  10.         evenNumber.add(6);
  11.         System.out.println("LinkedHashSet: " + evenNumber);
  13.         LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
  15.         // Using addAll() method
  16.         numbers.addAll(evenNumber);
  17.         numbers.add(5);
  18.         System.out.println("New LinkedHashSet: " + numbers);
  19.     }
  20. }

输出：

  1. LinkedHashSet: [2, 4, 6]
  2. New LinkedHashSet: [2, 4, 6, 5]

访问LinkedHashSet元素

要访问链接的哈希集的元素，我们可以使用iterator()方法。 为了使用此方法，我们必须导入java.util.Iterator包。 例如，

  1. import java.util.LinkedHashSet;
  2. import java.util.Iterator;
  4. class Main {
  5.     public static void main(String[] args) {
  6.         LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
  7.         numbers.add(2);
  8.         numbers.add(5);
  9.         numbers.add(6);
  10.         System.out.println("LinkedHashSet: " + numbers);
  12.         // Calling the iterator() method
  13.         Iterator<Integer> iterate = numbers.iterator();
  15.         System.out.print("LinkedHashSet using Iterator: ");
  17.         // Accessing elements
  18.         while(iterate.hasNext()) {
  19.             System.out.print(iterate.next());
  20.             System.out.print(", ");
  21.         }
  22.     }
  23. }

输出：

  1. LinkedHashSet: [2, 5, 6]
  2. LinkedHashSet using Iterator: 2, 5, 6,

注意：

  • 如果链接的哈希集中存在下一个元素，则hasNext()返回true
  • next()返回链接的哈希集中的下一个元素

从HashSet中删除元素

  • remove() - 从链接的哈希集中删除指定的元素
  • removeAll() - 从链接的哈希集中删除所有元素

例如：

  1. import java.util.LinkedHashSet;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
  6.         numbers.add(2);
  7.         numbers.add(5);
  8.         numbers.add(6);
  9.         System.out.println("LinkedHashSet: " + numbers);
  11.         // Using the remove() method
  12.         boolean value1 = numbers.remove(5);
  13.         System.out.println("Is 5 removed? " + value1);
  15.         boolean value2 = numbers.removeAll(numbers);
  16.         System.out.println("Are all elements removed? " + value2);
  17.     }
  18. }

输出：

  1. LinkedHashSet: [2, 5, 6]
  2. Is 5 removed? true
  3. Are all elements removed? true

集的操作

LinkedHashSet类的各种方法也可以用于执行各种设置操作。

并集

两个执行两个集合之间的联合，我们可以使用addAll()方法。 例如，

  1. import java.util.LinkedHashSet;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
  6.         evenNumbers.add(2);
  7.         evenNumbers.add(4);
  8.         System.out.println("LinkedHashSet1: " + evenNumbers);
  10.         LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
  11.         numbers.add(1);
  12.         numbers.add(3);
  13.         System.out.println("LinkedHashSet2: " + numbers);
  15.         // Union of two set
  16.         numbers.addAll(evenNumbers);
  17.         System.out.println("Union is: " + numbers);
  18.     }
  19. }

输出：

  1. LinkedHashSet1: [2, 4]
  2. LinkedHashSet2: [1, 3]
  3. Union is: [1, 3, 2, 4]

交集

要执行两个集合之间的相交，我们可以使用retainAll()方法。 例如

  1. import java.util.LinkedHashSet;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
  6.         primeNumbers.add(2);
  7.         primeNumbers.add(3);
  8.         System.out.println("LinkedHashSet1: " + primeNumbers);
  10.         LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
  11.         evenNumbers.add(2);
  12.         evenNumbers.add(4);
  13.         System.out.println("LinkedHashSet2: " + evenNumbers);
  15.         // Intersection of two sets
  16.         evenNumbers.retainAll(primeNumbers);
  17.         System.out.println("Intersection is: " + evenNumbers);
  18.     }
  19. }

输出：

  1. LinkedHashSet1: [2, 3]
  2. LinkedHashSet2: [2, 4]
  3. Intersection is: [2]

差集

要计算两组之间的差异，我们可以使用removeAll()方法。 例如，

  1. import java.util.LinkedHashSet;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
  6.         primeNumbers.add(2);
  7.         primeNumbers.add(3);
  8.         primeNumbers.add(5);
  9.         System.out.println("LinkedHashSet1: " + primeNumbers);
  11.         LinkedHashSet<Integer> oddNumbers = new LinkedHashSet<>();
  12.         oddNumbers.add(1);
  13.         oddNumbers.add(3);
  14.         oddNumbers.add(5);
  15.         System.out.println("LinkedHashSet2: " + oddNumbers);
  17.         // Difference between LinkedHashSet1 and LinkedHashSet2
  18.         primeNumbers.removeAll(oddNumbers);
  19.         System.out.println("Difference : " + primeNumbers);
  20.     }
  21. }

输出：

  1. LinkedHashSet1: [2, 3, 5]
  2. LinkedHashSet2: [1, 3, 5]
  3. Difference: [2]

子集

要检查一个集合是否是另一个集合的子集，我们可以使用containsAll()方法。 例如，

  1. import java.util.LinkedHashSet;
  3. class Main {
  4.     public static void main(String[] args) {
  5.         LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
  6.         numbers.add(1);
  7.         numbers.add(2);
  8.         numbers.add(3);
  9.         numbers.add(4);
  10.         System.out.println("LinkedHashSet1: " + numbers);
  12.         LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
  13.         primeNumbers.add(2);
  14.         primeNumbers.add(3);
  15.         System.out.println("LinkedHashSet2: " + primeNumbers);
  17.         // Check if primeNumbers is a subset of numbers
  18.         boolean result = numbers.containsAll(primeNumbers);
  19.         System.out.println("Is LinkedHashSet2 is subset of LinkedHashSet1? " + result);
  20.     }
  21. }

输出：

  1. LinkedHashSet1: [1, 2, 3, 4]
  2. LinkedHashSet2: [2, 3]
  3. Is LinkedHashSet2 is a subset of LinkedHashSet1? true

LinkedHashSet的其他方法

方法 描述
clone() 创建LinkedHashSet的副本
contains() 在LinkedHashSet中搜索指定的元素，并返回布尔结果
isEmpty() 检查LinkedHashSet是否为空
size() 返回LinkedHashSet的大小
clear() 从LinkedHashSet中删除所有元素

要了解有关LinkedHashSet方法的更多信息，请访问 Java LinkedHashSet（Java 官方文档）。

LinkedHashSet与HashSet

LinkedHashSet和HashSet都实现Set接口。 但是，它们之间存在一些差异。

  • LinkedHashSet在内部维护一个链表。 因此，它保持其元素的插入顺序。
  • LinkedHashSet类比HashSet需要更多的存储空间。 这是因为LinkedHashSet内部维护链表。
  • LinkedHashSet的性能比HashSet慢。 这是因为LinkedHashSet中存在链表。

LinkedHashSet与TreeSet

以下是LinkedHashSet和TreeSet之间的主要区别：

  • TreeSet类实现SortedSet接口。 这就是对树集中的元素进行排序的原因。 但是，LinkedHashSet类仅维护其元素的插入顺序。
  • TreeSet通常比LinkedHashSet慢。 这是因为每当元素添加到TreeSet时，它都必须执行排序操作。
  • LinkedHashSet允许插入空值。 但是，我们不能向TreeSet插入空值。