Java LinkedHashSet

在本教程中，我们将通过示例了解 Java LinkedHashSet 类及其方法。

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

它实现了Set接口。

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

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

创建一个 LinkedHashSet

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

导入包后，下面是我们在 Java 中创建链接哈希集的方法。

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

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

注意，new LinkedHashSet<>(8, 0.75) 部分 .这里，第一个参数是容量第二个参数是 loadFactor .

容量 - 这个哈希集的容量是8。意思是，它可以存储8个元素。
负载系数 - 这个哈希集的负载因子是 0.6。这意味着，每当我们的哈希表填充 60% 时，元素就会被移动到一个新的哈希表，该哈希表的大小是原始哈希表的两倍。

默认容量和负载率

可以在不定义其容量和负载因子的情况下创建链接哈希集。例如，

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

默认情况下，

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

从其他集合创建 LinkedHashSet

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

import java.util.LinkedHashSet;
import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        // Creating an arrayList of even numbers
        ArrayList<Integer> evenNumbers = new ArrayList<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("ArrayList: " + evenNumbers);

        // Creating a LinkedHashSet from an ArrayList
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
        System.out.println("LinkedHashSet: " + numbers);
    }
}

输出

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

LinkedHashSet的方法

LinkedHashSet 类提供了允许我们对链接的哈希集执行各种操作的方法。

向 LinkedHashSet 插入元素

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

例如，

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> evenNumber = new LinkedHashSet<>();

        // Using add() method
        evenNumber.add(2);
        evenNumber.add(4);
        evenNumber.add(6);
        System.out.println("LinkedHashSet: " + evenNumber);

        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        
        // Using addAll() method
        numbers.addAll(evenNumber);
        numbers.add(5);
        System.out.println("New LinkedHashSet: " + numbers);
    }
}

输出

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

访问 LinkedHashSet 元素

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

import java.util.LinkedHashSet;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("LinkedHashSet: " + numbers);

        // Calling the iterator() method
        Iterator<Integer> iterate = numbers.iterator();

        System.out.print("LinkedHashSet using Iterator: ");

        // Accessing elements
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

输出

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

注意：

hasNext() 返回 true 如果链接哈希集中有下一个元素
next() 返回链接哈希集中的下一个元素

从 HashSet 中移除元素

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

例如，

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("LinkedHashSet: " + numbers);

        // Using the remove() method
        boolean value1 = numbers.remove(5);
        System.out.println("Is 5 removed? " + value1);

        boolean value2 = numbers.removeAll(numbers);
        System.out.println("Are all elements removed? " + value2);
    }
}

输出

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

设置操作

LinkedHashSet的各种方法类也可以用来执行各种集合操作。

集合并集

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

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("LinkedHashSet1: " + evenNumbers);

        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(1);
        numbers.add(3);
        System.out.println("LinkedHashSet2: " + numbers);

        // Union of two set
        numbers.addAll(evenNumbers);
        System.out.println("Union is: " + numbers);
    }
}

输出

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

集合的交集

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

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        System.out.println("LinkedHashSet1: " + primeNumbers);

        LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("LinkedHashSet2: " + evenNumbers);

        // Intersection of two sets
        evenNumbers.retainAll(primeNumbers);
        System.out.println("Intersection is: " + evenNumbers);
    }
}

输出

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

集合的不同

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

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        primeNumbers.add(5);
        System.out.println("LinkedHashSet1: " + primeNumbers);

        LinkedHashSet<Integer> oddNumbers = new LinkedHashSet<>();
        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        System.out.println("LinkedHashSet2: " + oddNumbers);

        // Difference between LinkedHashSet1 and LinkedHashSet2
        primeNumbers.removeAll(oddNumbers);
        System.out.println("Difference : " + primeNumbers);
    }
}

输出

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

子集

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

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("LinkedHashSet1: " + numbers);

        LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        System.out.println("LinkedHashSet2: " + primeNumbers);

        // Check if primeNumbers is a subset of numbers
        boolean result = numbers.containsAll(primeNumbers);
        System.out.println("Is LinkedHashSet2 is subset of LinkedHashSet1? " + result);
    }
}

输出

LinkedHashSet1: [1, 2, 3, 4]
LinkedHashSet2: [2, 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 对比。哈希集

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

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

LinkedHashSet 对比。树集

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

TreeSet 类实现 SortedSet 界面。这就是为什么对树集中的元素进行排序的原因。但是，LinkedHashSet 类只维护其元素的插入顺序。
一个TreeSet 通常比 LinkedHashSet 慢 .这是因为每当一个元素被添加到 TreeSet ，它必须执行排序操作。
<随机>LinkedHashSet 允许插入空值。但是，我们不能在 TreeSet 中插入空值 .

Java 枚举集 Java 排序集接口

java