TreeSet的使用方法总结、实现原理、使用示例

已于 2023-01-11 20:50:51 修改
阅读量2w 收藏 179
点赞数 51
分类专栏： java 文章标签： java
于 2020-07-02 23:11:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22701869/article/details/106990578
版权

目录

存储特点：有序，不重复；key不能为空，value可以为null（总结一点：凡是有Tree的集合，都是有序的，凡是有Set的就是不重复的）

底层原理：使用NavigableMap，但NavigableMap只是一个接口，最终是使用TreeMap

构造函数

public TreeSet()：底层创建新的TreeMap

public TreeSet(Collection c)：通过集合构造TreeSet

public TreeSet(Comparator comparator)：自定义比较器的TreeSet

如果Treeset存储的是对象，可以通过对象实现Comparator，实现自定义对象比较器

public TreeSet(SortedSet s)：通过set构造TreeSet

常用方法

public boolean add(E e)：添加元素

public  boolean addAll(Collection c)：通过集合添加元素

public E ceiling(E e)：返回大于或等于给定键值的最小键值

public void clear()：清空集合

public Object clone()：克隆集合

public Comparator comparator()：用于在此树映射中维护顺序的比较器，如果使用其键的自然顺序，则为null

public boolean contains(Object o) ：是否包含摸个元素

public Iterator descendingIterator()：用于按降序迭代元素。

public NavigableSet descendingSet()：？

public E first()：获取首点

public E floor(E e)：返回小于或等于给定键值的最大键值

public SortedSet headSet(E toElement)：返回key<=toElement集合

public NavigableSet headSet(E toElement, boolean inclusive)：返回key<=toElement集合，inclusive=true返回的集合在原set中，会包含自己，否则不会包含

public E higher(E e)：返回严格大于给定键值的最小键值

public boolean isEmpty()：判断集合是否为空

public Iterator iterator() ：迭代输出

public E last()：获取最后的值

public E lower(E e)：返回严格小于给定键值的最大键值

public E pollFirst()：获取第一个值并移除第一个值

public E pollLast()：获取最后值并移除这个值

public boolean remove(Object o)：移除元素

public int size() ：当前set容量

public Spliterator spliterator() ： 方法用于拆分set元素，并逐个迭代它们。

public NavigableSet subSet(E fromElement, boolean fromInclusive, E toElement,   boolean toInclusive)：返回from到to之间的值，fromInclusive和toInclusive代表是否包含当前值

public SortedSet subSet(E fromElement, E toElement)：返回from到to之间的值，包含from，不包含to，即【左闭右开）

public SortedSet tailSet(E fromElement)：返回>=fromElement值的集合元素

public NavigableSet tailSet(E fromElement, boolean inclusive)返回>=fromElement值的集合元素，inclusive=true包含自身，=false就不包含

存储特点：有序，不重复；key不能为空，value可以为null（总结一点：凡是有Tree的集合，都是有序的，凡是有Set的就是不重复的）

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        set.add(3);
        set.add(2);
        set.add(5);
        set.add(1);
        set.add(3);
        System.out.println(set);
    }
}

结果：

[1, 2, 3, 5]

底层原理：使用NavigableMap，但NavigableMap只是一个接口，最终是使用TreeMap

构造函数

public TreeSet()：底层创建新的TreeMap

public TreeSet(Collection<? extends E> c)：通过集合构造TreeSet

demo

public class Test {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(3);
        list.add(3);
        list.add(2);
        list.add(1);
        list.add(4);
        TreeSet set = new TreeSet(list);

        System.out.println("list:"+list);
        System.out.println("set:"+set);
    }
}

结果：

list:[3, 3, 2, 1, 4]
set:[1, 2, 3, 4]

public TreeSet(Comparator<? super E> comparator)：自定义比较器的TreeSet

如果Treeset存储的是对象，可以通过对象实现Comparator，实现自定义对象比较器

实体类Person，实现Comparator接口

public class Person implements Comparable {
    private String name;
    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    //实现比较方法
    @Override
    public int compareTo(Object o) {
        Person p = (Person) o;
        return this.age - p.getAge();
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        set.add(new Person("成龙",13));
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",16));
        set.add(new Person("李连杰",56));
        System.out.println("set:"+set);
    }
}

