/**
    哈希集合特点：存取顺序不确定，同一个哈希值的位置可以存放多个元素，
                  哈希集合存放元素的时候是先判断哈希地址值:hashCode()是否相同，如果不同则直接存放；
                  如果哈希地址值相同则再调用equals()方法对元素进行判断如果元素不同则存放，如果元素相同则不存放.

                  对于判断元素是否存在依赖的是hashCode()和equals()方法

    区别：ArrayList区别元素的方法只依赖于equals();
          HashSet  区别元素的方法依赖于hashCode()和equals();
*/

import java.util.*;
class HashSetDemo
{
    public static void main(String[] args)
    {
        HashSet ha=new HashSet();
        ha.add(new Person("张三",10));
        ha.add(new Person("李四",11));
        ha.add(new Person("王五",12));
        ha.add(new Person("张三",10));
        Iterator it = ha.iterator();//迭代器是哈希集合唯一的遍历方式
        while(it.hasNext())
        {
            Person p=(Person)it.next();
            sop(p.getName()+":"+p.getAge());//只有Person类中才有gerName()方法，所以必须把it.next()强制转换成Person对象
        }
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public boolean equals(Object obj)//此方法是在哈希集合中存贮元素的时候自动调用的 用来判断同一个哈希地址值上的对象是否相同
    {
        if(!(obj instanceof Person))//判断obj是否是Person的一个实例
            return false;
        Person p=(Person)obj;//强制吧obj转换成Person类型
        
        return this.name.equals(p.name)&&this.age==p.age;//当前对象与引用p所指引的对象判断名字与年龄是否都相同(即当前要存贮的对象与哈希集合中已有的对象做比较。)
    }
    public int hashCode()//哈希值 在存储元素的时候会自动调用接口collection中的hashCode方法，如果此方法被复写那么就自动调用复写后的方法
    {
        System.out.println(this.name.hashCode()+this.age);
        return this.name.hashCode()+this.age;
    }
   
}

这个世界上永远不可能同时存在两个一模一样的人，而且性格各方都一样的，即世界上没有两片完全一样的叶子。其实，这样的一种情况符合数学中的集合的概念
* 而java编程中，集Set也是这样的，放在集中的对象中没有两个相同的引用，因为，Set有一个机制是在将对象放进集的时候会先检查集中是否已经存在，也就是先equals一下
* 如果存在，则不添加，如果不存在就添加，Set是一个接口，主要有两个实现子类，HashSet和TreeSet，而HashSet还有一个子类，LinkedHashSet，它不仅实现了哈希算法，
* 而且实现了链表数据结构，而链表数据结构能够提供插入和删除元素的性能。而TreeSet实现了SortedSet接口，有排序的功能。
* 这里先讲下HashSet类，当然，它也是祖先类的子类了，所以当然有两个方法：hashCode,equals，而equals是判断两个对象引用的内存地址是否相同来返回两个对象是否相等的依据
* 而HashCode即哈希码，所以，如果equals返回来是true，那么，它们的HashCode也必然相等。而如果，有一个类覆盖了祖先类Object的equals方法的话，那么就有可能出现两个引用相等
* 但是哈希码不等的情况，这样，Set的大小就会是2，下面的代码展示了这一情况，以及如果使其正常化。
*/
package com.cbh.collection_test;
/**
* @author cbh java编程网 http://www.haohaoblog.com
*/
import java.util.HashSet;
import java.util.Set;

public class Animal {
private String speak;
private int run;
Animal(String speak,int run)
{
this.speak=speak;
this.run=run;
}
public String getSpeak() {
return speak;
}
public void setSpeak(String speak) {
this.speak = speak;
}
public int getRun() {
return run;
}
public void setRun(int run) {
this.run = run;
}
public boolean equals(Object one)
{
if(this==one)return true;
if(!(one instanceof Animal))return false;
final Animal animal=(Animal)one;
if(this.speak.equals(animal.getSpeak())&&this.run==animal.getRun())
{
return true;
}
else return false;
}//覆盖祖先类Object的equals方法，使得判断两个类相等与否的方法由自己定义
//    public int hashCode()
//    {
//        int code;
//        code=(speak==null?0:speak.hashCode());
//        code=10*code+run;
//        return code;
//    }
public static void main(String[] args) {
Animal an1=new Animal(“1″,100);
Animal an2=new Animal(“1″,100);
Set<Animal> set=new HashSet<Animal>();
set.add(an1);
set.add(an2);
System.out.println(an1.equals(an2));//两者相等
System.out.println(set.size());//大小是2
System.out.println(an2.hashCode()==an1.hashCode());
/**造成这种现象的原因是，哈希码不同，照理是对象相等，哈希码就相等，大小只能是1，但是Animal类覆盖了Object的equals方法
* 所以，如果要恢复正常，那么只好一不做二不休，覆盖HashCode方法.
* 其实，这样的一种现象，正好可以验证，Set的存放元素标准，它是更加equals来判断是否已存在相同元素，有的话就不放的这一情况
*
*/

//        Set<String> set1=new HashSet<String>();
//        String s1=new String(“hello”);
//        String s2=new String(“hello”);
//        set1.add(s1);
//        set1.add(s2);
//        System.out.println(s1.hashCode()==s2.hashCode());//相等对象引用，顾哈希码相同
//        System.out.println(set1.size());//大小为1，有相同元素，只放一个
}