黑马程序员-集合类Collection之Set接口

-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------

一、定义：

Set具有与Collection接口完全一样的接口，因此没有任何额外的功能；其实Set就是Collection，只是行为不同。

 

二、特点：

无序的(存入和取出的顺序不一定一致)，无索引，元素不可重复。
Set接口中的方法和Collection中方法一致的。Set接口取出方式只有一种，迭代器。

三、子类：

|--HashSet：底层数据结构是哈希表，线程是不同步的。无序，高效；
       |--LinkedHashSet：有序，是hashset的子类。
|--TreeSet：底层的数据结构是二叉树。对Set集合中的元素进行指定顺序的排序，默认是自然顺序。不同步。

四、HashSet

1、保证性元素唯一的原理：

是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会继续调用equals方法来判断两元素是否相同：如果为true，那么视为相同元素，不存；如果为false，那么存储。
如果元素的HashCode值不同，不会调用equals，从而提高对象比较的速度。
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。往HashSet里面存的自定义元素一定要复写hashCode和equals方法，以保证元素的唯一性！

2、哈希表的原理：

（1）对对象元素中的关键字(对象中的特有数据)，进行哈希算法的运算，并得出一个具体的算法值，这个值称为哈希值。
（2）哈希值就是这个元素的位置。要找元素时，先将该元素通过哈希算法算出哈希值，再通过哈希值到哈希表中去查找。
（3）如果哈希值出现冲突，再次判断这个关键字对应的对象是否相同。如果对象相同，就不存储，因为元素重复。如果对象不同，就存储，在原来对象的哈希值基础 +1顺延。
（4）存储哈希值的结构，我们称为哈希表。
（5）既然哈希表是根据哈希值存储的，为了提高效率，最好保证对象的关键字是唯一的。这样可以尽量少的判断关键字对应的对象是否相同，提高了哈希表的操作效率。

3、对比：

对于ArrayList集合，判断元素是否存在，或者删元素，底层依据都是equals方法。
对于HashSet集合，判断元素是否存在，或者删除元素，底层依据的是hashCode方法和equals方法。

 

4、代码示例：

/*
往hashSet集合中存入自定义对象
姓名和年龄相同为同一个人，重复元素。
 */
import java.util.*;

/*
 往哈希表中的存储的自定义对象，必须覆盖hashCode方法，和equals方法。如果不知道这个对象到底存储到哪个容器中去，
 那就将hashCode，equals，toString全都覆盖，创建对象自身的判断相同的依据。
 */
class Person {

	// 声明属性
	private String name;
	private int age;

	// 构造方法
	Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	// getter,setter方法
	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;
	}

	// 覆盖Object类中的hashCode方法。建立Person对象自己特有的哈希值算法。
	public int hashCode() {
		System.out.println(this.name + "....hashCode");
		final int NUMBER = 37;
		return name.hashCode() + age * NUMBER;// *37是为了尽量保证哈希值唯一。
	}

	// 覆盖Object类中的equals方法，建立Person对象。判断是否相同的依据: 根据Person自身的特点来判断。
	public boolean equals(Object obj) {

		if (!(obj instanceof Person))
			return false;

		Person p = (Person) obj;
		System.out.println(this.name + "...equals.." + p.name);

		return this.name.equals(p.name) && this.age == p.age;
	}

}

class HashSetTest {
	public static void sop(Object obj) {
		System.out.println(obj);
	}

	public static void main(String[] args) {
		HashSet<Person> hs = new HashSet<Person>();

		// 往哈希表中存储自定义对象。
		hs.add(new Person("a1", 11));
		hs.add(new Person("a2", 12));
		hs.add(new Person("a3", 13));
		hs.add(new Person("a2", 12));
		hs.add(new Person("a4", 14));

		Iterator<Person> it = hs.iterator();

		while (it.hasNext()) {
			Person p = (Person) it.next();
			sop(p.getName() + "::" + p.getAge());
		}
	}
}

/*output:
a1....hashCode
a2....hashCode
a3....hashCode
a2....hashCode
a2...equals..a2
a4....hashCode
a1::11
a3::13
a2::12
a4::14
*/

 

五、TreeSet：

 

1、特点：

底层数据结构式二叉树。可以用于对Set集合进行元素的指定顺序排序。排序需要依据元素自身具备的比较性。线程不同步。

 

2、保证元素唯一性的方式：

参考Comparable接口的compareTo方法的返回值。也就是参考比较方法的结果是否为0，如果return 0，视为两个对象重复，不存。

3、TreeSet集合排序有两种方式，Comparable和Comparator：

（1）自然排序（默认排序）：

1）方法：
让元素自身具备比较性，需要添加的元素对象实现Comparable接口，覆盖compareTo方法。

如果元素不具备比较性，在运行时会发生ClassCastException异常。
所以需要元素实现Comparable接口，强制让元素具备比较性，复写compareTo方法。
依据compareTo方法的返回值，确定元素在TreeSet数据结构中的位置。

2）注意：

在进行比较时，如果判断条件不唯一，比如，同姓名，同年龄，才视为同一个人。
在判断时，需要分主要条件和次要条件，当主要条件相同时，再判断次要条件，按照次要条件排序。

 

3）代码示例：

/*
需求：
往TreeSet集合中存储自定义对象学生。
想按照学生的年龄进行排序。

记住：排序时，当主要条件相同时，一定判断一下次要条件。
 */

import java.util.*;

