HashSet、LinkedHashSet、TreeSet的内部实现简介

本文深入探讨了Java中三种Set实现:HashSet、LinkedHashSet和TreeSet的内部工作机制。详细解析了它们如何基于HashMap、LinkedHashMap和TreeMap来确保元素的唯一性,并介绍了各Set实现的特点及其应用场景。

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

在写这篇博客之前,本人已经介绍了HashMap(HashMap内部存储实现及HashTable比较)、LinkedHashMap(LinkedHashMap内部实现)、TreeMap(TreeMap内部实现简介)。考虑到即将介绍的三种Set类型是基于上述Map类型的,于是直接归纳其关联,这样简洁明了。

1、HashSet继承AbstractSet类,实现了Set等接口,但最重要的是HashSet是基于HashMap来实现的。先看构造函数:

/**
         * 默认构造函数
         * 初始化一个空的HashMap,并使用默认初始容量为16和加载因子0.75。
         */
        public HashSet() {
            map = new HashMap<>();
        }

        /**
         * 构造一个包含指定 collection 中的元素的新 set。
         */
        public HashSet(Collection<? extends E> c) {
            map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
            addAll(c);
        }

        /**
         * 构造一个新的空 set,其底层 HashMap 实例具有指定的初始容量和指定的加载因子
         */
        public HashSet(int initialCapacity, float loadFactor) {
            map = new HashMap<>(initialCapacity, loadFactor);
        }

        /**
         * 构造一个新的空 set,其底层 HashMap 实例具有指定的初始容量和默认的加载因子(0.75)。
         */
        public HashSet(int initialCapacity) {
           map = new HashMap<>(initialCapacity);
        }

        /**
         * 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。
         * dummy 为标识 该构造函数主要作用是对LinkedHashSet起到一个支持作用
         */
        HashSet(int initialCapacity, float loadFactor, boolean dummy) {
           map = new LinkedHashMap<>(initialCapacity, loadFactor);
        }

从各个构造函数可以看出,HashSet在构造时都会构造出一个HashMap。HashSet将数据存储到HashMap的key中,因为key是不可重复的,这就满足了HashSet中的值不会重复;而HashMap中的值会放入一个虚拟的object对象。正是由于HashSet是基于HashMap实现的,它的相关操作都是直接调用底层的HashMap的相关方法来实现的。HashSet源代码如下:

