一、Set
(一)set概述(摘自API文档)
public interface Set<E>
extends Collection<E>
set是一个不包含重复元素的 collection。更确切地讲,set 不包含满足 e1.equals(e2)
的元素对 e1
和 e2
,并且最多包含一个 null 元素。正如其名称所暗示的,此接口模仿了数学上的 set 抽象。
在所有构造方法以及 add、equals 和 hashCode 方法的协定上,Set 接口还加入了其他规定,这些规定超出了从Collection 接口所继承的内容。出于方便考虑,它还包括了其他继承方法的声明(这些声明的规范已经专门针对Set 接口进行了修改,但是没有包含任何其他的规定)。
对这些构造方法的其他规定是(不要奇怪),所有构造方法必须创建一个不包含重复元素的 set(正如上面所定义的)。
注:如果将可变对象用作 set 元素,那么必须极其小心。如果对象是 set 中某个元素,以一种影响 equals 比较的方式改变对象的值,那么 set 的行为就是不确定的。此项禁止的一个特殊情况是不允许某个 set 包含其自身作为元素。
(二)set集合通用方法
boolean | ||
boolean | addAll(Collection<? extends E> c) | |
void | clear() | |
boolean | ||
boolean | containsAll(Collection<?> c) | |
boolean | ||
int | hashCode() | |
boolean | isEmpty() | |
iterator() | ||
boolean | ||
boolean | removeAll(Collection<?> c) | |
boolean | retainAll(Collection<?> c) | |
int | size() | |
Object[] | toArray() | |
| toArray(T[] a) |
二、 HashSet:
(1)概述
此类实现 Set 接口,由哈希表(实际上是一个 HashMap 实例)支持。它不保证 set 的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用 null 元素。
注意,此实现不是同步的。如果多个线程同时访问一个哈希 set,而其中至少一个线程修改了该 set,那么它必须 保持外部同步。这通常是通过对自然封装该 set 的对象执行同步操作来完成的。如果不存在这样的对象,则应该使用 Collections.synchronizedSet
方法来“包装” set。最好在创建时完成这一操作,以防止对该 set 进行意外的不同步访问:
Set s = Collections.synchronizedSet(new HashSet(...));
|--Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复。、
|--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
(2)HashSet是如何保证元素唯一性的呢?
是通过元素的两个方法,hashCode和equals来完成。
如果元素的HashCode值相同,才会判断equals是否为true。
如果元素的hashcode值不同,不会调用equals。
注意:对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashcode和equals方法。
Set集合的功能和Collection是一致的。
(3)自练
importjava.util.*;
/*
用HashSet存储自定义对象
*/
class HashSetDemo
{
public static void main(String[] args)
{
Set<Person> hs= newHashSet<Person>();
hs.add(newPerson("zhangsan",20));
hs.add(newPerson("zhangsan3",23));
hs.add(newPerson("zhangsan2",22));
hs.add(newPerson("zhangsan6",26));
hs.add(newPerson("zhangsan2",22));//重复元素无法放入集合内
sop(hs);
Person p1 = newPerson("zhangsan6",26);
sop(hs.contains(p1));//判断对象是否存在
sop(hs.remove(p1));//删除对象
sop(hs);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public boolean equals(Object obj)
{
if (!(obj instanceof Person))
{
throw newClassCastException("不是Person类");
}
Person p = (Person)obj;
return this.name.equals(p.name)&& this.age == age;
}
public int hashCode()
{
returnthis.name.hashCode()+age*39;
}
public String toString()
{
returnthis.name+"_"+this.age;
}
}
三、 TreeSet
(1) 概述
基于 TreeMap
的 NavigableSet
实现。使用元素的自然顺序对元素进行排序,或者根据创建 set 时提供的Comparator
进行排序,具体取决于使用的构造方法。
此实现为基本操作(add
、remove
和 contains
)提供受保证的 log(n) 时间开销。
注意,如果要正确实现 Set
接口,则 set 维护的顺序(无论是否提供了显式比较器)必须与 equals 一致。(关于与 equals 一致 的精确定义,请参阅 Comparable
或 Comparator
。)这是因为 Set
接口是按照 equals
操作定义的,但 TreeSet
实例使用它的 compareTo
(或 compare
)方法对所有元素进行比较,因此从 set 的观点来看,此方法认为相等的两个元素就是相等的。即使 set 的顺序与 equals 不一致,其行为也是 定义良好的;它只是违背了 Set
接口的常规协定。
注意,此实现不是同步的。
|--TreeSet:可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据:compareTo方法return 0.
(2)TreeSet排序
TreeSet排序的第一种方式:让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。也种方式也成为元素的自然顺序,或者叫做默认顺序。
TreeSet的第二种排序方式:当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时,就有了比较方式。
(3)构造方法
构造方法摘要 | |
TreeSet() |
|
TreeSet(Collection<? extends E> c) |
|
TreeSet(Comparator<? super E> comparator) |
|
TreeSet(SortedSet<E> s) |
|
(4)自练
import java.util.*;
/*
需求:在TreeSet中存储学生类的自定义对象
学生类中有姓名和年龄,首先按照姓名排序,若姓名相同,则按照年龄排序
*/
class TreeSetDemo
{
publicstatic void main(String[] args)
{
Set<Student>ts = new TreeSet<Student>();
ts.add(newStudent("Dabao",28));
ts.add(newStudent("Sibao",25));
ts.add(newStudent("Sanbao",26));
ts.add(newStudent("Sibao",24));
ts.add(newStudent("Erbao",27));
Iterator<Student>it = ts.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
}
class Student implements Comparable//此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序
{
privateString name;
privateint age;
Student(Stringname,int age)
{
this.name= name;
this.age= age;
}
publicString getName()
{
returnthis.name;
}
public intgetAge()
{
returnthis.age;
}
public intcompareTo(Object obj)//compareTo 方法被称为它的自然比较方法
{
if(!(obj instanceof Student))//比较之前要先判断类型是否匹配
{
thrownew ClassCastException("不是学生类");
}
Studentstu = (Student)obj;
intnum = (this.name).compareTo(stu.getName());//将比较结果存入变量中待返回
if(num==0) //如果姓名相同,则判断年龄
{
returnstu.getAge()-this.age;
}
returnnum;
}
publicString toString()
{
returnname+"_"+age;
}
}
四、比较器Comparator
强行对某个对象 collection 进行整体排序 的比较函数。可以将Comparator 传递给 sort 方法(如Collections.sort
或 Arrays.sort
),从而允许在排序顺序上实现精确控制。还可以使用Comparator 来控制某些数据结构(如有序 set
或有序映射
)的顺序,或者为那些没有自然顺序
的对象 collection 提供排序。
自练
import java.util.*;
/*
需求:使用比较器对TreeSet进行排序
*/
class CompDemo
{
publicstatic void main(String[] args)
{
Set<Student>ts = new TreeSet<Student>();
ts.add(newStudent("Dabao",28));
ts.add(newStudent("Sibao",25));
ts.add(newStudent("Sanbao",26));
ts.add(newStudent("Sibao",24));
ts.add(newStudent("Erbao",27));
Iterator<Student>it = ts.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
}
class MyComparator implements Comparator //比较器接口,实现该接口需要重写compare()方法
{
publicint compare(Object o1, Object o2)//这次按照年龄排序
{
if(!(o1 instanceof Student && o2 instanceof Student))
{
thrownew ClassCastException("不是学生类");
}
Students1 = (Student)o1;
Students2 = (Student)o2;
intnum = ((Integer)s1.getAge()).compareTo((Integer)s2.getAge());
if(num == 0)
{
returns1.getName().compareTo(s2.getName());
}
returnnum;
}
}
/*
继续用上个例子中的学生类,当类既有自然顺序,又有比较器时,使用比较器排序
*/
class Student implements Comparable//此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序
{
privateString name;
privateint age;
Student(Stringname,int age)
{
this.name= name;
this.age= age;
}
publicString getName()
{
returnthis.name;
}
publicint getAge()
{
returnthis.age;
}
publicint compareTo(Object obj)//compareTo 方法被称为它的自然比较方法
{
if(!(obj instanceof Student))//比较之前要先判断类型是否匹配
{
thrownew ClassCastException("不是学生类");
}
Studentstu = (Student)obj;
intnum = (this.name).compareTo(stu.getName());//将比较结果存入变量中待返回
if(num==0) //如果姓名相同,则判断年龄
{
returnstu.getAge()-this.age;
}
returnnum;
}
publicString toString()
{
returnname+"_"+age;
}
}