Java Set接口方法测试,HashSet,TreeSet方法测试（详）# descendingSet#headSet#subSet#tailSet

ricoric

已于 2022-08-19 18:37:03 修改

阅读量741

点赞数 1

CC 4.0 BY-SA版权

文章标签： java 数据结构

于 2022-08-19 16:09:15 首次发布

本文链接：https://blog.csdn.net/Fooler233/article/details/126403240

本文详细介绍了Java集合框架中的Set接口，包括其特点、存储规则和常用方法。特别讨论了HashSet和TreeSet两个实现类，HashSet基于哈希表实现，不允许重复元素；TreeSet基于红黑树，元素自动排序。文章还涉及到了这两个类的增删查改操作及其特定方法，如TreeSet的pollFirst、pollLast等。此外，还讲解了迭代器和比较器在TreeSet中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.Set接口是Collection接口的一个子接口，包含了collection接口的所有方法，并没有新增方法。

2.存储在Set集合中的元素要求：

a.不可重复，重复会报错。

加入Set里面的元素必须定义equals()方法以确保对象的唯一性。set中插入数据时，先比较hashCode。如果hashCode相同才会比较equals，equals相同，则两个对象相同，新值会覆盖当前值。equals不同，可以插入。如果hashCode不同，就直接插入了，两个对象hashCode不相等，他们equals一定是false。

b.存取无序：

        Set<String> set=new HashSet();
        set.add("z") ;
        set.add("a") ;
        set.add("h") ;
        set.add("A") ;

        for(String s:set){
            System.out.println(s);
        }
测试结果
D:\Java\jdk\bin\java.exe 
a
A
h
z

3.方法：

增：
   boolean add(E e) ：添加元素
   boolean addAll(Collection<? extends E> c) ：添加一个集合中的所有元素

删：
    void clear() ：清空集合
    boolean remove(Object o)：删除指定元素
    boolean removeAll(Collection<?> c)：删除包含的指定集合的所有元素
    boolean retainAll(Collection<?> c)：保留包含的指定集合的所有元素，其余删除

查：
    boolean contains(Object o)：查看是否包含指定元素
    boolean containsAll(Collection<?> c)：查看是否包含指定集合的所有元素
    boolean equals(Object o)
    int hashCode()
    boolean isEmpty()：判空
    int size()：返回该集合的大小
改：
    Object[] toArray()：返回一个包含此集合中所有元素的数组
    <T> T[] toArray(T[] a)：返回一个包含此集合中所有元素的指定类型的数组
  
迭代器：
    Iterator<E> iterator()：返回一个迭代器
    default Spliterator<E> spliterator()：创建一个可分割迭代器

这里面就那个分割迭代器我还不会，其他看看应该没问题，和collection集合中的一样。

4：常用实现类：

HashSet: 底层数据结构为散列表，散列表中存储的元素具有支持下标随机访问的数据特性，就是由一维数组和单向链表构成的。盗了老杜的图

hashSet类中的方法都是实现的set接口中的方法除了clone外都是实现set接口中的方法，主要看看构造方法

HashSet() ： 默认初始容量（16）和负载因子（0.75）。  
HashSet(Collection<? extends E> c) ：构造一个包含指定集合中的元素的hash表。  
HashSet(int initialCapacity) ：指定初始容量，默认负载因子（0.75）。  
HashSet(int initialCapacity, float loadFactor) ：指定初始容量，指定负载因子。

负载因子是和扩容机制有关的，意思是如果当前容器的容量，达到了我们设定的最大值，就要开始执行扩容操作。比如说当前的容器容量（initialCapability）是16，负载因子（lodeFactor）是0.75,16*0.75=12，也就是说，当容量达到了12的时候就会进行扩容。

TreeSet:底层是红黑树，红黑树具体的增删操作还在学习中。

红黑树的规则：

每个节点都有红色或黑色
树的根始终是黑色的
没有两个相邻的红色节点（红色节点不能有红色父节点或红色子节点，并没有说不能出现连续的黑色节点）
从节点（包括根）到其任何后代NULL节点 (叶子结点下方挂的两个空节点，并且认为他们是黑色的)的每条路径都具有相同数量的黑色节

TreeSet方法测试：

