Java 树集

在本教程中，我们将通过示例了解 Java TreeSet 类及其各种操作和方法。

TreeSet Java集合框架的类提供了树数据结构的功能。

它扩展了 NavigableSet 接口。

创建树集

为了创建树集，我们必须导入 java.util.TreeSet 先打包。

一旦我们导入包，下面是我们如何创建一个 TreeSet 在 Java 中。


TreeSet<Integer> numbers = new TreeSet<>();

在这里，我们创建了一个 TreeSet 没有任何论据。在这种情况下，TreeSet 中的元素自然排序（升序）。

但是，我们可以使用 Comparator 自定义元素的排序界面。我们将在本教程的后面部分了解它。

TreeSet的方法

TreeSet 类提供了各种方法，允许我们对集合执行各种操作。

向 TreeSet 插入元素

add() - 将指定元素插入到集合中
addAll() - 将指定集合的所有元素插入到集合中

例如，

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {

        TreeSet<Integer> evenNumbers = new TreeSet<>();

        // Using the add() method
        evenNumbers.add(2);
        evenNumbers.add(4);
        evenNumbers.add(6);
        System.out.println("TreeSet: " + evenNumbers);

        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(1);

        // Using the addAll() method
        numbers.addAll(evenNumbers);
        System.out.println("New TreeSet: " + numbers);
    }
}

输出

TreeSet: [2, 4, 6]
New TreeSet: [1, 2, 4, 6]

访问 TreeSet 元素

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

import java.util.TreeSet;
import java.util.Iterator;

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

        // Calling iterator() method
        Iterator<Integer> iterate = numbers.iterator();
        System.out.print("TreeSet using Iterator: ");
        // Accessing elements
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

输出

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

删除元素

remove() - 从集合中移除指定元素
removeAll() - 从集合中移除所有元素

例如，

import java.util.TreeSet;

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

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

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

输出

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

自 TreeSet 类实现 NavigableSet ，它提供了多种方法来导航树集的元素。

1。 first() 和 last() 方法

first() - 返回集合的第一个元素
last() - 返回集合的最后一个元素

例如，

import java.util.TreeSet;

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

        // Using the first() method
        int first = numbers.first();
        System.out.println("First Number: " + first);

        // Using the last() method
        int last = numbers.last();
        System.out.println("Last Number: " + last);
    }
}

输出

TreeSet: [2, 5, 6]
First Number: 2
Last Number: 6

2。天花板（），地板（），更高（）和更低（）方法

更高（元素） - 返回大于指定 element 的元素中最小的元素 .
下层（元素） - 返回小于指定element的元素中最大的元素 .
天花板（元素） - 返回大于指定 element 的元素中最小的元素 .如果 元素 传递存在于树集中，它返回 element 作为参数传递。
地板（元素） - 返回小于指定 element 的元素中最大的元素 .如果 元素 传递存在于树集中，它返回 element 作为参数传递。

例如，

import java.util.TreeSet;

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

        // Using higher()
        System.out.println("Using higher: " + numbers.higher(4));

        // Using lower()
        System.out.println("Using lower: " + numbers.lower(4));

        // Using ceiling()
        System.out.println("Using ceiling: " + numbers.ceiling(4));

        // Using floor()
        System.out.println("Using floor: " + numbers.floor(3));

    }
}

输出

TreeSet: [2, 4, 5, 6]
Using higher: 5
Using lower: 2
Using ceiling: 4
Using floor: 2

3。 pollfirst() 和 pollLast() 方法

pollFirst() - 从集合中返回并删除第一个元素
pollLast() - 返回并删除集合中的最后一个元素

例如，

import java.util.TreeSet;

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

        // Using pollFirst()
        System.out.println("Removed First Element: " + numbers.pollFirst());

        // Using pollLast()
        System.out.println("Removed Last Element: " + numbers.pollLast());

        System.out.println("New TreeSet: " + numbers);
    }
}

输出

TreeSet: [2, 4, 5, 6]
Removed First Element: 2
Removed Last Element: 6
New TreeSet: [4, 5]

4。 headSet()、tailSet() 和 subSet() 方法

headSet(元素, booleanValue)

headSet() 方法返回指定 element 之前的树集合的所有元素（作为参数传递）。

booleanValue 参数是可选的。它的默认值为 false .

如果 true 作为 booleanValue 传递，该方法返回指定元素之前的所有元素，包括指定元素。

例如，

import java.util.TreeSet;

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

        // Using headSet() with default boolean value
        System.out.println("Using headSet without boolean value: " + numbers.headSet(5));

        // Using headSet() with specified boolean value
        System.out.println("Using headSet with boolean value: " + numbers.headSet(5, true));
    }
}