结果：年龄从低到高排列

set:[Person{name='刘亦菲', age=11}, 
Person{name='成龙', age=13}, 
Person{name='周星驰', age=16}, 
Person{name='胡歌', age=22}, 
Person{name='李连杰', age=56}]

public TreeSet(SortedSet<E> s)：通过set构造TreeSet

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        set.add(new Person("成龙",13));
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",16));
        set.add(new Person("李连杰",56));

        TreeSet t = new TreeSet(set);

        System.out.println("set:"+set);

        t.add(new Person("杨超越",18));
        System.out.println("t:"+t);
    }
}

结果

set:[Person{name='刘亦菲', age=11}, Person{name='成龙', age=13}, Person{name='周星驰', age=16}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
t:[Person{name='刘亦菲', age=11}, Person{name='成龙', age=13}, Person{name='周星驰', age=16}, Person{name='杨超越', age=18}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]

常用方法

public boolean add(E e)：添加元素

public  boolean addAll(Collection<? extends E> c)：通过集合添加元素

public class Test {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(3);
        list.add(3);
        list.add(2);
        list.add(1);
        list.add(4);
        TreeSet set = new TreeSet(list);

        System.out.println("list:"+list);
        System.out.println("set:"+set);
    }
}

结果：

list:[3, 3, 2, 1, 4]
set:[1, 2, 3, 4]

public E ceiling(E e)：返回大于或等于给定键值的最小键值

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",12);
        set.add(new Person("成龙",13));
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",16));
        set.add(new Person("李连杰",56));

        System.out.println("set:"+set);
        System.out.println(set.ceiling(person));
    }
}

结果：最接近古天乐年纪的是成龙，所有结果是成龙

set:[Person{name='刘亦菲', age=11}, Person{name='成龙', age=13}, Person{name='周星驰', age=16}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
Person{name='成龙', age=13}

public void clear()：清空集合

public Object clone()：克隆集合

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",12);
        set.add(person);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",16));
        set.add(new Person("李连杰",56));

        TreeSet clone = (TreeSet)set.clone();

        System.out.println("set:"+set);
        clone.remove(person);
        System.out.println("clone:"+clone);
    }
}

结果：

set:[Person{name='刘亦菲', age=11}, Person{name='古天乐', age=12}, Person{name='周星驰', age=16}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
clone:[Person{name='刘亦菲', age=11}, Person{name='周星驰', age=16}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]

public Comparator<? super E> comparator()：用于在此树映射中维护顺序的比较器，如果使用其键的自然顺序，则为null

public boolean contains(Object o) ：是否包含摸个元素

public Iterator<E> descendingIterator()：用于按降序迭代元素。

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",23);
        Person person2 = new Person("杨超越",18);
        set.add(person);
        set.add(person2);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",18));
        set.add(new Person("李连杰",56));


        System.out.println("set:"+set);
        Iterator iterator = set.descendingIterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

结果：

set:[Person{name='刘亦菲', age=11}, Person{name='杨超越', age=18}, Person{name='胡歌', age=22}, Person{name='古天乐', age=23}, Person{name='李连杰', age=56}]
Person{name='李连杰', age=56}
Person{name='古天乐', age=23}
Person{name='胡歌', age=22}
Person{name='杨超越', age=18}
Person{name='刘亦菲', age=11}

public NavigableSet<E> descendingSet()：？

public E first()：获取首点

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",12);
        set.add(person);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",16));
        set.add(new Person("李连杰",56));

        System.out.println("set:"+set);
        System.out.println("set:"+set.first());
    }
}

结果

set:[Person{name='刘亦菲', age=11}, Person{name='古天乐', age=12}, Person{name='周星驰', age=16}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
set:Person{name='刘亦菲', age=11}

public E floor(E e)：返回小于或等于给定键值的最大键值

demo

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

        TreeSet set = new TreeSet();
        Person person = new Person("古天乐", 23);
        //set.add(person);
        set.add(new Person("胡歌", 22));
        set.add(new Person("刘亦菲", 11));
        set.add(new Person("周星驰", 16));
        set.add(new Person("李连杰", 56));

        System.out.println("set:" + set);
        System.out.println(set.floor(person));
    }
}

