HashSet , TreeSet , LinkedHashSet 对比

最新推荐文章于 2024-03-08 16:10:40 发布
最新推荐文章于 2024-03-08 16:10:40 发布
阅读量317 收藏 1
点赞数
分类专栏： JAVA
本文详细比较了Java中HashSet、TreeSet和LinkedHashSet三种集合类的特点及适用场景，并通过具体实例展示了它们的不同之处，包括元素的存储顺序、性能差异等。

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

Set 是一个没有重复元素的集合。何时使用是一个重要的问题。简而言之，如果您需要一个快速集合，您应该使用HashSet;如果您需要一个排序集合，那么应该使用TreeSet;如果您需要一个可以存储插入顺序的集合，那么应该使用LinkedHashSet。

1. Set Interface

Set是继承Collection 接口的。
这里写图片描述

2. HashSet ,TreeSet ,LinkedHashSet的区别

HashSet 是由hash table实现的，元素是无序的，添加、删除和包含方法具有常量时间复杂度O（1）。
TreeSet 是使用树形结构（算法书中的红黑树）实现的。集合中的元素是有序的，但是add、remove和包含方法的时间复杂度是O（log（n）），它提供了几个有序集合处理方法，比如first(), last(), headSet(), tailSet()等等。
LinkedHashSet 位于 HashSet和TreeSet之间。是由hash table和linked list实现的,所以是以插入顺序保存的。基本方法的时间复杂度是O（1）。

3. TreeSet 的例子

TreeSet<Integer> tree = new TreeSet<Integer>();
tree.add(12);
tree.add(63);
tree.add(34);
tree.add(45);

Iterator<Integer> iterator = tree.iterator();
System.out.print("Tree set data: ");
while (iterator.hasNext()) {
    System.out.print(iterator.next() + " ");
}

输出结果:

Tree set data: 12 34 45 63

Dog类:

class Dog {
    int size;

    public Dog(int s) {
        size = s;
    }

    public String toString() {
        return size + "";
    }

遍历Dog:

import java.util.Iterator;
import java.util.TreeSet;

public class TestTreeSet {
    public static void main(String[] args) {
        TreeSet<Dog> dset = new TreeSet<Dog>();
        dset.add(new Dog(2));
        dset.add(new Dog(1));
        dset.add(new Dog(3));

        Iterator<Dog> iterator = dset.iterator();

        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
    }
}

结果报错了：

Exception in thread “main” java.lang.ClassCastException: collection.Dog cannot be cast to java.lang.Comparable
at java.util.TreeMap.put(Unknown Source)
at java.util.TreeSet.add(Unknown Source)
at collection.TestTreeSet.main(TestTreeSet.java:22)

因为TreeSet是有序的，Dog类需要实现java.lang.Comparable’s compareTo() 方法。

class Dog implements Comparable<Dog>{
    int size;

    public Dog(int s) {
        size = s;
    }

    public String toString() {
        return size + "";
    }

    @Override
    public int compareTo(Dog o) {
            return size - o.size;
    }
}

结果为：

1 2 3

4. HashSet 的例子

HashSet<Dog> dset = new HashSet<Dog>();
dset.add(new Dog(2));
dset.add(new Dog(1));
dset.add(new Dog(3));
dset.add(new Dog(5));
dset.add(new Dog(4));
Iterator<Dog> iterator = dset.iterator();
while (iterator.hasNext()) {
    System.out.print(iterator.next() + " ");
}

结果：

5 3 2 1 4

注意输出顺序是乱的。

5. LinkedHashSet 的例子

LinkedHashSet<Dog> dset = new LinkedHashSet<Dog>();
dset.add(new Dog(2));
dset.add(new Dog(1));
dset.add(new Dog(3));
dset.add(new Dog(5));
dset.add(new Dog(4));
Iterator<Dog> iterator = dset.iterator();
while (iterator.hasNext()) {
    System.out.print(iterator.next() + " ");
}

结果：

2 1 3 5 4

性能测试

add() 方法的性能：

public static void main(String[] args) {
Random r = new Random();
HashSet<Dog> hashSet = new HashSet<Dog>();
TreeSet<Dog> treeSet = new TreeSet<Dog>();
LinkedHashSet<Dog> linkedSet = new LinkedHashSet<Dog>();
// start time
long startTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
int x = r.nextInt(1000 - 10) + 10;
hashSet.add(new Dog(x));
}
// end time
long endTime = System.nanoTime();
long duration = endTime - startTime;
System.out.println("HashSet: " + duration);
// start time
startTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
int x = r.nextInt(1000 - 10) + 10;
treeSet.add(new Dog(x));
}
// end time
endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println("TreeSet: " + duration);
// start time
startTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
int x = r.nextInt(1000 - 10) + 10;
linkedSet.add(new Dog(x));
}
// end time
endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println("LinkedHashSet: " + duration);
}

结果，HashSet是最快的跟LinkedHashSet是差不多，但是TreeSet是最慢的：

HashSet: 2244768
TreeSet: 3549314
LinkedHashSet: 2263320

