Java LinkedHashSet

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

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

它实现Set接口。

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

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

创建一个LinkedHashSet

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

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

//具有8个容量和0.75负载因子的LinkedHashSet
LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);

在这里，我们创建了一个名为numbers的链表哈希集合。

注意，语句 new LinkedHashSet<>(8, 0.75)。在这里，第一个参数是容量，第二个参数是负载因子。

• capacity - 该哈希集的容量为8。意味着，它可以存储8个元素。

• loadFactor- 此哈希集的负载因子为0.6。这意味着，只要我们的哈希表填充了60％，元素就会移动到新哈希表中，该哈希表的大小是原始哈希表的两倍。

默认容量和负载因子

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

//具有默认容量和负载因子的LinkedHashSet
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) {
        //创建偶数的arrayList
        ArrayList<Integer> evenNumbers = new ArrayList<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("ArrayList: " + evenNumbers);

        //从ArrayList创建LinkedHashSet
        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<>();

        // 使用add()方法
        evenNumber.add(2);
        evenNumber.add(4);
        evenNumber.add(6);
        System.out.println("LinkedHashSet: " + evenNumber);

        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        
        //使用addAll()方法
        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);

        //调用iterator()方法
        Iterator<Integer> iterate = numbers.iterator();

        System.out.print("使用Iterator的LinkedHashSet: ");

        //访问元素
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

输出结果

LinkedHashSet: [2, 5, 6]
使用Iterator的LinkedHashSet: 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);

        //使用remove()方法
        boolean value1 = numbers.remove(5);
        System.out.println("5被删除? " + value1);

        boolean value2 = numbers.removeAll(numbers);
        System.out.println("是否删除了所有元素? " + value2);
    }
}

输出结果

LinkedHashSet: [2, 5, 6]
5被删除? true
是否删除了所有元素? true

LinkedHashSet操作方法

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

并集

执行两个集合之间的并集，我们可以使用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);

        //两个集合的并集
        numbers.addAll(evenNumbers);
        System.out.println("并集: " + numbers);
    }
}

输出结果

LinkedHashSet1: [2, 4]
LinkedHashSet2: [1, 3]
并集: [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);

        //集合的交集
        evenNumbers.retainAll(primeNumbers);
        System.out.println("集合的交集: " + evenNumbers);
    }
}

输出结果

LinkedHashSet1: [2, 3]
LinkedHashSet2: [2, 4]
集合的交集: [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);

        //LinkedHashSet1和LinkedHashSet2之间的差集
        primeNumbers.removeAll(oddNumbers);
        System.out.println("差集: " + primeNumbers);
    }
}

输出结果

LinkedHashSet1: [2, 3, 5]
LinkedHashSet2: [1, 3, 5]
差集: [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);

        //检查primeNumbers是否是numbers的子集
        boolean result = numbers.containsAll(primeNumbers);
        System.out.println("LinkedHashSet2是LinkedHashSet1的子集吗? " + result);
    }
}

输出结果

LinkedHashSet1: [1, 2, 3, 4]
LinkedHashSet2: [2, 3]
LinkedHashSet2是LinkedHashSet1的子集吗? true

LinkedHashSet的其他方法

LinkedHashSet与HashSet的区别

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

• LinkedHashSet在内部维护一个链表。因此，它保持其元素的插入顺序。

• LinkedHashSet类比HashSet需要更多的存储空间。这是因为LinkedHashSet在内部维护链表。

• LinkedHashSet的性能比HashSet慢。这是因为LinkedHashSet中存在链表。

LinkedHashSet 与TreeSet的区别

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

• TreeSet类实现了SortedSet接口。这就是为什么树集中的元素是有序的。但是，LinkedHashSet类只维护其元素的插入顺序。

• TreeSet通常比LinkedHashSet慢。这是因为每当将元素添加到TreeSet时，它都必须执行排序操作。

• LinkedHashSet允许插入空值。但是，我们不能向TreeSet插入空值。