结果：比23最小的是22 

set:[Person{name='刘亦菲', age=11}, Person{name='周星驰', age=16}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
Person{name='胡歌', age=22}

public SortedSet<E> headSet(E toElement)：返回key<=toElement集合

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",18);
        //set.add(person);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",16));
        set.add(new Person("李连杰",56));

        System.out.println("set:"+set);
        System.out.println("返回age小于person.age的元素set:"+set.headSet(person));
    }
}

结果

set:[Person{name='刘亦菲', age=11}, Person{name='周星驰', age=16}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
返回age小于person.age的元素set:[Person{name='刘亦菲', age=11}, Person{name='周星驰', age=16}]

public NavigableSet<E> headSet(E toElement, boolean inclusive)：返回key<=toElement集合，inclusive=true返回的集合在原set中，会包含自己，否则不会包含

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",18);
        set.add(person);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",16));
        set.add(new Person("李连杰",56));

        System.out.println("set:"+set);
        System.out.println("返回age小于person.age的元素set:"+set.headSet(person,false));
    }
}

结果：返回的结果包含person自己，如果是false就不会包含

set:[Person{name='刘亦菲', age=11}, Person{name='周星驰', age=16}, Person{name='古天乐', age=18}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
返回age小于person.age的元素set:[Person{name='刘亦菲', age=11}, Person{name='周星驰', age=16}]

public E higher(E e)：返回严格大于给定键值的最小键值

demo：person上面有

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",18);
        set.add(person);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",16));
        set.add(new Person("李连杰",56));

        System.out.println("set:"+set);
        System.out.println("返回严格大于给定键值的最小键值:"+set.higher(person));
    }
}

结果

set:[Person{name='刘亦菲', age=11}, Person{name='周星驰', age=16}, Person{name='古天乐', age=18}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
返回严格大于给定键值的最小键值:Person{name='胡歌', age=22}

public boolean isEmpty()：判断集合是否为空

public Iterator<E> iterator() ：迭代输出

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",18);
        set.add(person);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",16));
        set.add(new Person("李连杰",56));

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

结果

Person{name='刘亦菲', age=11}
Person{name='周星驰', age=16}
Person{name='古天乐', age=18}
Person{name='胡歌', age=22}
Person{name='李连杰', age=56}

public E last()：获取最后的值

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",18);
        set.add(person);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",16));
        set.add(new Person("李连杰",56));


        System.out.println("set:"+set);
        System.out.println("获取最后的值:"+set.last());
    }
}

结果

set:[Person{name='刘亦菲', age=11}, Person{name='周星驰', age=16}, Person{name='古天乐', age=18}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
获取最后的值:Person{name='李连杰', age=56}

public E lower(E e)：返回严格小于给定键值的最大键值

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",18);
        set.add(person);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",18));
        set.add(new Person("李连杰",56));


        System.out.println("set:"+set);
        System.out.println("获取"+set.lower(person));
    }
}

结果

set:[Person{name='刘亦菲', age=11}, Person{name='古天乐', age=18}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
获取最后的值:Person{name='刘亦菲', age=11}

public E pollFirst()：获取第一个值并移除第一个值

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",18);
        set.add(person);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",18));
        set.add(new Person("李连杰",56));


        System.out.println("set:"+set);
        System.out.println("获取第一个值并移除这个值"+set.pollFirst());
        System.out.println("set:"+set);
    }
}

结果：

set:[Person{name='刘亦菲', age=11}, Person{name='古天乐', age=18}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
获取第一个值并移除这个值Person{name='刘亦菲', age=11}
set:[Person{name='古天乐', age=18}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]

public E pollLast()：获取最后值并移除这个值

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",18);
        set.add(person);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",18));
        set.add(new Person("李连杰",56));


        System.out.println("set:"+set);
        System.out.println("获取最后值并移除这个值"+set.pollLast());
        System.out.println("set:"+set);
    }
}

结果

