21、集合之Set之hashCode和equals

Set是一个接口，继承了Collection

Set的一个实现类是HashSet

import java.util.HashSet;

public class SetTest2
{
	public static void main(String[] args)
	{
		HashSet set = new HashSet();
		
		set.add("A");
		set.add("B");
		set.add("C");
		set.add("D");
		
		System.out.println(set);
		//加进去四个，但是打印时与加入时的顺序不同，打印的顺序是随机的
		set.add(new People("zhangsan"));
		set.add(new People("lisi"));
		set.add(new People("zhangsan"));
		//三个都加进去了
		System.out.println(set);
		
		People p1 = new People("wangwu");
		set.add(p1);
		set.add(p1);//只能加进去一个
		
		String s1 = new String("a");
		String s2 = new String("a");
		set.add(s1);
		set.add(s2);//s2也加不进去
	}
}

class People
{
	String name;
	
	public People(String name)
	{
		this.name = name;
	}
}

对于Set的add方法，能否将元素加入集合中呢，查看add（）方法的说明：

Adds the specified element tothis set if it is not already present.More firmally,adds the specified element e to this set if this set contains no element e2 such that

(e == null  ?  e2 == null  :  e.equals(e2)). If this set already contains the element,the call leaves the set unchanged and returns false.

如果此 set 中尚未包含指定元素，则添加指定元素。更确切地讲，如果此 set 没有包含满足 (e==null ? e2==null : e.equals(e2)) 的元素e2，则向此 set 添加指定的元素e。如果此 set 已包含该元素，则该调用不更改 set 并返回 false。

1、在这里使用了equals方法，这个方法是Object类定义的，对于这个equals方法的特点：

      a）自反性：It is reflexive： x.equals(x)应该返回true；

      b）对称性：It is symmetric：x.equals(y)为true，那么y.equals(x)也为true。

      c）传递性：It is transitive：x.equals(y)为 true并且y.equals(z)为true，那么x.equals(z)也应该为true。

      d）一致性：It is consistant：x.equals(y)的第一次调用为true，那么x.equals(y)的第二次、第三次、第n次调用也应该为true，前提条件是在比较之间没有修改x也没有修改y。

      e）对于非空引用x，x.equals(null)返回false。

2、Object类的hashCode方法

      a) 在Java应用的一次执行过程当中，对于同一个对象的hashCode方法的多次调用，他们应该返回同样的值（前提是该对象的信息没有发生变化）——这里要注意是一次执行过程当中。两次执行中同一个对象的hashCode值可能不同，也可能相同

      b）对于两个对象来说，如果使用equals方法比较返回true，那么这两个对象的hashCode值一定是相同的。

      c）对于两个对象来说，如果使用equals方法比较返回false，那么这两个对象的hashCode值不要求一定不同（可以相同，可以不同），但是如果不同则可以提高应用的性能。

      d）对于Object类来说，不同的Object对象的hashCode值是不同的，hashCode返回值是一个整型值（Object类的hashCode值表示的是对象的地址）。

3、当使用HashSet时，hashCode（）方法就会得到调用，判断已经存储在集合中的对象的hash code值是否与增加的对象的hash code值一致；如果不一致，直接加进去；如果一致，再进行equals方法的比较，equals方法如果返回true，表示对象已经加进去了，就不会再增加新的对象，否则加进去。

因为判断是否可以加入set需要同时使用hashCode和equals方法，所以如果我们重写equals方法，那么也要重写hashCode方法，反之亦然。

4、对于上面的SetTest2类来说，因为People类没有重写hashCode和equals方法，所以

set.add(new People("zhangsan"));

set.add(new People("lisi"));

set.add(new People("zhangsan"));

两次new People("zhangsan")都加入了set，下面的程序重写了hashCode和equals方法，结果就只能加入一个

import java.util.HashSet;

public class SetTest3
{
	public static void main(String[] args)
	{
		HashSet set = new HashSet();
		
		Student s1 = new Student("zhangsan");
		Student s2 = new Student("zhangsan");
		
		set.add(s1);
		set.add(s2);
		//只能加入s1		
		System.out.println(set);
	}
}

class Student
{
	String name;
	
	public Student(String name)
	{
		this.name = name;
	}
	
	public int hashCode()
	{
		return this.name.hashCode();
	}
	
	public boolean equals(Object o)
	{
		if (this == o)
		{
			return true;
		}
		
		if(null != o && o instanceof Student)
		{
			Student s = (Student)o;
			if(name.equals(s.name))
			{
				return true;
			}
		}
		
		return false;
	}
}

Myeclips当中提供了自动生成hashCode和equals方法的机制，可以实现自动生成重写方法代码。

5、HashSet因为它里面的元素是无序的，也就是说，我们存进去的是一个顺序，取出来的时候是另一种顺序，或者多次取出时每次的顺序也不一样，就是说没有下标的概念，不能使用类似List的get（int index）方法取其中的元素，这时，HashSet提供了一个iterator方法——迭代器。对于HashSet的iterator（）方法：

