Set接口的实现类---HashSet

HashSet类

HashSet类直接实现了Set接口， 其底层其实是包装了一个HashMap去实现的，以需要存储的数据作为map的key值，以常量PRESENT作为value值

private transient HashMap<E, Object> map;

private static final Object PRESENT=new Object();

HashSet采用HashCode算法来存取集合中的元素，因此具有比较好的读取和查找性能

Set<Person> set=new HashSet<>();
Person p1=new Person();
Person p2=new Person();
set.add(p1);
set.add(p2);
System.out.println(set.size());

这里显示值为2，因为 Person类中的hashCode方法和equals方法都来自于Object类

public class Test2 {
	public static void main(String[] args) {
		A2 a1=new A2();
		A2 a2=new A2();
		System.out.println(a1==a2);  //false
		System.out.println(a1.equals(a2));  //false ? 这是因为A2类的equals是从java.lang.Object类中继承得到的，具体实现还是==
	}
}

class A2{
	private Long id;
	private String name;
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class Test20 {
	public static void main(String[] args) {
		A20 a1=new A20();
		A20 a2=new A20();
		System.out.println(a1==a2);  //false
		System.out.println(a1.equals(a2));  //true
		
		Set<A20> set=new HashSet<>();
		set.add(a1);
		set.add(a2);
		System.out.println(set.size());  //2? 这是因为对象比较时，首先调用hashCode方法，如果两个对象
		                                //的hashCode值相等才会继续调用equals比较，否则直接返回false
	}
}

class A20{
	private Long id;
	private String name;
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
//添加则返回1
//	@Override
//	public int hashCode() {
//		return Objects.hash(id, name);
//	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		A20 other = (A20) obj;
		
		return Objects.equals(id, other.id) && Objects.equals(name, other.name);
	}
	
}

在Person类中添加方法
public boolean equals(Object obj){
    if(obj!=null && obj instanceof Person){
        Person p=(Person)obj;
        //具体的比较内容取决于业务规则，这里不进行判空了（偷懒）
        return this.id==p.id && this.name.equals(p.name);
    }
    return false;
}

问题在于hashcode值 
public int hashCode(){
    return this.id.hashCode();
}

原因在于：向HashSet中添加元素时首先执行的是对象的hashcode值比较，如果两个
对象的hashcode值相等时才会继续调用equals方法；如果两个对象的hashcode值不
相等则不会调用equals方法

向set中添加元素到底比较是采用==还是equals?
Set<String> set=new HashSet<>();
String s1="abc";
String s2=new String("abc");
System.out.println(s1==s2);
set.add(s1);
set.add(s2);
System.out.println(set.size());  //返回为1

HashSet实际上是通过使用HashMap的key实现的，所有key对应的value都是一个常量

散列算法

散列法Hashing是一种将字符组成的字符串转换为固定长度（一般是更短长度）的数值或索引值的方法，称为散列法，也叫哈希法。

由于通过更短的哈希值比用原始值进行数据库搜索更快，这种方法一般用来在数据库中，建立索引并进行搜索，同时还用在各种解密算法中

当然在存储时需要解决哈希碰撞问题

通常处理碰撞的方法有开放寻址Open Addressing法和链地址法

String类型中的hashCode方法的实现:
  public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            hash = h = isLatin1() ? StringLatin1.hashCode(value)
                                  : StringUTF16.hashCode(value);
        }
        return h;
    }

由于自定义类都会直接或者间接的继承于java.lang.Object，所以所有的类中都有hashCode
方法
        public native int hashCode();

HashSet的特征

1、无序：不仅不能保证元素插入的顺序（如果需要顺序则可以使用LinkedHashSet） ，而且在元素在以后的顺序中也可能变化（这是由HashSet按HashCode存储对象（元素）决定的，对象变化则可能导致HashCode变化）

        如果需要访问的顺序和插入的顺序一致，可以使用HashSet的子类LinkedHashSet

2、不允许重复 [equals和hashcode]
3、HashSet是线程非安全的，方法上没有同步约束

如何判断两个对象相等 

实现Set接口的HashSet，依靠HashMap来实现的。

我们应该为要存放到散列表的各个对象定义hashCode()和equals()

HashSet的equals和hashCode

那么HashSet如何判断元素重复呢？
        HashSet需要同时通过equals和HashCode来判断两个元素是否相等，具体规则是，如果两个元素通过equals为true，并且两个元素的hashCode相等，则这两个元素相等（即重复）。所以如果要重写保存在HashSet中的对象的equals方法，也要重写hashCode方法，重写前后hashCode返回的结果相等（即保证保存在同一个位置）。所有参与计算 hashCode() 返回值的关键属性，都应该用于作为 equals() 比较的标准。
    
    结论：要求当两个同类型对象equals为true时，必须hashCode值一致。事实上equals方法和hashCode方法没有任何必然联系