set:[Person{name='刘亦菲', age=11}, Person{name='古天乐', age=18}, Person{name='胡歌', age=22}, Person{name='李连杰', age=56}]
获取最后值并移除这个值Person{name='李连杰', age=56}
set:[Person{name='刘亦菲', age=11}, Person{name='古天乐', age=18}, Person{name='胡歌', age=22}]

public boolean remove(Object o)：移除元素

public int size() ：当前set容量

public Spliterator<E> spliterator() ： 方法用于拆分set元素，并逐个迭代它们。

demo：链接

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",23);
        Person person2 = new Person("杨超越",18);
        set.add(person);
        set.add(person2);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",18));
        set.add(new Person("李连杰",56));


        System.out.println("set:"+set);
        Spliterator<Person> spliterator = (Spliterator<Person>) set.spliterator();
        spliterator.forEachRemaining(System.out::println);
    }
}

结果

set:[Person{name='刘亦菲', age=11}, Person{name='杨超越', age=18}, Person{name='胡歌', age=22}, Person{name='古天乐', age=23}, Person{name='李连杰', age=56}]
Person{name='刘亦菲', age=11}
Person{name='杨超越', age=18}
Person{name='胡歌', age=22}
Person{name='古天乐', age=23}
Person{name='李连杰', age=56}

public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement,   boolean toInclusive)：返回from到to之间的值，fromInclusive和toInclusive代表是否包含当前值

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",23);
        Person person2 = new Person("杨超越",18);
        set.add(person);
        set.add(person2);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",18));
        set.add(new Person("李连杰",56));


        System.out.println("set:"+set);
        System.out.println("返回age在18-23之间的值"+set.subSet(person2,true,person,true));
    }
}

结果：

set:[Person{name='刘亦菲', age=11}, Person{name='杨超越', age=18}, Person{name='胡歌', age=22}, Person{name='古天乐', age=23}, Person{name='李连杰', age=56}]
返回age在18-23之间的值[Person{name='杨超越', age=18}, Person{name='胡歌', age=22}, Person{name='古天乐', age=23}]

public SortedSet<E> subSet(E fromElement, E toElement)：返回from到to之间的值，包含from，不包含to，即【左闭右开）

public SortedSet<E> tailSet(E fromElement)：返回>=fromElement值的集合元素

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",23);
        Person person2 = new Person("杨超越",18);
        set.add(person);
        set.add(person2);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",18));
        set.add(new Person("李连杰",56));


        System.out.println("set:"+set);
        System.out.println("返回age在18-23之间的值"+set.tailSet(person2));
    }
}

结果

set:[Person{name='刘亦菲', age=11}, Person{name='杨超越', age=18}, Person{name='胡歌', age=22}, Person{name='古天乐', age=23}, Person{name='李连杰', age=56}]
返回age在18-23之间的值[Person{name='杨超越', age=18}, Person{name='胡歌', age=22}, Person{name='古天乐', age=23}, Person{name='李连杰', age=56}]

public NavigableSet<E> tailSet(E fromElement, boolean inclusive)返回>=fromElement值的集合元素，inclusive=true包含自身，=false就不包含

demo

public class Test {
    public static void main(String[] args) {
        TreeSet set = new TreeSet();
        Person person = new Person("古天乐",23);
        Person person2 = new Person("杨超越",18);
        set.add(person);
        set.add(person2);
        set.add(new Person("胡歌",22));
        set.add(new Person("刘亦菲",11));
        set.add(new Person("周星驰",18));
        set.add(new Person("李连杰",56));


        System.out.println("set:"+set);
        System.out.println("返回age在18-23之间的值"+set.tailSet(person2,false));
    }
}

结果

set:[Person{name='刘亦菲', age=11}, Person{name='杨超越', age=18}, Person{name='胡歌', age=22}, Person{name='古天乐', age=23}, Person{name='李连杰', age=56}]
返回age在18-23之间的值[Person{name='胡歌', age=22}, Person{name='古天乐', age=23}, Person{name='李连杰', age=56}]

