TreeSet源码分析(JDK1.8)

Dear 丶 2023-07-03 04:42 18阅读 0赞

### 文章目录 ###

*   *   *  成员变量
         *   *  1、m
             *  2、PRESENT
         *  构造方法
         *   *  1、TreeSet()：无参构造方法
             *  2、TreeSet(Comparator<? super E> comparator)：指定比较器
             *  3、TreeSet(Collection<? extends E> c)：在初始化时构造一组包含指定集合中的元素的TreeSet对象
             *  4、TreeSet(SortedSet s)：在初始化时构造一组包含指定集合和指定比较器中的元素的TreeSet对象
         *  常用方法
         *   *  1、add(E e)
             *  2、remove(Object o)
             *  3、removeAll(Collection<?> c)
             *  4、contains(Object o)
             *  5、containsAll(Collection<?> c)
             *  6、retainAll(Collection<?> c)
             *  7、isEmpty()
             *  8、iterator()
             *  9、equals(Object o)
             *  10、size()
             *  11、clear()
             *  12、comparator()
         *  总结

### 成员变量 ###

#### 1、m ####

/** * TreeSet底层是以TreeMap来储存数据的，key为add()中的元素，value为PRESENT值 */
    private transient NavigableMap<E,Object> m;

#### 2、PRESENT ####

/** * 空的Object对象，作为TreeMap中的value值 */
    private static final Object PRESENT = new Object();

### 构造方法 ###

#### 1、TreeSet()：无参构造方法 ####

/** * 无参构造方法，创建一个TreeSet对象 */
    public TreeSet() { 
      this(new TreeMap<E,Object>());
    }
    
    /** * 创建一个TreeMap对象 */
    TreeSet(NavigableMap<E,Object> m) { 
      this.m = m;
    }

#### 2、TreeSet(Comparator<? super E> comparator)：指定比较器 ####

/** * 指定比较器创建一个TreeMap对象 */
    public TreeSet(Comparator<? super E> comparator) { 
      this(new TreeMap<>(comparator));
    }

#### 3、TreeSet(Collection<? extends E> c)：在初始化时构造一组包含指定集合中的元素的TreeSet对象 ####

/** * 先创建一个TreeMap对象，再添加指定集合中的元素 */
    public TreeSet(Collection<? extends E> c) { 
      this();
      addAll(c);
    }

#### 4、TreeSet(SortedSet s)：在初始化时构造一组包含指定集合和指定比较器中的元素的TreeSet对象 ####

/** * 指定比较器创建一个TreeMap对象，再添加指定集合中的元素 */
    public TreeSet(SortedSet<E> s) { 
      this(s.comparator());
      addAll(s);
    }

### 常用方法 ###

#### 1、add(E e) ####

**add(E e)执行原理：**

> 调用TreeMap中的put()方法进行添加元素

**add(E e)源码：**

/** * 调用TreeMap中的put()方法进行添加元素 */
    public boolean add(E e) { 
      return m.put(e, PRESENT)==null;
    }

#### 2、remove(Object o) ####

**remove(Object o)执行原理：**

> 调用TreeMap中的remove()方法来删除TreeSet中的元素

**remove(Object o)源码：**

/** * 调用TreeMap中的remove()方法来删除TreeSet中的元素 */
    public boolean remove(Object o) { 
      return m.remove(o)==PRESENT;
    }

#### 3、removeAll(Collection<?> c) ####

**removeAll(Collection<?> c)执行原理：**

> 1、调用TreeSet的父类AbstractSet中的removeAll(Collection<?> c)方法
> 
> 2、循环删除当前TreeSet对象的在传入集合对象中存在的元素

**removeAll(Collection<?> c)源码：**

/** * 循环删除当前TreeSet对象的在传入集合对象中存在的元素 */
    public boolean removeAll(Collection<?> c) { 
      Objects.requireNonNull(c);
      boolean modified = false;
    
      // 如果当前TreeSet对象的实际元素个数>传入的集合对象的实际元素个数
      if (size() > c.size()) { 
        for (Iterator<?> i = c.iterator(); i.hasNext(); )
          modified |= remove(i.next());
      }
      
      // 如果当前TreeSet对象的实际元素个数<传入的集合对象的实际元素个数
      else { 
        for (Iterator<?> i = iterator(); i.hasNext(); ) { 
          if (c.contains(i.next())) { 
            i.remove();
            modified = true;
          }
        }
      }
      return modified;
    }

