• Java集合源码分析(十)——TreeSet


    简介

    TreeSet就是一个集合,里面不能有重复的元素,但是元素是有序的。

    TreeSet其实就是调用了TreeMap实现的,所以,它也不是线程安全的。可以实现自然排序或者根据传入的Comparator进行排序。

    TreeSet通过iterator()返回的迭代器是fail-fast的。

    TreeSet 实现了NavigableSet接口,意味着它支持一系列的导航方法。比如查找与指定目标最匹配项。TreeSet的导航方法大致可以区分为两类,一类时提供元素项的导航方法,返回某个元素;另一类时提供集合的导航方法,返回某个集合。
    lower、floor、ceiling 和 higher 分别返回小于、小于等于、大于等于、大于给定元素的元素,如果不存在这样的元素,则返回 null。

    源码分析

    TreeSet源码也很短,这里就不筛选分析了。

    
    package java.util;
    
    public class TreeSet<E> extends AbstractSet<E>
        implements NavigableSet<E>, Cloneable, java.io.Serializable
    {
    	// 这里就是一个TreeMap
        private transient NavigableMap<E,Object> m;
    
        // 为了在TreeMap中填入一个虚拟的值
        private static final Object PRESENT = new Object();
    
        TreeSet(NavigableMap<E,Object> m) {
            this.m = m;
        }
    
    	// 默认构造
        public TreeSet() {
            this(new TreeMap<E,Object>());
        }
    
    	// 传入比较器构造
        public TreeSet(Comparator<? super E> comparator) {
            this(new TreeMap<>(comparator));
        }
    
    	// 传入初始集合
        public TreeSet(Collection<? extends E> c) {
            this();
            addAll(c);
        }
    
    	// 传入一个排序的集合
        public TreeSet(SortedSet<E> s) {
        	// 获取比较器
            this(s.comparator());
            addAll(s);
        }
    	
    	// 获取迭代器
        public Iterator<E> iterator() {
            return m.navigableKeySet().iterator();
        }
    
    	// 反向迭代
        public Iterator<E> descendingIterator() {
            return m.descendingKeySet().iterator();
        }
    
    	// 后去逆序的集合
        public NavigableSet<E> descendingSet() {
            return new TreeSet<>(m.descendingMap());
        }
    
        public int size() {
            return m.size();
        }
    
    
        public boolean isEmpty() {
            return m.isEmpty();
        }
    
    
        public boolean contains(Object o) {
            return m.containsKey(o);
        }
    
    	// 添加元素
        public boolean add(E e) {
        	// value就是填入的虚拟值
            return m.put(e, PRESENT)==null;
        }
    	
    	// 删除元素
        public boolean remove(Object o) {
            return m.remove(o)==PRESENT;
        }
    
        public void clear() {
            m.clear();
        }
    
    	// 批量填入集合
        public  boolean addAll(Collection<? extends E> c) {
            // 初始值填入
            if (m.size()==0 && c.size() > 0 &&
                c instanceof SortedSet &&
                m instanceof TreeMap) {
                SortedSet<? extends E> set = (SortedSet<? extends E>) c;
                TreeMap<E,Object> map = (TreeMap<E, Object>) m;
                Comparator<?> cc = set.comparator();
                Comparator<? super E> mc = map.comparator();
                if (cc==mc || (cc != null && cc.equals(mc))) {
                	// 将集合填入TreeMap中
                    map.addAllForTreeSet(set, PRESENT);
                    return true;
                }
            }
            // 已经初始化Tree之后的填入
            return super.addAll(c);
        }
    
    	// 导航方法,获取区间内的集合
        public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                                      E toElement,   boolean toInclusive) {
            return new TreeSet<>(m.subMap(fromElement, fromInclusive,
                                           toElement,   toInclusive));
        }
    
    	// 导航方法,获取前面的集合
        public NavigableSet<E> headSet(E toElement, boolean inclusive) {
            return new TreeSet<>(m.headMap(toElement, inclusive));
        }
    
    	// 导航方法,获取后面的集合
        public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
            return new TreeSet<>(m.tailMap(fromElement, inclusive));
        }
    
    	// 获取区间的集合
        public SortedSet<E> subSet(E fromElement, E toElement) {
            return subSet(fromElement, true, toElement, false);
        }
    
    	// 获取前面的集合
        public SortedSet<E> headSet(E toElement) {
            return headSet(toElement, false);
        }
    
    	// 获取后面的集合
        public SortedSet<E> tailSet(E fromElement) {
            return tailSet(fromElement, true);
        }
        
    	// 获取比较器
        public Comparator<? super E> comparator() {
            return m.comparator();
        }
    
    	// 获取头
        public E first() {
            return m.firstKey();
        }
    	
    	// 获取尾
        public E last() {
            return m.lastKey();
        }
        
    	// 获取小于的元素
        public E lower(E e) {
            return m.lowerKey(e);
        }
    
    	// 获取小于等于
        public E floor(E e) {
            return m.floorKey(e);
        }
    
     	// 获取大于等于的元素
        public E ceiling(E e) {
            return m.ceilingKey(e);
        }
    
    	// 获取大于的元素
        public E higher(E e) {
            return m.higherKey(e);
        }
    
    	// 获取并删除头
        public E pollFirst() {
            Map.Entry<E,?> e = m.pollFirstEntry();
            return (e == null) ? null : e.getKey();
        }
    
    	// 获取并删除尾
        public E pollLast() {
            Map.Entry<E,?> e = m.pollLastEntry();
            return (e == null) ? null : e.getKey();
        }
    
    	// 克隆方法
        @SuppressWarnings("unchecked")
        public Object clone() {
            TreeSet<E> clone;
            try {
                clone = (TreeSet<E>) super.clone();
            } catch (CloneNotSupportedException e) {
                throw new InternalError(e);
            }
    		// 直接创建一个新的TreeMap
            clone.m = new TreeMap<>(m);
            return clone;
        }
    
    	// 写到输出流
        private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException {
            // Write out any hidden stuff
            s.defaultWriteObject();
    
            // Write out Comparator
            s.writeObject(m.comparator());
    
            // Write out size
            s.writeInt(m.size());
    
            // Write out all elements in the proper order.
            for (E e : m.keySet())
                s.writeObject(e);
        }
    
    
    	// 从输入流写入到对象
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            // Read in any hidden stuff
            s.defaultReadObject();
    
            // Read in Comparator
            @SuppressWarnings("unchecked")
                Comparator<? super E> c = (Comparator<? super E>) s.readObject();
    
            // Create backing TreeMap
            TreeMap<E,Object> tm = new TreeMap<>(c);
            m = tm;
    
            // Read in size
            int size = s.readInt();
    
            tm.readTreeSet(size, s, PRESENT);
        }
    
    	// 分割迭代器
        public Spliterator<E> spliterator() {
            return TreeMap.keySpliteratorFor(m);
        }
    
        private static final long serialVersionUID = -2479143000061671589L;
    }
    
    

    总结

    TreeeSet内部都是对TreeMap的调用,不同的Key值,相同的value值。

    可以通过迭代器和for-each方法对其进行遍历。

  • 相关阅读:
    技术期刊 · 五等分の花嫁 | Vue 3.2 正式发布!;大型项目管理策略;开源社区运营就像种菜;阮一峰的 fetch 教程;Webpack5 学习的平凡之路
    最近很火的低代码到底是什么?
    测试开发之前端篇-Web前端简介
    痞子衡嵌入式:简析i.MXRT1170 XECC功能特点及其保护串行NOR Flash和SDRAM之道
    痞子衡嵌入式:其实i.MXRT下改造FlexSPI driver同样支持AHB方式去写入NOR Flash
    《痞子衡嵌入式半月刊》 第 38 期
    [Vue深入组件]:native事件修饰符以及拓展之自定义组件的事件监听目标DOM元素自定义
    [Vue深入组件]:v-model语法糖与自定义v-model
    [Vue深入组件]:禁用 Attribute 继承
    @from [GITHUB] : Learn regex the easy way
  • 原文地址:https://www.cnblogs.com/lippon/p/14117598.html
Copyright © 2020-2023  润新知