一、Set集合特性
- Set集合不允许存储重复元素
- 无序集合，存储的顺序和取出顺序不同
- 没有下标
- 使用传统的for遍历，可以用增强for，迭代器
- Set接口方法，和父接口Collection的方法，完全一致
二、接口特点和存取
直接上demo，用HashSet实例化
/*
* Set集合的练习，包括特点接存取
*/
import java.util.*;
public class SetDemo {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("agk");
set.add("ghkjrtykh");
set.add("c");
set.add("yuiyd");
for (String s : set) {
System.out.println(s);
}
System.out.println("---------------------");
// 迭代器遍历
Iterator<String> it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
三、HashSet集合
HashSet哈希表，无序，允许null，线程不安全，查询速度快，不重复。
那么HashSet如何保证对象唯一性的呢？HashSet底层实现原理是哈希表，存储的是对象的哈希值。集合的内部，存储的就是对象的哈希值，成为哈希表，是一个巨大的容器，会为每一个哈希值开辟独立存储空间。
HashSet集合的存储对象过程：存储对象的时候，调用该对象的hashCode方法，取得哈希值，自己的容器中是否有了这个哈希值？如果没有，直接将哈希值存储自己的容器。如果有了，调用对象的equals方法，和已经存储在的对象，进行比较，结果是真，HashSet判断为同一对象，不存。结果是假，将后进来的对象，挂靠在先进来的对象之后。
结论：HashSet集合保证对象的唯一性，依据对象的hashCode和equals方法，要求存储到哈希表中的对象，必须重写hashCode和equals方法
两个问题：
-
两个对象，如果对象的哈希值相同，equals方法一定返回真吗？
不一定，不同对象的哈希值有一定概率相同
-
两个对象，如果equals返回真，hashCode的值一定相同吗？
一定，两种情况。地址相同，指向同一个对象，这个哈希值一定相同。内容相容，地址不同，此时哈希值也一定相同。
demo：
package SetDemo;
/*
* HashSet的特点
*/
import java.util.*;
public class SetDemo1 {
public static void main(String[] args) {
HashSet<Person> set = new HashSet<Person>();
set.add(new Person("a",16));
set.add(new Person("a",11));
set.add(new Person("b",10));
set.add(new Person("c",15));
set.add(new Person("c",15));
//Person重写了hashCode方法和equals方法
//不同的对象，hash值有可能相同，所以又要调用equals方法进行比较，相同则抛弃，否则挂在之前对象的后面
for(Person p : set){
System.out.println(p);
}
HashSet<Integer> set2 = new HashSet<Integer>();
set2.add(new Integer(1231));
set2.add(new Integer(1231));
System.out.println(set2);
}
}
//================================分割线=========================================================
//附person代码，注意两个类不在同一个java文件内
package SetDemo;
/*
* 一个自定义Person对象
*/
public class Person {
private String name;
private int age;
Person() {
}
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;
}
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null)
return false;
if (o instanceof Person) {
Person p = (Person) o;
return this.name.equals(p.name) && this.age == p.age;
}
return false;
}
public String toString() {
return this.name + "..." + this.age;
}
public int hashCode() {
return name.hashCode() + age * 2;
}
}
四、LinkedHashSet有序集合
具有迭代顺序的Set集合，是HashSet的子类，开始版本是JDK1.4。线程不安全的，效率快，基于链表的哈希表。
demo：
/*
* 有序的Set集合
* 保证存储和取出的顺序一致
*/
import java.util.*;
public class LinkedHashSetDemo {
public static void main(String[] args) {
LinkedHashSet<String> lhs = new LinkedHashSet<String>();
lhs.add("abc");
lhs.add("tgf");
lhs.add("weds");
lhs.add("gvfcd");
lhs.add("qwds");
for(String s : lhs){
System.out.println(s);
}
}
}
/*输出如下：
abc
tgf
weds
gvfcd
qwds
*/
五、TreeSet集合
对存储的对象，按照自然顺序进行排序，同时也是线程不安全。
存储对象到TreeSet集合中，出现了类型转换异常，不能被转成java.lang.Comparable类型问题。Comparable是一个接口，如果类实现了此接口，定义的类具有了自然顺序。TreeSet排序必须按照对象的自然顺序。
此时要是存储自定义对象时，就需要实现接口Comparable，demo如下：
package SetDemo;
import java.util.*;
/*
* TreeSet存储自定义对象Person
*/
public class TreeSetDemo {
public static void main(String[] args) {
//实现存储自定义对象
TreeSet<Person> tp = new TreeSet<Person>();
tp.add(new Person("liuchao",12));
tp.add(new Person("liuyifei",12));
tp.add(new Person("linxu",12));
tp.add(new Person("liuqinfei",12));
tp.add(new Person("liuqinfei",13));
System.out.println(tp);
}
}
/*
程序的输出结果为：[linxu...12, liuchao...12, liuqinfei...12, liuqinfei...13, liuyifei...12]
*/
//附Person类新添加的代码
package SetDemo;
/*
* 一个自定义Person对象
*/
public class Person implements Comparable<Person>{
...
//比较的方法是：先按名字的自然顺序排序，相同再按年轻排序，都是小的在左，大的在右
public int compareTo(Person p){
int num = this.name.compareTo(p.name);
if(num == 0)
return this.age-p.age;
return num;
}
...
}
1. 比较器-comparator
上述的Person类实现了接口Comparable，重写了compareTo方法。但是此时有一个局限性，那就是如果想换一种排序的方法就会比较麻烦，需要重写compareTo方法。其实不然，此时其实还有一个接口叫comparator，在初始化TreeSet时只要将比较器当作参数传入即可使用新的排序方法。
下面举例实现，首先实现一个比较器（继续以之前的Person类为例）
package SetDemo;
import java.util.Comparator;
/*
* 构建Person的比较器，优先按照年龄排序，年龄相同则使用名字排序
*/
public class PersonComparator implements Comparator<Person> {
public int compare(Person p1, Person p2){
int num = p1.getAge()-p2.getAge();
return num == 0 ? p1.getName().compareTo(p2.getName()) : num;
}
}
然后更改下之前的代码：
package SetDemo;
import java.util.*;
/*
* TreeSet存储自定义对象Person
*/
public class TreeSetDemo {
public static void main(String[] args) {
//同时，也可以自定义比较器，传入TreeSet()方法中即可使用传入的比较器比较，而放弃原来的默认方法compareTo
TreeSet<Person> tp = new TreeSet<Person>(new PersonComparator());
tp.add(new Person("liuchao",12));
tp.add(new Person("liuyifei",19));
tp.add(new Person("linxu",12));
tp.add(new Person("liuqinfei",12));
tp.add(new Person("liuqinfei",0));
System.out.println(tp);
}
}
/*程序输出如下，可以看到已经优先按照年龄排序了
[liuqinfei...0, linxu...12, liuchao...12, liuqinfei...12, liuyifei...19]
*/