构造方法：
TreeSet()
构造一个新的树组，根据元素的compareTo方法比较进行自动排序。

 public static void main(String[] args) {
        Set<Integer> set=new TreeSet<>() ;
        set.add(3) ;
        set.add(9) ;
        set.add(1) ;
        set.add(2) ;
        for(Integer i:set){
            System.out.print(i);
        }

D:\Java\jdk\bin\java.exe 
1239
Process finished with exit code 0

TreeSet(Collection<? extends E> c)
构造一个包含指定集合中的元素的新树集，根据其元素的compareTo方法比较进行排序。

 LinkedList<Integer> L=new LinkedList<>() ;
        L.add(9) ;
        L.add(1) ;
        L.add(3) ;
        L.add(9) ;
        Set<Integer> set1=new TreeSet<>(L) ;
        for (Integer i:set1){
            System.out.println(i);
        }

D:\Java\jdk\bin\java.exe 
139
Process finished with exit code 0

元素重复了，会自己覆盖。
TreeSet(Comparator<? super E> comparator)
构造一个新的树集，根据指定的比较器进行排序。如果树集中存储的是对象，该类可以实现comparable接口，然后根据比较的具体需求重写compareTo方法。

public class Animal{
    public int age ;
    public String name ;

    public Animal(int age,String name){
        this.age=age ;
        this.name=name ;
    }

    @Override
    public String toString() {
        return "["+ name+":"+ age+ ']';
    }

}

     Set<Animal> set =new TreeSet<>(new Comparator<Animal>() {
            @Override
            public int compare(Animal o1, Animal o2) {
                return o1.age+o1.name.length()-(o2.age+o2.name.length()) ;
            }
        });

        set.add(new Animal(2,"cat***")) ;
        set.add(new Animal(3,"dog**")) ;
        set.add(new Animal(2,"pat*")) ;
        set.add(new Animal(2,"bird****")) ;
        set.add(new Animal(2,"cow"));

        for (Animal a:set){
            System.out.println(a);
        }


D:\Java\jdk\bin\java.exe 
[cow:2]
[pat*:2]
[cat***:2]
[bird****:2]

Process finished with exit code 0

TreeSet(SortedSet<E> s)
构造一个包含相同元素的新树，并使用与指定排序集相同的顺序。

       SortedSet s = new TreeSet(new Comparator<Integer>() {
          @Override
          public int compare(Integer num1, Integer num2) {
              return num2-num1;
            }
        });

        TreeSet treeSet3 = new TreeSet<>(s);
        treeSet3.add(1);
        treeSet3.add(2);
        treeSet3.add(3);
        System.out.println(treeSet3);

D:\Java\jdk\bin\java.exe
[3, 2, 1]

Process finished with exit code 0

增：

TreeSet增加元素还是实现的Set接口中的老方法，add(E e) 和addAll(Collection<? extends E> c)，返回值为布尔，上面提到过。

删：

treeSet只继承了父类Set的clear()和 remove(Object o),同时自己提供了两个


//删：
    继承的：
    void clear()：从此集合中删除所有元素。
    boolean remove(Object o)：如果存在，则从该集合中删除指定的元素。
    特有的：
    E pollFirst()：检索并删除第一个元素，并返回该元素，如果该集合为空返回 null。
    E pollLast()： 检索并删除最后一个元素，并返回该元素，如果此集合为空，则返回 null 。

 TreeSet<Integer> set =new TreeSet<>() ;
        set.add(1) ;
        set.add(6) ;
        set.add(2) ;
        set.add(8) ;
        System.out.println(set.pollFirst());
        for (Integer i:set) {
            System.out.print(i+" ");
        }

        System.out.println("\n"+"------------");

        System.out.println(set.pollLast());
        for(Integer i:set){
            System.out.print(i+" ");
        }

D:\Java\jdk\bin\java.exe
1
2 6 8 
------------
8
2 6 

Process finished with exit code 0

查：

//查：
    继承Set的：
    boolean contains(Object o): 如果此集合包含指定的元素，则返回 true 。
    boolean isEmpty(): 如果此集合不包含元素，则返回 true 。
    int size(): 返回此集合中的元素数（其基数）。
    Object clone(): 返回此 TreeSet实例的浅拷贝

    特有的：
    E first():返回此集合排序后的第一个（最小）元素。
    E last(): 返回此集合排序后的最后一个（最大）元素
    E floor(E e): 返回此集合中小于或等于指定元素中元素的最大值，如果没有这样的元素，则返回 null 
    E ceiling(E e): 返回此集合中大于或等于给定元素中元素的最小元素，如果没有此元素，则返回 null 。
    E higher(E e):返回严格大于给定元素的该集合中的最小元素，如果没有此元素则返回 null 。
    E lower(E e): 返回这个集合中最大的元素严格小于给定的元素，如果没有这样的元素，则返回 null
    
        TreeSet<Integer> set =new TreeSet<>() ;
        set.add(1) ;
        set.add(5) ;
        set.add(4) ;
        set.add(8) ;
        set.add(3) ;
        set.add(7) ; //1 3 4 5 7 8 
        System.out.println(set.first());  //1
        System.out.println(set.last());   //8
        System.out.println(set.floor(6 ));  //5
        System.out.println(set.ceiling(2)); //3
        System.out.println(set.higher(5));  //7
        System.out.println(set.lower(5));   //4

//改：
NavigableSet<E> descendingSet()
返回此集合中包含的元素的反向排序视图。
SortedSet<E> headSet(E toElement)
返回此集合的部分的视图，其元素严格小于 toElement 。
NavigableSet<E> headSet(E toElement, boolean inclusive)
返回该集合的部分的视图，其元素小于（或等于，如果 inclusive为真） toElement 。
NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
返回该集合的部分的视图，其元素的范围从 fromElement到 toElement 。
SortedSet<E> subSet(E fromElement, E toElement)
返回此集合的部分的视图，其元素的范围从 fromElement （含）到 toElement ，排他。
SortedSet<E> tailSet(E fromElement)
返回此组件的元素大于或等于 fromElement的部分的视图。
NavigableSet<E> tailSet(E fromElement, boolean inclusive)
返回此集合的部分的视图，其元素大于（或等于，如果 inclusive为真） fromElement 。


        TreeSet<Integer> set =new TreeSet<>() ;
        set.add(1) ;
        set.add(5) ;
        set.add(4) ;
        set.add(8) ;
        set.add(3) ;
        set.add(7) ;

        NavigableSet<Integer> set1=set.descendingSet();
        for(Integer i:set1){
            System.out.print(i);
        }

D:\Java\jdk\bin\java.exe
875431

TreeSet<Integer> set =new TreeSet<>() ;
        set.add(1) ;
        set.add(5) ;
        set.add(4) ;
        set.add(8) ;
        set.add(3) ;
        set.add(7) ;
  SortedSet<Integer> set1 =set.headSet(6) ;
        for(Integer i:set1){
            System.out.print(i);
        }
  System.out.println() ;

  SortedSet<Integer> set2 =set.headSet(6，true) ;
        for(Integer i:set2){
            System.out.print(i);
        }
D:\Java\jdk\bin\java.exe 
1345
1345
Process finished with exit code 0

TreeSet<Integer> set =new TreeSet<>() ;
        set.add(1) ;
        set.add(5) ;
        set.add(4) ;
        set.add(8) ;
        set.add(3) ;
        set.add(7) ;
        
        SortedSet<Integer> set1 =set.subSet(2,7) ;
        SortedSet<Integer> set2 =set.subSet(2,true,7,true) ;
        // fromInclusive和toInclusive一个可选参数，为布尔类型。如果将其设置为True，则低端点将包                
        // 含在返回的视图中，否则不包括在内
        for(Integer i:set1){
            System.out.print(i);
        }

        System.out.println();

        for(Integer i:set2){
            System.out.print(i);
        }
D:\Java\jdk\bin\java.exe 
345
3457
Process finished with exit code 0

 TreeSet<Integer> set =new TreeSet<>() ;
        set.add(1) ;
        set.add(5) ;
        set.add(4) ;
        set.add(8) ;
        set.add(3) ;
        set.add(7) ;
        SortedSet<Integer> set1 =set.tailSet(5) ;
        //等价于
        //SortedSet<Integer> set1 =set.tailSet(5,true) ;
        for(Integer i:set1){
            System.out.print(i+" ");
        }
        System.out.println();
        SortedSet<Integer> set2 =set.tailSet(5,false) ;
        //inclusive是可选参数，为true则包含当前元素，如果为false，则不包含
        for(Integer i:set2){
            System.out.print(i+" ");
        }
        
D:\Java\jdk\bin\java.exe 
5 7 8 
7 8 
Process finished with exit code 0

迭代器比较器：

Iterator<E> descendingIterator()：以降序方式遍历
Iterator<E> iterator()
Comparator<? super E> comparator():返回用于对该集合中的元素进行排序的比较器，如果没由，使用元素的自然排序 。
Spliterator<E> spliterator():返回一个可分割迭代器