HashSet，TreeSet 和 LinkedHashSet比较

一、Set回顾

一个不包括重复元素（包括可变对象）的Collection，是一种无序的集合。Set不包含满
a.equals(b) 的元素对a和b，并且最多有一个null。

泥瓦匠的记忆宫殿：

1、不允许包含相同元素

2、判断对象是否相同，根据equals方法

二、HashSet

一个按着Hash算法来存储集合中的元素，其元素值可以是NULL。它不能保证元素的排列顺序。同样，HashSet是不同步的，如果需要多线程访问它的话，可以用 Collections.synchronizedSet 方法来包装它：

1	`Set s = Collections.synchronizedSet(new` `HashSet(...));`

同上一节一样，用迭代器的时候，也要注意并发修改异常ConcurrentModificationException。

要注意的地方是，HashSet集合判断两个元素相等不单单是equals方法，并且必须hashCode()方法返回值也要相等。看下面的例子：

import
java.util.HashSet;

class
EuqalsObj

{

public
boolean equals(Object obj)

{

return
true;

}

class
HashCodeObj

{

public
int hashCode()

{

return
1;

}

class
HashSetObj

{

public
int hashCode()

{

return
2;

}

public
boolean equals(Object obj)

{

return
true;

}

public
class HashSetTest

{

public
static void main(String[] args)

{

HashSet objs =new
HashSet();

objs.add(new
EuqalsObj());

objs.add(new
HashCodeObj());

objs.add(new
HashSetObj());

System.out.println("HashSet Elements:");

System.out.print("\t"
+ objs +"\n");

}

Run 一下，控制台如下输出：

1 2	`HashSet Elements:` `[[email protected]1, [email protected]1, [email protected]2, [email protected], [email protected]]`

泥瓦匠根据结果，一一到来。首先，排列顺序不定。

HashSetObj 类满足我们刚刚的要求，所以集合中只有一个且它的HashCode值为2。

HashCodeObj 类虽然它们HashCode值为1，但是他们不相等。（其实当HashCode值一样，这个存储位置会采用链式结构保存两个HashCodeObj对象。）

同样,EqualsObj 类他们相等，但是他们HashCode值不等，分别为1471cb25、3acff49f。

因此，用HashSet添加可变对象，要注意当对象有可能修改后和其他对象矛盾，这样我们无法从HashSet找到准确我们需要的对象。

三、LinkedHashList

HashSet的子类，也同样有HashCode值来决定元素位置。但是它使用链表维护元素的次序。记住两个字：有序。

有序的妙用，复制。比如泥瓦匠实现一个HashSet无序添加，然后复制一个一样次序的HashSet来。代码如下：

package
com.sedion.bysocket.collection;

import
java.util.HashSet;

import
java.util.LinkedHashSet;

import
java.util.Set;

public
class LinkedHashListTest

{

public
static void main(String[] args)

{

/* 复制HashSet */

Set h1 =new
HashSet<String>();

h1.add("List");

h1.add("Queue");

h1.add("Set");

h1.add("Map");

System.out.println("HashSet Elements:");

System.out.print("\t"
+ h1 +"\n");

Set h2 = copy(h1);

System.out.println("HashSet Elements After Copy:");

System.out.print("\t"
+ h2 +"\n");

}

@SuppressWarnings({"rawtypes","unchecked"
})

public
static Set copy(Set set)

{

Set setCopy =new
LinkedHashSet(set);

return
setCopy;

}

Run 一下，控制台输出：

HashSet Elements:

[Map, Queue, Set, List]

HashSet Elements After Copy:

[Map, Queue, Set, List]

可见，每个数据结构都有它存在的理由。

四、TreeSet

TreeSet使用树结构实现（红黑树），集合中的元素进行排序，但是添加、删除和包含的算法复杂度为O（log（n））。

举个例子吧，首先我们定义一个Bird类。（鸟是泥瓦匠最喜欢的动物）

class
Bird

{

int
size;

public
Bird(int
s)

{

size = s;

}

public
String toString()

{

return
size +"";

}

然后用TreeSet添加Bird类。

public
class TreeSetTest

{

public
static void main(String[] args)

{

TreeSet<Bird> bSet =new
TreeSet<Bird>();

bSet.add(new
Bird(1));

bSet.add(new
Bird(3));

bSet.add(new
Bird(2));

Iterator<Bird> iter = bSet.iterator();

while
(iter.hasNext())

{

Bird bird = (Bird) iter.next();

System.out.println(bird);

}

Run一下,控制台输出如下：

Exceptionin
thread"main"
java.lang.ClassCastException: Bird cannot be cast to java.lang.Comparable

at java.util.TreeMap.compare(Unknown Source)

at java.util.TreeMap.put(Unknown Source)

at java.util.TreeSet.add(Unknown Source)

at com.sedion.bysocket.collection.TreeSetTest.main(TreeSetTest.java:29)

答案很明显，TreeSet是排序的。所以Bird需要实现Comparable此接口。

java.lang.Comparable此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

修改Bird如下：

class
Birdimplements
Comparable<Bird>

{

int
size;

public
Bird(int
s)

{

size = s;

}

public
String toString()

{

return
size +"号鸟";

}

@Override

public
int compareTo(Bird o)

{

return
size - o.size;

}

再次Run一下：

1号鸟

2号鸟

3号鸟

五、性能测试比较

针对上面三种Set集合，我们对它们的Add方法进行性能测试：

import
java.util.HashSet;

import
java.util.LinkedHashSet;

import
java.util.Random;

import
java.util.TreeSet;

class
Birdimplements
Comparable<Bird>

{

int
size;

public
Bird(int
s)

{

size = s;

}

public
String toString()

{

return
size +"号鸟";

}

@Override

public
int compareTo(Bird o)

{

return
size - o.size;

}

public
class Set

{

public
static void main(String[] args)

{

Random r =new
Random();

HashSet<Bird> hashSet =new
HashSet<Bird>();

TreeSet<Bird> treeSet =new
TreeSet<Bird>();

LinkedHashSet<Bird> linkedSet =new
LinkedHashSet<Bird>();

// start time

long
startTime = System.nanoTime();

for
(int
i =0; i <1000; i++) {

int
x = r.nextInt(1000
-10) +10;

hashSet.add(new
Bird(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
Bird(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
Bird(x));

}

// end time

endTime = System.nanoTime();

duration = endTime - startTime;

System.out.println("LinkedHashSet: " + duration);

}

Run一下，可以在控制台中看出：

HashSet:2610998

TreeSet:3195378

LinkedHashSet:2673782

可见，TreeSet因为需要进行比较，所以性能比较差。

六、总结

HashSet：equlas hashcode

LinkedHashSet：链式结构

TreeSet：比较，Comparable接口，性能较差

时间： 2024-11-08 17:51:35

HashSet，TreeSet 和 LinkedHashSet比较的相关文章

HashSet,TreeSet和LinkedHashSet的区别

Set接口Set不允许包含相同的元素,如果试图把两个相同元素加入同一个集合中,add方法返回false.Set判断两个对象相同不是使用==运算符,而是根据equals方法.也就是说,只要两个对象用equals方法比较返回true,Set就不会接受这两个对象. HashSet: 顺序是不确定性的. LinkedHashSet:按照输入的顺序进行输出. TreeSet:SortedSet 接口的唯一实现类,保证集合元素处于排序状态. 1.HashSetHashSet有以下特点不能保证元素的

Set下面HashSet,TreeSet和LinkedHashSet的区别

Set接口Set不允许包含相同的元素,如果试图把两个相同元素加入同一个集合中,add方法返回false.Set判断两个对象相同不是使用==运算符,而是根据equals方法.也就是说,只要两个对象用equals方法比较返回true,Set就不会接受这两个对象. HashSetHashSet有以下特点? 不能保证元素的排列顺序,顺序有可能发生变化? 不是同步的? 集合元素可以是null,但只能放入一个null当向HashSet结合中存入一个元素时,HashSet会调用该对象的hashCode()方

HashSet,TreeSet和LinkedHashSet

Set接口 Set不允许包含相同的元素,如果试图把两个相同元素加入同一个集合中,add方法返回false. Set判断两个对象相同不是使用==运算符,而是根据equals方法.也就是说,只要两个对象用equals方法比较返回true,Set就不会接受这两个对象. HashSetHashSet有以下特点不能保证元素的排列顺序,顺序有可能发生变化不是同步的集合元素可以是null,但只能放入一个null 当向HashSet结合中存入一个元素时,HashSet会调用该对象的hashCode()方法

HashSet vs. TreeSet vs. LinkedHashSet

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 an important question. In brief, if you need a fast se

Leetcode: LFU Cache && Summary of various Sets: HashSet, TreeSet, LinkedHashSet

Design and implement a data structure for Least Frequently Used (LFU) cache. It should support the following operations: get and set. get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1. s

【Simple Java】HashSet vs TreeSet vs LinkedHashSet

使用Set集合的主要原因是因为Set集合里面没有重复的元素.Set集合有三个常见的实现类:HashSet,TreeSet,LinkedHashSet.什么时候,选择哪一个使用非常重要.简单的说,如果你关注性能,应该使用HashSet:如果你需要一个有序的Set集合,应该使用TreeSet:如果你需要一个Set集合保存了原始的元素插入顺序,应该使用LinkedHashSet. Set接口 Set接口继承Collection接口.Set集合不允许里面存在重复元素,每个元素都必须是唯一的.你只需要往S

Set集合——HashSet、TreeSet、LinkedHashSet（2015年07月06日）

一.Set集合不同于List的是: Set不允许重复 Set是无序集合 Set没有下标索引,所以对Set的遍历要通过迭代器Iterator 二.HashSet 1.HashSet由一个哈希表支持,内部实际上是一个HashMap,HashMap的键即为HashSet的值,HashMap的值是一个固定常量,这也就是HashSet中不允许重复的值的原因,因为HashMap的键不允许重复. HashSet允许null值,并且只允许一个null值存在,它也是非线程安全的,不过它提供构造线程安全的HashS

Java 容器 & 泛型：三、HashSet，TreeSet 和 LinkedHashSet比较

Writer:BYSocket(泥沙砖瓦浆木匠) 微博:BYSocket 豆瓣:BYSocket 上一篇总结了下ArrayList .LinkedList和Vector比较,今天泥瓦匠总结下Hash .LinkedList和Vector比较.其实大家都是Collection,只不过有点各自特性.那就是数据结构的不同表现. 一.Set回顾一个不包括重复元素(包括可变对象)的Collection,是一种无序的集合.Set不包含满 a.equals(b) 的元素对a和b,并且最多有一个null.泥瓦

（转载）Java 容器 & 泛型：三、HashSet，TreeSet 和 LinkedHashSet比较

上一篇总结了下ArrayList .LinkedList和Vector比较,今天泥瓦匠总结下Hash .LinkedList和Vector比较.其实大家都是Collection,只不过有点各自特性.那就是数据结构的不同表现. 一.Set回顾一个不包括重复元素(包括可变对象)的Collection,是一种无序的集合.Set不包含满 a.equals(b) 的元素对a和b,并且最多有一个null.泥瓦匠的记忆宫殿:1.不允许包含相同元素 2.判断对象是否相同,根据equals方法二.HashSe