java中set\map自定义去重依据（重载Bean类的hashcode和equals）

<pre name="code" class="plain">java中set\map自定义去重依据（重载Bean类的hashcode和equals）
自定义去重的依据，不光要重载equals，还需要重载hashcode
去重时（发生在往set，map中加入数据时），先获取hashcode,如果hashcode与容器中现有的hashcode不重复，则不再执行equals，而直接认为该key尚未加入到容器中；
如果hashcode与容器中现有的hashcode重复，再去执行equals,以equals的结果为准。
无论什么类型（包括8种基本类型和包装类型、String类、数组等），其去重的规则都是依据 重载Bean类的hashCode和equals方法。
<注：数组类型可能需要对其进一步包装。

</pre><pre name="code" class="java">

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;


public class Test2 {

	public static void main(String[] args)
	{
		AA a1 = new AA(1);
		AA a2 = new AA(2);
		AA a3 = new AA(1);
		AA a4 = new AA(0);
		
		Set<AA> set = new HashSet<AA>();
		set.add(a1);
		set.add(a2);
		set.add(a3);
		set.add(a4);
		
		Map<AA, Integer> map = new HashMap<AA, Integer>();
		map.put(a1, 9);
		map.put(a2, 2);
		map.put(a3, 0);
		map.put(a4, 8);
	}
}


class AA
{
	int a = 0;
	public AA(int a)
	{
		this.a = a;
	}
	
	
	// 自定义去重的依据，不光要重载equals，还需要重载hashcode
	// 去重时（发生在往set，map中加入数据时），先获取hashcode,如果hashcode与容器中现有的hashcode不重复，则不再执行equals，而直接认为该key尚未加入到容器中；
	// 如果hashcode与容器中现有的hashcode重复，再去执行equals,以equals的结果为准。
	@Override
	public boolean equals(Object obj) {
		AA tmp = (AA)obj;
		if (tmp.a == this.a) {
			return true;
		} else {
			return false;
		}
	}

	@Override // 在往set，map容器中加入元素时，每次都会执行该函数。根据该函数的执行结果再决定是否要执行equals.
	public int hashCode() {
		// TODO 自动生成的方法存根
		return this.a; // 如果这里统一返回0，则一定会执行equals.
	}
	
}

// 以下测试：
当Set中插入时，值（Key）已经存在时，当前插入的值（Key），不会替换原来已经存在的Key，即不会用当前对象去替换原有对象。
当Map中插入时，Key已经存在时，不会用当前正要插入的Key对象，替换原来的Key对象，但Value值会被替换（即用当前插入的value替换原来存在的value）。

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;




public class Test9 {
 
 public static void main(String[] args)
 {    
  Set<BD> set2  = new HashSet<BD>();
  Set<BD> set3 = new TreeSet<BD>();
  BD b1 = new BD();
  BD b2 = new BD();
  BD b3 = new BD();
  
  set2.add(b1); //执行完该句， set中存放的是b1
  set2.add(b2); //执行完该句， set中存放的是b1
  set2.add(b3); //执行完该句， set中存放的是b1
  
  set3.add(b1); //执行完该句， set中存放的是b1
  set3.add(b2); //执行完该句， set中存放的是b1
  set3.add(b3); //执行完该句， set中存放的是b1
  
  Map<BD, BD> map = new HashMap<BD, BD>();
  map.put(b1, b1); //执行完该句， map中存放的是b1,b1
  map.put(b2, b2); //执行完该句， map中存放的是b1,b2
  map.put(b3, b3); //执行完该句， map中存放的是b1,b3
  map.put(b1, b1); //执行完该句， map中存放的是b1,b1
 }
}




class BD implements Comparable<BD>
{
 @Override
 public int hashCode() {
  // TODO 自动生成的方法存根
  return 0;
 }
 
 @Override
 public boolean equals(Object obj) {
  // TODO 自动生成的方法存根
  return true;
 }
 
 @Override
 public int compareTo(BD o) {
  // TODO 自动生成的方法存根
  return 0;
 }
}