*测试不是精确的，但是可以反映出TreeSet要慢得多的基本思想，因为它是有序的。

这里写图片描述

转自：https://www.programcreek.com/2013/03/hashset-vs-treeset-vs-linkedhashset/

但是本人亲自实验却与测试结果不同！

package com.moha.demo.util;


import java.util.*;

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


        Random r = new Random();

        HashSet<Dog> hashSet = new HashSet<Dog>();
        TreeSet<Dog> treeSet = new TreeSet<Dog>();
        LinkedHashSet<Dog> linkedSet = new LinkedHashSet<Dog>();



        // start time
        long startTime = System.nanoTime();

        for (int i = 0; i < 1000; i++) {
            int x = r.nextInt(1000 - 10) + 10;
            hashSet.add(new Dog(x));
        }
        // end time
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println("HashSet: " + duration);

        // start time
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int x = r.nextInt(1000 - 10) + 10;
            treeSet.add(new Dog(x));
        }
        // end time
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("TreeSet: " + duration);

        // start time
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int x = r.nextInt(1000 - 10) + 10;
            linkedSet.add(new Dog(x));
        }
        // end time
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("LinkedHashSet: " + duration);

        // start time
        startTime = System.nanoTime();
        Iterator<Dog> iterator = hashSet.iterator();
        while (iterator.hasNext()) {
            iterator.next();
        }
        // end time
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("HashSetget: " + duration);


        startTime = System.nanoTime();
        iterator = treeSet.iterator();
        while (iterator.hasNext()) {
            iterator.next();
        }
        // end time
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("TreeSetget: " + duration);


        startTime = System.nanoTime();
        iterator = linkedSet.iterator();
        while (iterator.hasNext()) {
            iterator.next();
        }
        // end time
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("LinkedHashSetget: " + duration);


    }
}

结果:

HashSet: 1059056
TreeSet: 736775
LinkedHashSet: 543965
HashSetget: 325696
TreeSetget: 388414
LinkedHashSetget: 169213

数据有在波动，但每次结果却基本都是HashSet的插入时间消耗最久了，LinkedHashSet的查询时间最快。

