Set接口
1)Set接口是Collection的子接口,set接口没有提供额外的方法,完全复用Collection中的方法。
2)Set是无序的,不可重复的,集合中不可包含重复的元素
3)Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals 方法
4)Set接口下的三个实现类:hashSet(set的主要是实现类,开发常用)、liknedHashSet,TreeSet
set实现类之一:HashSet(很重要)
什么是set集合的无序性和不可重复性
set集合是无序的 不像list那样根据添加的顺序进行排序
1) 无序性!=随机性 每次遍历set集合的时候都是和第一次遍历的结果一样
2)无序性:在set集合中无序是指存储是无序的,set在底层采用hash算法来存储
3)不可重复性:当向set中添加进相同元素的时候 后面的不能别添加进set集合中
3.1)说明:要求添加进set中元素所在的类,必须要重写equals()和hashCode()方法,List集合必须要添加类对象时,必须要重写equals方法,进而保证set中元素的不可重复性,其他类型的包装类都已经实现了这两个方法,所以在引入自定义类的对象时写侯一定要重写equals()方法和HashCode()方法。
Set集合中的元素时如何存储的呢?
使用hash算法 在java中重写hashcode()方法 来计算哈希值,这也就是说我们为什么要在引入自定义类对象添加到set集合中需要重写hashcode()方法和equals()方法
此哈希值决定了在元素中的存储位置,若此位置没有对象存储,则或者对象直接存储在该位置上,如果此位置已经有对象,在比较这两个对象equals()方法是否相同,如果相同 最后一个对象不能添加进来
代码演示
package com.ghl.demo;
//Person实体类
public class Person {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Person(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
public Person() {
super();
// TODO Auto-generated constructor stub
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((age == null) ? 0 : age.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age == null) {
if (other.age != null)
return false;
} else if (!age.equals(other.age))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
package com.ghl.demo;
//测试代码
import java.util.HashSet;
import java.util.Set;
import org.junit.Test;
public class HashSetDemo {
@Test
public void hashSetTest() {
Set set=new HashSet();
set.add("123");
set.add("678");
set.add("AA");
set.add(null);//set集合可以存储null
Person p1=new Person("GG", 23);
Person p2=new Person("GG", 23);
set.add(p1);//将实体类对象放入set集合中
set.add(p2);
//现在是没有重写equals和hashcode方法的时情况
System.out.println("p1的hashcode值:"+p1.hashCode());//p1的hashcode值:1598924227
System.out.println("p2的hashcode值:"+p2.hashCode());//p2的hashcode值:1144748369
System.out.println(set);//[AA, null, 123, 678, Person [name=GG, age=23], Person [name=GG, age=23]] 我们可以发现penson对象的属性值都相同,为什么还会被添加进来呢,因为他们的hashcode不同,底层通过计算hashcode来判断是否是同一个元素
//接下来是在Person类中重写 equals和hashcode方法的时情况 再次输入
System.out.println("================");
System.out.println("p1的hashcode值:"+p1.hashCode());//p1的hashcode值:3946
System.out.println("p2的hashcode值:"+p2.hashCode());//p2的hashcode值:3946
System.out.println(set);//[AA, null, 123, 678, Person [name=GG, age=23]]
}
}
HashSet 集合判断两个元素相等的标准:
两个对象通过 hashCode() 方法比较相等,并且两个对象的 equals() 方法返回值也相等
set集合总结
很重要:以上描述就可以保证set集合的无序性和不可重复性,在重复一遍,因为真的很重要:当你使用set集合添加自定义实体类对象的时候,一定要重写实体类对象的hashcode()方法和equals()方法。前面的博客也说过 集合不能存储基本数据类型,如果要存储只能是基本数据类型的包装类,包装类底层已经重写了hashcode()方法和equals()方法。
set实现类之二:LinkedHashSet
1) LinkedHashSet 是 HashSet 的子类
2) LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置,但它同时使用链表维护元素的次序,这使得元素看起来是以插入顺序保存的。
3)LinkedHashSet 不允许集合元素重复。
package com.ghl.demo;
import java.util.LinkedHashSet;
import java.util.Set;
import org.junit.Test;
public class LinkedHashCodeDemo {
@Test
public void LinkedHashCodeTest() {
Set set = new LinkedHashSet();
set.add(new String("AA"));
set.add(456);
set.add(456);
set.add(new Person("刘德华",1001));
set.add(123);
for (Object obj : set) {
//結果:AA,456,Person [name=刘德华, age=1001],123,
System.out.print(obj+",");//遍历的顺序和添加的顺序相同
}
}
}
Set实现类之三:TreeSet
1)TreeSet 可以确保集合元素处于排序状态。
2)TreeSet 两种排序方法:自然排序和定制排序。默认情况下,TreeSet 采用自然排序。
3)向TreeSet总添加的元素必须是同一个类的
4)可以按照添加进集合中的元素指定顺序,向包装类默认排序是从小到大
5)自然排序:TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序排列
如果试图把一个对象添加到 TreeSet 时,则该对象的类必须实现 Comparable 接口。
实现 Comparable 的类必须实现 compareTo(Object obj) 方法,两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。
6)对于 TreeSet 集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过 compareTo(Object obj) 方法比较返回值
当在TreeSet集合中添加不同数据类型的时候会存在转换问题
正确添加数据类型的情况
自然排序
如果试图把一个对象添加到 TreeSet 时,则该对象的类必须实现 Comparable 接口并重写compareTo()方法
代码解释
package com.ghl.demo;
public class Person implements Comparable<Person>{
private String name;
private Integer age;
//按照某个字段来排序,当向treeSet中添加Person类对象的时候,根据此方法确定按照那个属性来排序
@Override
public int compareTo(Person o) {
// 采用年龄排序 从小到大
if(o instanceof Person) {
Person person=(Person)o;
//return -this.age.compareTo(person.age);//从大到小排序
return this.age.compareTo(person.age);//从小到大排序
}
return 0; //为0 代表两个属性相同TreeSet集合,按照年龄来排序
}
setter方法getter方法省略
hashcode()省略
equals() 省略
@Test
public void TreeSetTest2() {
//java.lang.ClassCastException: com.ghl.demo.Person cannot be cast to java.lang.Comparable
//当Person类没有实现Comparable接口,
//并向TreeSet中添加Person对象时会出异常
Set set=new TreeSet();
set.add(new Person("CC",23));
set.add(new Person("MM",21));
set.add(new Person("GG",29));
set.add(new Person("KK",22));
set.add(new Person("AA",28));
}
定制排序
1)要实现定制排序,需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
2)仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。
3)使用定制排序判断两个元素相等的标准是:通过Comparator比较两个元素返回了0。
4)利用int compare(T o1,T o2)方法,比较o1和o2的大小:如果方法返回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表示o1小于o2
代码解释
@Test
public void test3() {
//第一步:.创建了一个Comparator接口的类对象 ,在这里我直接使用的是匿名内部类
Comparator com=new Comparator() {
//向TreeSet中添加Customer类的对象,在compare指明按照Customer的那个属性进行排序
@Override
public int compare(Object o1, Object o2) {
// 写具体的排序规则
if(o1 instanceof Customer && o2 instanceof Customer) {
//按照Customer的id属性来排序
Customer c1=(Customer)o1;
Customer c2=(Customer)o2;
return c1.getId().compareTo(c2.getId());
}
return 0;//0代表两个属性相等
}
};
//第二步:将Comparator对象作为形参传给我的TreeSet对象,同时也指明了按照那种规则排序
Set set=new TreeSet(com);
//第三步:向TreeSet中添加Comparator接口中的compare方法涉及到的类的对象
set.add(new Customer(1001));
set.add(new Customer(1003));
set.add(new Customer(1009));
set.add(new Customer(1005));
set.add(new Customer(1006));
set.add(new Customer(1002));
set.add(new Customer(1004));
set.add(new Customer(10018));
//第四步:遍历
for (Object object : set) {
System.out.println(object);
}
}
输出结果:
Customer [id=1001]
Customer [id=1002]
Customer [id=1003]
Customer [id=1004]
Customer [id=1005]
Customer [id=1006]
Customer [id=1009]
Customer [id=10018]
总结
Set 无序,唯一(不重复)
一、 HashSet
底层数据结构是哈希表。(无序,唯一)
如何来保证元素唯一性?
1.依赖两个方法:hashCode()和equals()
二、LinkedHashSet
底层数据结构是链表和哈希表。
1.由链表保证元素有序
2.由哈希表保证元素唯一
三、 TreeSet
底层数据结构是红黑树。(唯一,有序)
1. 如何保证元素排序的呢?
自然排序
定制排序
2.如何保证元素唯一性的呢?
根据比较的返回值是否是0来决定