/** 
     * 返回对此set中元素进行迭代的迭代器。返回元素的顺序并不是特定的。 
     * @return 对此set中元素进行迭代的Iterator。 
     */  
    public Iterator<E> iterator() {  
    return map.keySet().iterator();  
    }  
  
    /** 
     * 返回此set中的元素的数量(set的容量)。 
     * 
     * 底层实际调用HashMap的size()方法返回Entry的数量,就得到该Set中元素的个数。 
     * @return 此set中的元素的数量(set的容量)。 
     */  
    public int size() {  
    return map.size();  
    }  
  
    /** 
     * 如果此set不包含任何元素,则返回true。 
     * 
     * 底层实际调用HashMap的isEmpty()判断该HashSet是否为空。 
     * @return 如果此set不包含任何元素,则返回true。 
     */  
    public boolean isEmpty() {  
    return map.isEmpty();  
    }  
  
    /** 
     * 如果此set包含指定元素,则返回true。 
     * 更确切地讲,当且仅当此set包含一个满足(o==null ? e==null : o.equals(e)) 
     * 的e元素时,返回true。 
     * 
     * 底层实际调用HashMap的containsKey判断是否包含指定key。 
     * @param o 在此set中的存在已得到测试的元素。 
     * @return 如果此set包含指定元素,则返回true。 
     */  
    public boolean contains(Object o) {  
    return map.containsKey(o);  
    }  
  
    /** 
     * 如果此set中尚未包含指定元素,则添加指定元素。 
     * 更确切地讲,如果此 set 没有包含满足(e==null ? e2==null : e.equals(e2)) 
     * 的元素e2,则向此set 添加指定的元素e。 
     * 如果此set已包含该元素,则该调用不更改set并返回false。 
     * 
     * 底层实际将将该元素作为key放入HashMap。 
     * 由于HashMap的put()方法添加key-value对时,当新放入HashMap的Entry中key 
     * 与集合中原有Entry的key相同(hashCode()返回值相等,通过equals比较也返回true), 
     * 新添加的Entry的value会将覆盖原来Entry的value,但key不会有任何改变, 
     * 因此如果向HashSet中添加一个已经存在的元素时,新添加的集合元素将不会被放入HashMap中, 
     * 原来的元素也不会有任何改变,这也就满足了Set中元素不重复的特性。 
     * @param e 将添加到此set中的元素。 
     * @return 如果此set尚未包含指定元素,则返回true。 
     */  
    public boolean add(E e) {  
    return map.put(e, PRESENT)==null;  
    }  
  
    /** 
     * 如果指定元素存在于此set中,则将其移除。 
     * 更确切地讲,如果此set包含一个满足(o==null ? e==null : o.equals(e))的元素e, 
     * 则将其移除。如果此set已包含该元素,则返回true 
     * (或者:如果此set因调用而发生更改,则返回true)。(一旦调用返回,则此set不再包含该元素)。 
     * 
     * 底层实际调用HashMap的remove方法删除指定Entry。 
     * @param o 如果存在于此set中则需要将其移除的对象。 
     * @return 如果set包含指定元素,则返回true。 
     */  
    public boolean remove(Object o) {  
    return map.remove(o)==PRESENT;  
    }  
  
    /** 
     * 从此set中移除所有元素。此调用返回后,该set将为空。 
     * 
     * 底层实际调用HashMap的clear方法清空Entry中所有元素。 
     */  
    public void clear() {  
    map.clear();  
    }  
  
    /** 
     * 返回此HashSet实例的浅表副本:并没有复制这些元素本身。 
     * 
     * 底层实际调用HashMap的clone()方法,获取HashMap的浅表副本,并设置到HashSet中。 
     */  
    public Object clone() {  
        try {  
            HashSet<E> newSet = (HashSet<E>) super.clone();  
            newSet.map = (HashMap<E, Object>) map.clone();  
            return newSet;  
        } catch (CloneNotSupportedException e) {  
            throw new InternalError();  
        }  
    }  
}


2、LinkedHashSet

LinkedHashSet继承了HashSet,又基于LinkedHashMap来实现。LinkedHashSet底层使用LinkedHashMap的key来保存所有元素,从而维护着一个运行于所有元素的双向链表。该双向链表定义了迭代顺序,该顺序分为插入顺序和访问顺序(具体请看:LinkedHashMap内部实现)。因为它继承了父类HashSet,所以它的所有操作方法都与HashSet相同,直接调用父类的方法即可。其中,HashSet还专为LinkedHashSet提供了构造方法,由于包访问权限,并未对外公开。代码如下:

/** 
     * 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。  
     * 
     * 实际底层会以指定的参数构造一个空LinkedHashMap实例来实现。 
     * @param initialCapacity 初始容量。 
     * @param loadFactor 加载因子。 
     * @param dummy 标记。 
     */  
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {  
    map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);  
    }  

3、TreeSet

TreeSet继承自AbstractSet,又基于TreeMap实现,因为TreeSet底层使用一个TreeMap,它的元素存储在TreeMap的key中,保证了不可重复性。同时,TreeSet中的元素也是排好序的,操作的时间复杂度也与TreeMap相同。与HashSet类似的是,TreeSet的大部分方法也是直接调用TreeMap中的方法。(关于TreeMap,请看:TreeMap内部实现)。其中,TreeSet的构造函数代码如下所示:

public class TreeSet<E> extends AbstractSet<E> 
    implements NavigableSet<E>, Cloneable, java.io.Serializable 
 { 
    // 使用 NavigableMap 的 key 来保存 Set 集合的元素
    private transient NavigableMap<E,Object> m; 
    // 使用一个 PRESENT 作为 Map 集合的所有 value。
    private static final Object PRESENT = new Object(); 
    // 包访问权限的构造器,以指定的 NavigableMap 对象创建 Set 集合
    TreeSet(NavigableMap<E,Object> m) 
    { 
        this.m = m; 
    } 
    public TreeSet()                                      // 默认构造函数
    { 
        // 以自然排序方式创建一个新的 TreeMap,
        // 根据该 TreeSet 创建一个 TreeSet,
        // 使用该 TreeMap 的 key 来保存 Set 集合的元素
        this(new TreeMap<E,Object>()); 
    } 
    public TreeSet(Comparator<? super E> comparator) 
    { 
        // 以定制排序方式创建一个新的 TreeMap,
        // 根据该 TreeSet 创建一个 TreeSet,
        // 使用该 TreeMap 的 key 来保存 Set 集合的元素
        this(new TreeMap<E,Object>(comparator)); 
    } 
    public TreeSet(Collection<? extends E> c) 
    { 
        // 调用默认构造函数创建一个 TreeSet,底层以 TreeMap 保存集合元素
        this(); 
        // 向 TreeSet 中添加 Collection 集合 c 里的所有元素
        addAll(c); 
    } 
    public TreeSet(SortedSet<E> s) 
    { 
        //调用含有比较器参数的构造函数
        this(s.comparator()); 
        // 向 TreeSet 中添加 SortedSet 集合 s 里的所有元素
        addAll(s); 
    } 
    //TreeSet 的其他方法都只是直接调用 TreeMap 的方法来提供实现
    ... 
}