#### 4、contains(Object o) ####

**contains(Object o)执行原理：**

> 调用TreeMap中的contains()方法判断TreeSet中是否包含此key

**contains(Object o)源码：**

/** * 调用TreeMap中的contains()方法判断TreeSet中是否包含此key */
    public boolean contains(Object o) { 
      return m.containsKey(o);
    }

#### 5、containsAll(Collection<?> c) ####

**containsAll(Collection<?> c)执行原理：**

> 1、调用TreeSet的父类AbstractSet的父类AbstractCollection中的containsAll(Collection<?> c)方法
> 
> 2、循环判断传入的集合中的元素是否包含在TreeSet集合中

**containsAll(Collection<?> c)源码：**

/** * 循环判断传入的集合中的元素是否包含在TreeSet集合中 */
    public boolean containsAll(Collection<?> c) { 
      for (Object e : c)
        if (!contains(e))
          return false;
      return true;
    }

#### 6、retainAll(Collection<?> c) ####

**retainAll(Collection<?> c)执行原理：**

> 1、调用TreeSet的父类AbstractCollection中的retainAll(Collection<?> c)方法
> 
> 2、迭代器遍历，如果TreeSet集合中的元素不在传入的集合对象之中，那么就删除

**retainAll(Collection<?> c)源码：**

/** * 迭代器遍历，如果TreeSet集合中的元素不在传入的集合对象之中，那么就删除 */
    public boolean retainAll(Collection<?> c) { 
      Objects.requireNonNull(c);
      boolean modified = false;
      
      // 迭代器遍历当前TreeSet集合中的元素
      Iterator<E> it = iterator();
      while (it.hasNext()) { 
        // 如果TreeSet集合中的元素不在传入的集合对象之中，那么就删除
        if (!c.contains(it.next())) { 
          it.remove();
          modified = true;
        }
      }
      return modified;
    }

#### 7、isEmpty() ####

**isEmpty()执行原理：**

> 调用TreeMap中的isEmpty()方法判断TreeSet中是否包含元素

**isEmpty()源码：**

/** * 调用TreeMap中的isEmpty()方法判断TreeSet中是否包含元素 */
    public boolean isEmpty() { 
      return m.isEmpty();
    }

#### 8、iterator() ####

**iterator()执行原理：**

> 调用TreeMap中的内部类KeySet中的iterator()方法

**iterator()源码：**

/** * 调用TreeMap中的内部类KeySet中的iterator()方法 */
    public Iterator<E> iterator() { 
      return m.navigableKeySet().iterator();
    }

#### 9、equals(Object o) ####

**equals(Object o)执行原理：**

> 1、调用TreeSet的父类AbstractSet中的equals(Object o)方法
> 
> 2、底层通过调用containsAll()方法来进行判断的

**equals(Object o)源码：**

/** * 判断传入的对象是否和TreeSet对象一致 */
    public boolean equals(Object o) { 
      // 当传入对象为当前对象时
      if (o == this)
        return true;
    
      // 当传入对象没有实现Set接口时
      if (!(o instanceof Set))
        return false;
      
      // 当传入对象的实际元素个数不等时
      Collection<?> c = (Collection<?>) o;
      if (c.size() != size())
        return false;
      
      // 调用containsAll()来判断传入的集合元素是否都在TreeSet对象中
      try { 
        return containsAll(c);
      } catch (ClassCastException unused)   { 
        return false;
      } catch (NullPointerException unused) { 
        return false;
      }
    }

#### 10、size() ####

**size()执行原理：**

> 调用TreeMap中的size()方法来获取TreeSet中实际元素的个数

**size()源码：**

/** * 调用TreeMap中的size()方法来获取TreeSet中实际元素的个数 */
    public int size() { 
      return m.size();
    }

#### 11、clear() ####

**clear()执行原理：**