Set系列集合：Hashset、LinkedHashset、TreeSet --java学习笔记
m0_71386740的博客
03-23 3091
但是，它的每个元素都额外的多了一个双链表的机制记录它前后元素的位置，会有头节点变量和尾结点变量记录第一个和最后一个元素（空间换时间）注意:如果类本身有实现Comparable接口，Treeset集合同时也自带比较器，默认使用集合自带的比较器排序。1、往哈希表添加数据时，会创建一个默认长度16的数组，默认加载因子为0.75，数组名table。JDK 8之前，新元素存入数组，占老元素位置，老元素挂下面。对于自定义类型如Student对象，Treeset默认是无法直接排序的，
java集合之Set篇——HashSet、LinkedHashSet、TreeSet的底层源码解析
2202_75483664的博客
07-21 1250
上一节结束了java集合的List篇java集合之List篇——ArrayList补充和Vector、LinkedList的底层源码-优快云博客本节说一下Set篇——HashSet、LinkedHashSet、TreeSet的底层源码解析实现Comparable接口// 自定义类 Person 实现 Comparable 接口// 构造函数// Getter 方法return age;// 重写 compareTo 方法@Override// 按年龄升序排列。
HashSet,TreeSet和LinkedHashSet的区别
yy6060
07-07 1076
Set接口 Set不允许包含相同的元素，如果试图把两个相同元素加入同一个集合中，add方法返回false。 Set判断两个对象相同不是使用==运算符，而是根据equals方法。也就是说，只要两个对象用equals方法比较返回true，Set就不 会接受这两个对象。 HashSet
Java 容器 & 泛型：三、HashSet，TreeSet 和 LinkedHashSet比较
程序员泥瓦匠
03-28 1087
Writer：BYSocket（泥沙砖瓦浆木匠） 微博：BYSocket 豆瓣：BYSocket 上一篇总结了下ArrayList 、LinkedList和Vector比较，今天泥瓦匠总结下Hash 、LinkedList和Vector比较。其实大家都是Collection，只不过有点各自特性。那就是数据结构的不同表现。   一、Set回顾 一个不包括重复元素（
HashSet、LinkedHashSet、TreeSet的区别
乐在克里特
05-22 311
HashSet：哈希表是通过使用称为散列法的机制来存储信息的，元素并没有以某种特定顺序来存放； LinkedHashSet：以元素插入的顺序来维护集合的链接表，允许以插入的顺序在集合中迭代；   TreeSet：提供一个使用树结构存储Set接口的实现，对象以升序顺序存储，访问和遍历的时间很快。 package com.test; import java.util.HashSe...
HashSet和TreeSet
热门推荐
宁静深远的专栏
11-01 1万+
Set是java中一个不包含重复元素的collection。更正式地说，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。 HashSet与TreeSet都是基于Set接口的实现类。其中TreeSet是Set的子接口SortedSet的实现类。Set接口及其子接口、实现类的结构如
HashSet、LinkedHashSet和TreeSet三者区别与联系
个人技术博客
03-26 1万+
一.HashSet 特点： 1.HashSet中不能有相同的元素，可以有一个Null元素，存入的元素是无序的。 2.HashSet如何保证唯一性？ 1).HashSet底层数据结构是哈希表，哈希表就是存储唯一系列的表，而哈希值是由对象的hashCode()方法生成。 2).确保唯一性的两个方法：hashCode()和equals()方法。 3.添加、删除操作时间复杂度都是O(1)。
HashSet、LinkedHashSet、Treeset 的区别
pig_ning的博客
03-08 461
HashSet、LinkedHashSet、Treeset 的区别
HashSet,LInkedHashSet,TreeSet比较与解读——JAVA
weixin_43698704的博客
01-13 439
目录 HashSet,LInkedHashSet,TreeSet比较与解读 1.基本性质比较 2.判定元素是否相同方法比较 3.常见函数 一、HashSet基本函数运用举例 二、LinkedHashSet 三、TreeSet HashSet,LInkedHashSet,TreeSet比较与解读 1.基本性质比较 HashSet:基于散列函数得集合，无序，可容纳null元素...
HashSet、TreeSet、LinkedHashSet原理及线程安全的使用
hzhahsz的博客
09-05 3488
一、原理 1、HashSet hashset底层其实维护的是一个hashMap实例。 /** * 维护的hashMap实例 */ private transient HashMap<E,Object> map; /** * 无参构造器，创建一个hashMap实例，默认的加载因子是0.75 */ public HashSet() { map = new H...
HashSet、LinkedHashSet、TreeSet区别
mingyuli的博客
04-18 3093
如果你需要一个访问快速的Set，你应该使用HashSet；当你需要一个排序的Set，你应该使用TreeSet；当你需要记录下插入时的顺序时，你应该使用LinedHashSet。 HashSet是采用hash表来实现的。其中的元素没有按顺序排列，add()、remove()以及contains()等方法都是复杂度为O(1)的方法。 TreeSet是采用树结构实现(红黑树算法)。元素是按顺序进行排列，但是add()、remove()以及contains()等方法都是复杂度为O(log (n))的方法。它还提
HashSet 与TreeSet和LinkedHashSet的区别
weixin_30791095的博客
05-08 156
Set接口 Set不允许包含相同的元素，如果试图把两个相同元素加入同一个集合中，add方法返回false。 Set判断两个对象相同不是使用==运算符，而是根据equals方法。也就是说，只要两个对象用equals方法比较返回true，Set就不会接受这两个对象。 HashSet与TreeSet都是基于Set接口的实现类。其中TreeSet是Set的子接口SortedSet的实...
HashSet,TreeSet,LinkedHashSet的比较
a3363642的博客
02-09 185
A Set contains no duplicate elements. That is one of the major reasons to use a set. There are 3 commonly used implementations of Set: HashSet, TreeSet and LinkedHashSet. When and which to use is...
【面试题精讲】比较 HashSet、LinkedHashSet 和 TreeSet 三者的异同
程序员朱永胜
10-17 380
HashSet 使用哈希表作为底层数据结构，不保证元素的顺序；TreeSet 对元素进行排序，默认使用元素的自然顺序（实现 Comparable 接口），或者通过传入 Comparator 进行定制排序。是 HashSet 的子类，它通过链表维护插入顺序，即按照元素插入的顺序进行迭代。LinkedHashSet 继承自 HashSet，底层数据结构也是哈希表，但通过链表维护插入顺序，因此能够按照插入顺序进行迭代。HashSet 使用哈希表作为底层数据结构，具有较快的插入和查询速度，但不保证元素的顺序。
TreeSet, LinkedHashSet and HashSet 的区别
baiyaoliang7445的博客
11-09 155
1. 介绍 TreeSet, LinkedHashSet and HashSet 在java中都是实现Set的数据结构 # TreeSet的主要功能用于排序 #LinkedHashSet的主要功能用于保证FIFO即有序的集合(先进先出) # HashSet只是通用的存储数据的集合 2. 相同点 1）Duplicates elements: 因为三者都实现Set inter...
关于LinkedHashSet和HashSet的对比
weixin_61503139的博客
03-23 147
的
Java中TreeSet与HashSet的对比
Rebirth_Love的博客
08-10 2173
我们知道TreeSet与HashSet都实现了Set，Set的特性就是不允许重复的元素。《thinking in Java》中说set必须定义equals方法确保对象的唯一性，但是经过测试貌似不是这样，不知道是不是java1.5以后版本改变后造成的。下面就从唯一性展开问题，先看例子： 先来看HashSet： package testsortset; import java.util.Hash
HashSet与TreeSet中的等同性比较
千林的博客
11-05 474
set中的等同性比较
Hashset,linkedHashset和treeset的区别
最新发布
07-10
首先，用户的问题是：“我想理解Java集合框架中HashSet、LinkedHashSet和TreeSet的区别 请问Java中HashSet, LinkedHashSet和TreeSet的区别”。所以，我需要清晰地解释这三种Set实现之间的区别。 从系统指令中，我...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值