<think>首先,用户的问题是:“我想理解Java集合框架中HashSetLinkedHashSetTreeSet的区别 请问JavaHashSet, LinkedHashSetTreeSet的区别”。所以,我需要清晰地解释这三种Set实现之间的区别。 从系统指令中,我必须: - 所有行内数学表达式使用$...$格式。 - 独立公式使用$$...$$格式并单独成段。 - LaTeX语法正确。 - 使用中文回答。 - 生成相关问题。 - 在回答中引用的段落末尾自然地添加引用标识,如[^1]。 用户提供的引用是: - [^1]: HashSet基于HashMap,允许null,不保证顺序,操作平均O(1)。 - [^2]: LinkedHashSetHashSet的子类,使用LinkedHashMap维护插入顺序。 - [^3]: LinkedHashSet继承HashSet,使用LinkedHashMap。 - [^4]: 性能比较:HashSet最高,LinkedHashSet次之,TreeSet最差(因为排序)。 - [^5]: 遍历Set的示例。 这些引用来自之前的上下文,但用户说“上述引用仅供参考”,所以我应该基于这些内容构建回答,但确保回答真实可靠。 关键区别点: 1. **HashSet**:无序,基于哈希表实现,操作平均时间复杂度O(1)。 2. **LinkedHashSet**:维护插入顺序,基于LinkedHashMap,操作时间复杂度类似HashSet,但略有开销。 3. **TreeSet**:有序(自然排序或自定义排序),基于红黑树实现,操作平均时间复杂度O(log n)。 其他方面: - 允许null值:HashSetLinkedHashSet允许null,TreeSet可能不允许(取决于Comparator)。 - 线程安全:三者都不是线程安全的。 - 性能:如引用[^4]所述,HashSet最快,LinkedHashSet次之,TreeSet最慢。 结构回答: - 介绍每个Set。 - 比较关键特性:顺序、底层实现、性能、允许null等。 - 使用表格或列表清晰展示区别。 - 添加代码示例(如果合适)。 - 自然地引用提供的引用。 最后,生成相关问题。 回答结构: 1. **引言**:简要介绍Set接口三种实现。 2. **详细解释每个Set**: - HashSet - LinkedHashSet - TreeSet 3. **比较表格**:总结区别。 4. **代码示例**:展示简单使用。 5. **结论**:总结适用场景。 6. **相关问题**:生成2-3个相关问题。 确保使用中文。 在回答中,当引用信息时,添加引用标识如[^1]。例如,提到HashSet的性能时,可以引用[^1]。 生成相关问题: - 基于内容,如:如何选择哪个Set?TreeSet的排序如何工作?等。 现在,构建回答。</think>### JavaHashSetLinkedHashSetTreeSet的区别 在Java集合框架中,`Set`接口表示不包含重复元素的集合。`HashSet`、`LinkedHashSet``TreeSet`是`Set`的三种主要实现类,它们在底层实现、元素顺序、性能适用场景上有显著区别。以下我将逐步解释这些区别,帮助您全面理解。 #### 1. **HashSet** - **底层实现**:基于`HashMap`实现,使用哈希表存储元素。哈希表通过哈希函数计算元素位置,实现快速访问。 - **元素顺序**:不保证元素的迭代顺序(即无序),顺序可能随时间变化[^1]。 - **性能**:添加、删除查找操作的平均时间复杂度为$O(1)$(常数时间),在理想哈希条件下效率最高[^1]。 - **允许null值**:是,允许一个`null`元素。 - **线程安全**:非线程安全,需外部同步。 - **适用场景**:当需要快速查找去重,且不关心元素顺序时,如缓存或集合运算。 示例代码: ```java Set<String> hashSet = new HashSet<>(); hashSet.add("Apple"); hashSet.add("Banana"); hashSet.add(null); // 允许null System.out.println(hashSet); // 输出可能为[null, Apple, Banana]或其他无序顺序 ``` #### 2. **LinkedHashSet** - **底层实现**:继承自`HashSet`,但使用`LinkedHashMap`维护一个双向链表,记录元素的插入顺序[^2][^3]。 - **元素顺序**:保证元素的迭代顺序与插入顺序一致(即有序),适合需要保留添加顺序的场景。 - **性能**:操作平均时间复杂度也为$O(1)$,但由于链表维护的开销,性能略低于`HashSet`但高于`TreeSet`[^4]。 - **允许null值**:是,允许一个`null`元素。 - **线程安全**:非线程安全。 - **适用场景**:当需要保留插入顺序且高效访问时,如LRU缓存或日志记录。 示例代码: ```java Set<String> linkedHashSet = new LinkedHashSet<>(); linkedHashSet.add("Apple"); linkedHashSet.add("Banana"); linkedHashSet.add("Cherry"); System.out.println(linkedHashSet); // 输出总是[Apple, Banana, Cherry],保持插入顺序 ``` #### 3. **TreeSet** - **底层实现**:基于`TreeMap`实现,使用红黑树(一种自平衡二叉搜索树)存储元素。元素按自然顺序或自定义`Comparator`排序[^4]。 - **元素顺序**:保证元素按升序排序(自然排序)或指定顺序排序(自定义排序),即有序集合。 - **性能**:添加、删除查找操作的平均时间复杂度为$O(\log n)$(对数时间),因为需要维护树结构平衡,性能低于前两者[^4]。 - **允许null值**:否(如果使用自然排序,添加`null`会抛出`NullPointerException`;自定义`Comparator`可能支持,但不推荐)。 - **线程安全**:非线程安全。 - **适用场景**:当需要元素排序范围查询(如`subSet()`方法)时,如排行榜或有序数据集。 示例代码: ```java Set<String> treeSet = new TreeSet<>(); treeSet.add("Cherry"); treeSet.add("Apple"); treeSet.add("Banana"); System.out.println(treeSet); // 输出总是[Apple, Banana, Cherry],按字母升序排序 ``` #### 关键区别总结 下表总结了三种`Set`实现的核心区别: | 特性 | HashSet | LinkedHashSet | TreeSet | |----------------------|------------------|-----------------------------|----------------------| | **底层实现** | 基于HashMap | 基于LinkedHashMap(HashSet子类)[^2][^3] | 基于TreeMap(红黑树) | | **元素顺序** | 无序 | 插入顺序有序 | 排序顺序(自然或自定义) | | **平均时间复杂度** | $O(1)$(操作) | $O(1)$(略低于HashSet)[^4] | $O(\log n)$(操作) | | **允许null** | 是 | 是 | 否(通常) | | **主要优势** | 最高性能 | 保留插入顺序 | 自动排序 | | **典型应用场景** | 去重、快速查找 | 有序迭代(如FIFO缓存) | 排序集合、范围查询 | #### 性能比较 根据基准测试,在插入查找操作上: - `HashSet`性能最高(哈希表直接定位)。 - `LinkedHashSet`次之(链表维护增加轻微开销)。 - `TreeSet`最慢(树结构需动态平衡)[^4]。 #### 如何选择? - 需要**最高性能无序存储**?选`HashSet`。 - 需要**保留插入顺序**?选`LinkedHashSet`。 - 需要**元素排序或范围操作**?选`TreeSet`。 总之,理解这些区别有助于优化代码性能。如果您有具体使用场景,我可以提供更针对性的建议。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值