输出

TreeSet: [2, 4, 5, 6]
Using headSet without boolean value: [2, 4]
Using headSet with boolean value: [2, 4, 5]

tailSet(元素, booleanValue)

tailSet() 方法返回指定 element 之后的树集合的所有元素（作为参数传递）包括指定的 element .

booleanValue 参数是可选的。它的默认值为 true .

如果 false 作为 booleanValue 传递 , 该方法返回指定 element 之后的所有元素不包括指定的 element .

例如，

import java.util.TreeSet;

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

        // Using tailSet() with default boolean value
        System.out.println("Using tailSet without boolean value: " + numbers.tailSet(4));

        // Using tailSet() with specified boolean value
        System.out.println("Using tailSet with boolean value: " + numbers.tailSet(4, false));
    }
}

输出

TreeSet: [2, 4, 5, 6]
Using tailSet without boolean value: [4, 5, 6]
Using tailSet with boolean value: [5, 6]

子集(e1, bv1, e2, bv2)

subSet() 方法返回 e1 之间的所有元素和 e2 包括 e1 .

bv1 和 bv2 是可选参数。 bv1 的默认值是 true ，以及 bv2 的默认值是 false .

如果 false 作为 bv1 传递 , 该方法返回 e1 之间的所有元素和 e2 不包括 e1 .

如果 true 作为 bv2 传递 , 该方法返回 e1 之间的所有元素和 e2 , 包括 e1 .

例如，

import java.util.TreeSet;

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

        // Using subSet() with default boolean value
        System.out.println("Using subSet without boolean value: " + numbers.subSet(4, 6));

        // Using subSet() with specified boolean value
        System.out.println("Using subSet with boolean value: " + numbers.subSet(4, false, 6, true));
    }
}

输出

TreeSet: [2, 4, 5, 6]
Using subSet without boolean value: [4, 5]
Using subSet with boolean value: [5, 6]

设置操作

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

集合并集

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

import java.util.TreeSet;;

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

        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        System.out.println("TreeSet2: " + numbers);

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

    }
}

输出

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
Union is: [1, 2, 3, 4]

集合的交集

为了执行两个集合之间的交集，我们使用 retainAll() 方法。例如，

import java.util.TreeSet;;

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

        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        System.out.println("TreeSet2: " + numbers);

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

输出

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
Intersection is: [2]

集合的不同

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

import java.util.TreeSet;;

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

        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("TreeSet2: " + numbers);

        // Difference between two sets
        numbers.removeAll(evenNumbers);
        System.out.println("Difference is: " + numbers);
    }
}

输出

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3, 4]
Difference is: [1, 3]

集合的子集

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

import java.util.TreeSet;

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

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

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

输出

TreeSet1: [1, 2, 3, 4]
TreeSet2: [2, 3]
Is TreeSet2 subset of TreeSet1? True

TreeSet 的其他方法

方法	说明
`clone()`	创建 TreeSet 的副本
`contains()`	在 TreeSet 中搜索指定元素并返回布尔结果
`isEmpty()`	检查 `TreeSet` 是空的
`size()`	返回`TreeSet`的大小
`clear()`	从 `TreeSet` 中移除所有元素

要了解更多信息，请访问 Java TreeSet（Java 官方文档）。

TreeSet 对比。哈希集

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

不同于 HashSet , TreeSet 中的元素以某种顺序存储。这是因为 TreeSet 实现 SortedSet 界面也是如此。
TreeSet 提供了一些方便导航的方法。例如，first() , last() , headSet( ), tailSet() 等。这是因为 TreeSet 还实现了 NavigableSet 界面。
HashSet 比 TreeSet 快用于添加、删除、包含和大小等基本操作。

树集比较器

在上面的所有示例中，树集元素都是自然排序的。但是，我们也可以自定义元素的顺序。

为此，我们需要根据树集中的哪些元素进行排序来创建自己的比较器类。例如，

import java.util.TreeSet;
import java.util.Comparator;

class Main {
    public static void main(String[] args) {

        // Creating a tree set with customized comparator
        TreeSet<String> animals = new TreeSet<>(new CustomComparator());

        animals.add("Dog");
        animals.add("Zebra");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("TreeSet: " + animals);
    }

    // Creating a comparator class
    public static class CustomComparator implements Comparator<String> {

        @Override
        public int compare(String animal1, String animal2) {
            int value =  animal1.compareTo(animal2);

            // elements are sorted in reverse order
            if (value > 0) {
                return -1;
            }
            else if (value < 0) {
                return 1;
            }
            else {
                return 0;
            }
        }
    }
}

输出