> 调用TreeMap中的clear()方法进行清除TreeMap中所有的元素

**clear()源码：**

/** * 调用TreeMap中的clear()方法进行清除TreeMap中所有的元素 */
    public void clear() { 
      m.clear();
    }

#### 12、comparator() ####

**comparator()执行原理：**

> 调用TreeMap中的comparator()方法获取指定的比较器

**comparator()源码：**

/** * 调用TreeMap中的comparator()方法获取指定的比较器 */
    public Comparator<? super E> comparator() { 
      return m.comparator();
    }

### 总结 ###

*  TreeSet底层是使用[TreeMap][]来存储数据，key值为TreeSet中的数据，value值为一个空的Object对象
 *  TreeSet的方法大多是通过调用[TreeMap][]中的方法来实现的
 *  TreeSet和[TreeMap][]一样，都是线程不安全的集合类
 *  TreeSet和[TreeMap][]一样，有两种方式定义key的比较规则，优先使用指定的构造器进行比较key
    
     *  key实现Comparable接口重写compareTo方法
     *  通过TreeSet的构造方法指定构造器

[TreeMap]: https://blog.csdn.net/qq_35620501/article/details/104139417

发表评论取消回复

表情：

评论列表（有 0 条评论，18人围观）

还没有评论，来说两句吧...

相关阅读

相关【JDK源码】PriorityQueue源码分析

文章目录 PriorityQueue源码分析 1.简介 2.主要属性 3.入队 4.扩容 5.出

曾经终败给现在/ 2023年10月01日 11:38/ 0 赞/ 68 阅读

相关【JDK源码】LinkedList源码分析

文章目录 LinkedList源码分析 1.简介 2.主要属性 3.主要内部类 4.主要构造方法

朱雀/ 2023年10月01日 11:37/ 0 赞/ 70 阅读

相关【JDK源码】ArrayList 源码分析

文章目录 ArrayList 源码分析 1.简介 2.属性 3.构造方法 ArrayList(int i

怼烎@/ 2023年10月01日 11:36/ 0 赞/ 83 阅读

相关 TreeSet源码分析(JDK1.8)

文章目录成员变量 1、m 2、PRESENT 构造方法

Dear 丶/ 2023年07月03日 04:42/ 0 赞/ 19 阅读

相关 TreeSet源码分析

阅读本文章之前推荐先阅读博主的关于HashSet和TreeMap的源码分析，传送地址： [HashSet源码分析，基于JDK1.8详细分析][HashSet_JDK1.8]

刺骨的言语ヽ痛彻心扉/ 2023年01月19日 03:13/ 0 赞/ 218 阅读

相关【Java容器源码】TreeSet 源码分析

TreeSet 大致的结构和 HashSet 相似，具体可以看上篇[HashSet源码分析][HashSet]，这里底层组合的是 TreeMap，所以继承了 TreeMap k

雨点打透心脏的1/2处/ 2022年12月05日 15:14/ 0 赞/ 260 阅读

相关深入源码分析TreeSet和TreeMap

类似于前面介绍的HashMap和HashSet之间的关系，HashSet底层依赖于HashMap实现，而TreeSet底层则采用一个NavigableMap来保存TreeSet

心已赠人/ 2022年08月21日 08:58/ 0 赞/ 335 阅读

相关 TreeSet实现原理及源码分析

类似于HashMap和HashSet之间的关系，HashSet底层依赖于HashMap实现，TreeSet底层则采用一个NavigableMap来保存TreeSet集合的元素。

红太狼/ 2022年06月11日 06:50/ 0 赞/ 287 阅读

相关 Set源码分析（HashSet,TreeSet）

Set不允许重复的，HashSet无序，TreeSet有序的 HashSet 变量 private transient HashMap<E,Object> m

Dear 丶/ 2022年03月10日 04:58/ 0 赞/ 319 阅读

相关 JDK源码分析－－Properties源码分析

注：以下分析基于JDK1.8.0\_74。一、概述 1、Properties类表示一组持久属性。属性列表中的每个键及其对

深碍√TFBOYSˉ_/ 2022年02月27日 03:38/ 0 赞/ 570 阅读