class Student implements Comparable<Object> {// 该接口强制让学生具备比较性。
	private String name;
	private int age;

	Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;

	}

	public int getAge() {
		return age;
	}

	public int compareTo(Object obj) {
		if (!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");

		Student s = (Student) obj;

		System.out.println(this.name + "....compareto....." + s.name);

		if (this.age > s.age)
			return 1;

		if (this.age == s.age) {
			return this.name.compareTo(s.name);
		}
		return -1;
	}

}

class TreeSetTest1 {
	public static void main(String[] args) {
		TreeSet<Student> ts = new TreeSet<Student>();

		ts.add(new Student("lisi02", 22));
		ts.add(new Student("lisi007", 20));
		ts.add(new Student("lisi09", 19));
		ts.add(new Student("lisi08", 19));
		ts.add(new Student("lisi007", 20));
		ts.add(new Student("lisi01", 40));

		Iterator<Student> it = ts.iterator();

		while (it.hasNext()) {
			Student stu = (Student) it.next();
			System.out.println(stu.getName() + "..." + stu.getAge());
		}
	}

}

/*output:
lisi007....compareto.....lisi02
lisi09....compareto.....lisi02
lisi09....compareto.....lisi007
lisi08....compareto.....lisi007
lisi08....compareto.....lisi09
lisi007....compareto.....lisi007
lisi01....compareto.....lisi007
lisi01....compareto.....lisi02
lisi08...19
lisi09...19
lisi007...20
lisi02...22
lisi01...40
*/

 

（2）比较器：

1）使用条件及方法：

当元素自身不具备比较性(比如存储学生对象时)或者具备的比较性不是我们所需要的比较性时(比如想字符串的长度排序)，此时就需要让集合自身具备自定义的比较性。那如何让集合自身具备比较性呢？可在集合初始化时，就让集合自身具备比较性，需要定义一个类（比较器），实现Comparator接口，并覆盖compare方法，将比较器对象作为实际参数传递给TreeSet集合的构造函数。
自定义比较器的方法：定义一个类，实现Comparator接口，覆盖compare方法。

注意：第二种方式较为灵活。当两种排序都存在时，以比较器为主。

2）优先考虑比较器的原因：

实现implements Comparable接口定义排序有局限性，实现此接口只能按comparaTo()定义的这一种方法排序，如果同一对象有多种排序方式，应该定义不同的比较器，比如说学生对象可以按学号，分数，年龄等进行多种排序。

3）自定义比较器实质：

让自己编写的类实现Comparator接口，重写Comparator中的比较方法compara(Object a,Objectb)

compara(Object a,Objectb)方法使用：

public  int compare(Object a,Object b){

　　int i = b.对象属性- a.对象属性;
　　return   i;   //返回0，表示this==obj  ；返回正数表示，this>obj; 返回负数，表示this<obj

}

 

4）代码示例：

//让学生信息按照学生成绩排序输出

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

/**
 * 
 * 学术类
 * 
 */
class Student {

	/* 声明属性和方法 */
	private String name;
	private Integer age;
	private Integer score;

	/* 构造方法 */
	public Student(String name, Integer age, Integer score) {
		super();
		this.name = name;
		this.age = age;
		this.score = score;
	}

	/* getter，setter方法 */
	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 Integer getScore() {
		return score;
	}

	public void setScore(Integer score) {
		this.score = score;
	}

	@Override
	// 重写String，toString方法
	public String toString() {

		return "姓名：" + name + "    年龄：" + age + "      成绩:" + score;
	}

	@Override
	// 重写hasCode()方法
	public int hashCode() {

		return age * name.hashCode();
	}

	@Override
	// 重写equals方法
	public boolean equals(Object o) {

		Student s = (Student) o;

		return age == s.age && name.equals(s.name);

	}

}

/**
 * TreeSet测试类
 */

/* 创建学生成绩比较器 */
class StudentScoreComparator implements Comparator<Student> {

	@Override
	public int compare(Student o1, Student o2) {
		int i = (int) (o2.getScore() - o1.getScore());
		return i;
	}
}

public class TreeSetTest2 {
	public static void main(String[] args) {

		Set<Student> ts = new TreeSet<Student>(new StudentScoreComparator()); // 创建TreeSet集合

		Student stu1 = new Student("张三", 18, 85);
		Student stu2 = new Student("李四", 19, 88);
		Student stu3 = new Student("李红", 20, 60);
		Student stu4 = new Student("张丽", 18, 90);

		ts.add(stu1); // 将对象放进TreeSet集合中
		ts.add(stu2);
		ts.add(stu3);
		ts.add(stu4);

		Iterator<Student> it = ts.iterator(); // 声明迭代器

		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

/*output:
姓名：张丽    年龄：18      成绩:90
姓名：李四    年龄：19      成绩:88
姓名：张三    年龄：18      成绩:85
姓名：李红    年龄：20      成绩:60
*/

 

5）练习：

/*
练习：按照字符串长度排序。
字符串本身具备比较性。但是它的比较方式不是所需要的。
这时就只能使用比较器。
 */

import java.util.*;

class StrLenComparator implements Comparator<Object> {
	public int compare(Object o1, Object o2) {
		String s1 = (String) o1;
		String s2 = (String) o2;
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if (num == 0)
			return s1.compareTo(s2);
		return num;
	}
}

class TreeSetTest {
	public static void main(String[] args) {
		TreeSet<String> ts = new TreeSet<String>(new StrLenComparator());

		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("aaa");
		ts.add("z");
		ts.add("hahaha");

		Iterator<String> it = ts.iterator();

		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

/*output:
z
cc
aaa
cba
abcd
hahaha
*/