public Iterator<E> iterator()

Returns an iterator over the elements in this set.The elements are returned in no particular order.

返回对此 set 中元素进行迭代的迭代器。返回元素的顺序并不是特定的(无序的)。

返回的迭代器有三个方法：boolean hasNext（），Object next（），void remove（）。

6、迭代器的使用：在通过迭代函数访问类集之前，必须得到一个迭代函数。每一个Collection类都提供一个iterator()函数，该函数返回一个对类集头的迭代函数。通过使用这个迭代函数对象，可以访问类集中的每一个元素，一次一个元素。通常，使用迭代函数循环通过类集的内容，步骤如下
      –1. 通过调用类集的iterator( )方法获得对类集头的迭代函数。
      –2. 建立一个调用hasNext( )方法的循环，只要hasNext( )返回true，就进行循环迭代。
      –3. 在循环内部，通过调用next( )方法来得到每一个元素

for(Iterator iter = set.iterator();iter.hasNext();)
		{
			String value = (String)iter.next();
			System.out.println(value);
		}

6、Set接口的子接口SortedSet，SortedSet的实现类为TreeSet。

TreeSet的输出不是任意的，她是按照一定规则进行排序后输出的有序序列。

import java.util.TreeSet;

public class TreeSetTest
{
	public static void main(String[] args)
	{
		TreeSet set = new TreeSet();
		
		set.add("C");
		set.add("A");
		set.add("E");
		set.add("D");
		set.add("B");
		
		
		System.out.println(set);
	}
}

这个输出为【A，B，C，D，E】，有序的。

如果我们加入的是自定义的类对象，如下：

import java.util.TreeSet;

public class TreeSetTest2
{
	public static void main(String[] args)
	{
		TreeSet set = new TreeSet();
		
		Person p1 = new Person(10);
		Person p2 = new Person(20);
		Person p3 = new Person(30);
		Person p4 = new Person(40);
		
		set.add(p1);
		set.add(p2);
		set.add(p3);
		set.add(p4);
		
		System.out.println(set);
	}
}

class Person
{
	int score;
	
	public Person(int score)
	{
		this.score = score;
	}
	
	public String toString()
	{
		return String.valueOf(this.score);
	}
}

运行时将出现错误：java.lang.ClassCastException。

查看TreeSet的add（）方法，抛出ClassCastException是由于：如果指定对象无法与此 set 的当前元素进行比较。之所以TreeSetTest可以运行，是因为默认的TreeSet采用自然排序，也就会说如果set中的元素可自然排序（如对于字符串，按照自然排序也就是字典排序），如果不能采用自然排序，要么需要指定一个比较器，要么抛异常。

查看TreeSet的构造方法：

TreeSet()                                                                         构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
TreeSet(Collection<? extends E> c)                          构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
TreeSet(Comparator<? super E> comparator)       构造一个新的空 TreeSet，它根据指定比较器进行排序。
TreeSet(SortedSet<E> s)                                             构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

第三种就是可以自己指定一个比较器。

假设我们已经有了一个比较器  Comparator myComparator，生成带特定比较器的TreeSet对象：

TreeSet set = new TreeSet(myComparator);

7、Comparator是一个接口，提供两个方法，int compare(T o1, T o2) 和equals()方法，我们需要实现Comparator接口的类并重写compare方法。

对于compare方法，用来比较排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

 

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

public class TreeSetTest2
{
	public static void main(String[] args)
	{
		TreeSet set = new TreeSet(new MyComparator1());//调用带有自定义比较器的构造方法
		
		Person p1 = new Person(10);
		Person p2 = new Person(20);
		Person p3 = new Person(30);
		Person p4 = new Person(40);
		
		set.add(p1);
		set.add(p2);
		set.add(p3);
		set.add(p4);
		for(Iterator iter = set.iterator();iter.hasNext();)
		{
			Person p = (Person)iter.next();
			System.out.println(p.score);
		}
		System.out.println(set);
	}
}

class Person
{
	int score;
	
	public Person(int score)
	{
		this.score = score;
	}
	
	public String toString()
	{
		return String.valueOf(this.score);
	}
}

class MyComparator1 implements Comparator                      //自定义比较器
{
	public int compare(Object arg0,Object arg1)
	{
		Person p1 = (Person)arg0;
		Person p2 = (Person)arg1;
		
		return p2.score - p1.score;
	}
}

 8、关于Collections类，类似于Arrays类，提供很多的静态方法，来对集合进行操作。

 Collections提供的常用方法：

<T> Comparator<T>  reverseOrder(Comparator<T> cmp)   返回一个比较器，它强行逆转指定比较器的顺序。
<T extends Comparable<? super T>> void sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。
static void shuffle(List<?> list)   使用默认随机源对指定列表进行置换。

min（），max（）