前言
Set接口继承Collection接口,实现类有HashSet、LinkedHashSet、TreeSet。
Set接口的核心方法
- boolean add(E e); //新增元素
- boolean remove(Object o); //删除指定元素
- void clear(); //删除所有元素
- boolean contains(Object o); //判断元素是否相同
- lterator iterator(); //迭代器
- int size(); //集合大小
HashSet
hashSet实现了Set接口,底层是以哈希表实现,元素无序且唯一,线程不安全,存取速度快。
HashSet元素无序性
hashSet读取数据必须使用迭代器(Iterator)。Iterator类中有两个核心方法
- hasNext()判断是否有下一个元素
- next()获取下一个元素
public class CollectionDemo {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
Set hashSet = new HashSet();
hashSet.add("hash -- 1");
hashSet.add("hash -- 2");
hashSet.add("hash -- 3");
hashSet.add("hash -- 4");
//使用迭代器输入数组元素
Iterator iterator = hashSet.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
//输出结果
//hash – 1
//hash – 4
//hash – 3
//hash – 2
通过结果可以看出,元素新增和查询出来的顺序是不一样的,也就是所说的hashSet的无序。
HashSet元素唯一性
当hashSet中插入重复元素时,此元素只会插入一次,重复的会被忽略。那么hashSet是如何判断元素是否重复呢,它首先会通过hash算法生成一个int类型的hashCode值,将此hashCode值和已存在的所有元素的hashCode值进行比较,如果不存在,那么就绝不是重复值,然后存储此hashCode值所对应的元素对象。如果hashCode值相等,那么它会调用equals方法判断两个元素的值是否相同,如果相同那么就是重复元素,就会被忽略,如果不同那就是不同的两个元素,直接存储。此时就需要解决hashCode地址冲突问题。它会新建一个链表,在同一个hashCode值后面存储不同的元素对象,这样就保证了元素的唯一性。
示例代码
public class Person {
private String name;
private int age;
Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
System.out.println("hashCode --- 属性名:" + this.name + "----- hashCode值:"+this.name.hashCode());
return this.name.hashCode() + age * 37;
}
@Override
public boolean equals(Object obj) {
System.out.println(this + "---equals---" + obj);
if (obj instanceof Person) {
Person p = (Person) obj;
System.out.println("equals --- " + (this.name.equals(p.name) && this.age == p.age));
return this.name.equals(p.name) && this.age == p.age;
} else {
return false;
}
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class HashSetDemo {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
Set hashSet = new HashSet();
hashSet.add(new Person("jack", 18));
hashSet.add(new Person("apple", 18));
hashSet.add(new Person("admin", 18));
hashSet.add(new Person("admin", 18)); //插入重复值
//使用迭代器输入数组元素
Iterator iterator = hashSet.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
需要注意的是:所有要存入hashSet中的对象必须在类中重写equals方法,以保证元素唯一性。
LinkedHashSet
LinkedHashSet底层采用了链表和哈希表共同实现,链表保证的元素是有序的,哈希表保证了元素的唯一性,线程不安全,效率高。
TreeSet
TreeSet基于TreeMpa实现,TreeMap本质就是红黑树。所以TreeSet其实于是基于红黑树的。TreeSet元素有序且唯一,线程不安全,存取效率低于HashSet。
TreeSet存放普通属性
public class TreeSetDemo {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
treeSet.add("a");
treeSet.add("s");
treeSet.add("1");
treeSet.add("f");
Iterator iterator = treeSet.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
//输出结果
// 1 a s f
可以看到上面存储的都是string类型,那么现在把1换成int类型
public class TreeSetDemo {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
treeSet.add("a");
treeSet.add("s");
treeSet.add(1);
treeSet.add("f");
Iterator iterator = treeSet.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
由于存在两种类型,就会抛出java.lang.ClassCastException异常。而hashSet不会。
TreeSet元素排序规则
public class HashSetDemo {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
treeSet.add(new Person("admin", 18));
treeSet.add(new Person("apple", 18));
treeSet.add(new Person("jack", 18));
Iterator iterator = treeSet.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
运行以上代码会抛出java.lang.ClassCastException异常,原因是我们需要告诉TreeSet如何进行排序,如果不指定,就会报错此异常。
TreeSet排序规则有两种:
元素自身排序
实体类实现Comparable接口,重写compareTo方法。通过在compareTo中自定义比较,例如先比较年龄,若年龄相同再比较姓名。
public class Person implements Comparable{
private String name;
private int age;
Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
//重写compareTo方法保证TreeSet元素的有序性
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
return -1;
}
}
public class TreeSetDemo {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
treeSet.add(new Person("admin", 18));
treeSet.add(new Person("apple", 19));
treeSet.add(new Person("jack", 20));
Iterator iterator = treeSet.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
为什么返回0,只会存第一个元素,返回-1会倒序存储,返回1会怎么存就怎么取呢?原因在于TreeSet底层其实是一个二叉树机构,且每插入一个新元素(第一个除外)都会调用compareTo()
方法去和上一个插入的元素作比较,并按二叉树的结构进行排列。
- 如果将
compareTo()
返回值写死为0,元素值每次比较,都认为是相同的元素,这时就不再向TreeSet中插入除第一个外的新元素。所以TreeSet中就只存在插入的第一个元素。 - 如果将
compareTo()
返回值写死为1,元素值每次比较,都认为新插入的元素比上一个元素大,于是二叉树存储时,会存在根的右侧,读取时就是正序排列的。 - 如果将
compareTo()
返回值写死为-1,元素值每次比较,都认为新插入的元素比上一个元素小,于是二叉树存储时,会存在根的左侧,读取时就是倒序序排列的。
容器自身排序
当元素自身不具备比较性,或者元素自身具备的比较性不是所需的。那么这时只能让容器自身具备。定义一个类实现Comparator 接口,覆盖compare方法。并将该接口的子类对象作为参数传递给TreeSet集合的构造函数。当Comparable比较方式,及Comparator比较方式同时存在,以Comparator比较方式为主。
public class Person {
private String name;
private int age;
Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class MyComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
// TODO Auto-generated method stub
Person p1 = (Person) o1;
Person p2 = (Person) o2;
if(p1.getAge() > p2.getAge()) {
return 1;
}
if(p1.getAge() < p2.getAge()) {
return -1;
}
return p1.getName().compareTo(p2.getName());
}
}
public class TreeSetDemo {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
TreeSet treeSet = new TreeSet(new MyComparator());
treeSet.add(new Person("admin", 19));
treeSet.add(new Person("apple", 18));
treeSet.add(new Person("jack", 20));
Iterator iterator = treeSet.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
总结:其实两种方式差不多。
TreeSet元素唯一性
当排序时,return 0 就表示元素重复,就不会再存储到集合里。
总结
HashSet:元素唯一且无序,线程不安全,存取速度快。
TreeSet:元素唯一且有序,线程不安全,存取速度低于HashSet。
LinkedHashSet:元素唯一且有序,线程不安全。
文尾
文章均为学习阶段记录笔记,若有不妥请留言指正。谢谢!