黑皮爱学习
关注
  • 51
    点赞
  • 踩
  • 179
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
解决TreeSet类的排序问题
09-03
本文介绍TreeSet支持两种排序方法：自然排序和定制排序。TreeSet默认采用自然排序。详细请看下
java集合-TreeSet的使用
06-14
TreeSet 是 Java 中的一个集合类，它实现了 SortedSet 接口，并且使用红黑树作为底层数据结构。TreeSet 具有以下主要特点： 排序性：TreeSet 中的元素是有序的，默认按照元素的自然顺序进行排序。或者，可以在创建 TreeSet 时提供一个比较器（Comparator）来指定自定义的排序规则。 唯一性：TreeSet 中不允许重复元素，每个元素都必须是唯一的。如果将重复元素添加到 TreeSet 中，后面的重复元素将被忽略。 支持范围操作：TreeSet 提供了一些方法用于执行范围操作，例如 subSet()、headSet()、tailSet() 等，可以根据元素的顺序提取子集。 效率较高：基于红黑树的数据结构使得 TreeSet 在插入、删除和查找操作的时间复杂度都接近 O(log n)。 不允许空值：TreeSet 不允许插入空值（null），否则会抛出 NullPointerException。
List 去重的6种方法（contains、迭代、hashSet、treeSet、linkedHashSet、stream）
最新发布
12-26
1：contains判断去重(有序) 此方法的优点的：理解起来比较简单，并且最终得到的集合也是有序的，这里的有序指的是新集合的排列顺序和原集合的顺序是一致的;但缺点是实现代码有点多，不够简洁优雅。 2：迭代器去重(无序) 此方法的实现比上一种方法的实现代码要少一些，且不需要新建集合，但此方法得到的新集合是无序的，也就是新集合的排列顺序和原集合不一致 3：HashSet去重(无序) 此方法的实现代码较为简洁，但缺点是 HashSet 会自动排序，这样新集合的数据排序就和原集合不一致了 4：TreeSet去重(无序) 比较遗憾的是，TreeSet 虽然实现起来也比较简单，但它有着和 HashSet 一样的问题，会自动排序 5：LinkedHashSet去重(有序) 从代码和执行结果可以看出，LinkedHashSet 是到目前为止，实现比较简单，且最终生成的新集合与原集合顺序保持一致的实现方法 6：Stream去重(有序) Stream 实现去重功能和其他方法不同的是，它不用新创建集合，使用自身接收一个去重的结果就可以了，并且实现代码也很简洁
TreeSet详解和使用示例_动力节点Java学院整理
08-30
TreeSet 是一个有序的集合，它的作用是提供有序的Set集合。这篇文章主要介绍了TreeSet使用示例，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
TreeSet集合用法
05-19
介绍TreeSet集合用法，向TreeSet集合中添加类的对象，此类需实现Comparable接口，有实例，供需要的朋友下载学习。
TreeSet详解
热门推荐
ch98000的博客
08-30 1万+
TreeSet是一个使用你较少的一个Set容器，很多同学可能不知道它是干嘛的，它和HashSet有什么区别，它底层是如何实现的？本篇文章带你全面了解掌握TreeSet我们知道HashSet是没有顺序的，而TreeSet最大的特点就是一个有顺序的去重集合容器。集合中的元素没有重复集合中的元素不保证插入顺序，而是默认使用元素的自然排序，不过可以自定义排序器jdk8以后，集合中的元素不可以是null集合不是线程安全相对于HashSet, 性能更差。...
TreeSet的使用
muyuxifeng的博客
04-03 2327
TreeSet是一个有序的集合，它支持自然排序和根据实现Comparator或Comparable接口进行排序。下面通过案例来看一下TreeSet的使用 1、使用TreeSet对String类型的数据进行存储，存储顺序默认按字母升序排序。 在本例题中，定义TreeSet集合，并添加多个字符串到集合中，然后对集合进行遍历输出，并通过first()和last()方法来获取集合中的第一个和最后一个元素 package com.jinglan.sort; import java.util.TreeSet; pu
Java基础知识之TreeSet的使用
qq_45344586的博客
03-21 2981
Java基础知识之TreeSet的使用
TreeSet常用方法
qq_43776742的博客
06-12 5851
treeSet.add() public boolean add（E e） 如果指定的元素尚不存在，则将其添加到此集合中。更正式地说，e如果集合中不包含任何元素，则将指定的元素添加到此集合e2中 Objects.equals(e, e2)。如果此set已包含该元素，则调用将保持set不变并返回false。 treeSet.addAll() public boolean ad...
java中treemap和treeset实现红黑树
08-28
主要为大家详细介绍了java中treemap和treeset实现红黑树，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
HashSet和TreeSet使用方法的区别解析
08-28
主要介绍了HashSet和TreeSet使用方法的区别解析，具有一定借鉴价值,需要的朋友可以参考下
Java TreeSet实现学生按年龄大小和姓名排序的方法示例
08-29
主要介绍了Java TreeSet实现学生按年龄大小和姓名排序的方法,涉及java类型转换、遍历、比较等相关操作技巧,需要的朋友可以参考下
Java TreeSet类的简单理解和使用
08-25
主要介绍了Java TreeSet类的简单理解和使用,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
TreeSet解析
weixin_47382783的博客
07-28 2869
TreeSet实际上是TreeMap实现的，所以底层结构也是红黑树。TreeSet不需要重写hashCode()和euqals()方法，因为它去重是依靠比较器来去重，因为结构是红黑树，所以每次插入都会遍历比较来寻找节点插入位置，如果发现某个节点的值是一样的那就会直接覆盖。当我们构造TreeSet时；若使用不带参数的构造函数，则TreeSet的使用自然比较器；若用户需要使用自定义的比较器，则需要使用带比较器的参数。TreeSet是非线程安全的。...
TreeSet用法详解
qq1169091731的博客
10-04 2356
TreeSet 总结 特点：      无序（指的时存储顺序和取出顺序不同），但是内部其实有集合本身的排序方式      唯一（无重复元素） A:底层数据结构是红黑树(是一个自平衡的二叉树) B:保证元素的排序方式     a:自然排序(元素具备比较性)         1）让元素所属的类实现Comparable接口         2) 在类中重写Comparable的抽
【JavaSE专栏52】Java集合类TreeSet解析，基于红黑树实现的有序非重集合
Designer 小郑的技术博客
07-23 1515
本文讲解了 Java 中集合类 TreeSet 的语法、使用说明和应用场景，并给出了样例代码。
TreeSet的基本使用
TobEABetterMan_的博客
01-29 477
文章目录前言一、TreeSet的使用二、解法要求1.输入格式2.输出格式2.输入样例2.输出样例实现代码如下： 前言 Set类是继承Collection接口，Set类存储的元素，是无序，不重复的，比如Hashset类，但TreeSet 是一个排好序的集合类，默认情况下 存储的元素值不同，所以可以用TreeSet类对象在添加数据后 实现元素排序，同时去掉重复元素 只保留一个元素。如果元素对象没法比较大小，元素对应的类需要实现Comparable接口 一、TreeSet的使用 示例：Set类是继承Col.
Java TreeSet集合简介、常用方法详解
qq_52972504的博客
08-04 8241
1. TreeSet简介 TreeSet 是通过 TreeMap 实现的一个有序的、不可重复的集合 2. 构造方法——API文档 3. 常用方法——API文档 3.1 添加元素3.2删除元素3.3 判断集合元素个数3.4 迭代器遍历集合4. 在类对象中实现compareTo()方法 ......
treeset的底层实现原理
09-08
TreeSet的底层实现原理是基于红黑树（Red-Black Tree）。红黑树是一种自平衡二叉搜索树，它具有以下特点： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色的。 3. 所有叶子节点（NIL节点）都是黑色的。 4. 如果一个节点是红色的，则它的两个子节点都是黑色的。 5. 从根节点到叶子节点或空子节点的每条路径，都包含相同数目的黑色节点。 TreeSet利用红黑树的特性来实现有序集合。当元素被添加到TreeSet时，它会根据元素的值按照二叉搜索树的规则插入到合适的位置上。插入完成后，TreeSet会通过对红黑树进行调整，以保持红黑树的平衡性和有序性。 由于红黑树的特性，TreeSet支持高效的插入、删除和查找操作。插入和删除操作平均时间复杂度为O(log N)，查找操作的时间复杂度也为O(log N)，其中N为元素个数。 总结起来，TreeSet通过红黑树实现了有序集合，并保证了高效的插入、删除和查找操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值