一、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方法

两个问题：

  1. 两个对象，如果对象的哈希值相同，equals方法一定返回真吗？

    不一定，不同对象的哈希值有一定概率相同

  2. 两个对象，如果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]
*/