散列算法与散列码

 1 /**
 2  * Description:新建一个类作为map的key
 3  */
 4 public class Groundhog
 5 {
 6     protected int number;
 7 
 8     public Groundhog(){
 9     }
10     public Groundhog(int number)
11     {
12         this.number = number;
13     }
14 
15     @Override
16     public String toString()
17     {
18         return "Groundhog{" + "number=" + number + ‘}‘;
19     }
20 }
21 
22 /**
23  * Description:新建一个类作为map的value
24  */
25 public class Prediction
26 {
27     private boolean shadow=Math.random() > 0.5;
28 
29     @Override
30     public String toString()
31     {
32         if (shadow) return "Six more weeks of Winter";
33         else return "Early Spring!";
34     }
35 }
36 
37 /**
38  * Description:测试类
39  */
40 public class SpringDetector
41 {
42     public static void detectSpring(Class grondHotClass) throws Exception{
43         Constructor constructor = grondHotClass.getConstructor(new Class[]{int.class});
44         Map map=new HashMap();
45         for (int i=0;i<10;i++){
46             map.put(constructor.newInstance(new Object[]{new Integer(i)}),new Prediction());
47         }
48         System.out.println("map="+map);
49 
50         Groundhog groundhog=(Groundhog)constructor.newInstance(new Object[]{new Integer(3)});
51         System.out.println(groundhog);
52 
53         if (map.containsKey(groundhog)) {//查找这个key是否存在
54             System.out.println((Prediction)map.get(groundhog));
55         }else {
56             System.out.println("key not find:"+groundhog);
57         }
58 
59     }
60     public static void main(String[] args)
61     {
62         try {
63             detectSpring(Groundhog.class);
64         } catch (Exception e) {
65             e.printStackTrace();
66         }
67     }
68 }

/**
 * Description:首先新建一个类作为map中存储的对象并重写了hashCode()和equals()方法
 */
public class MPair implements Map.Entry,Comparable
{
    private Object key,value;

    public MPair(Object key,Object value)
    {
        this.key = key;
        this.value=value;
    }
    @Override
    public int compareTo(Object o)
    {
        return ((Comparable)key).compareTo(((MPair)o).key);
    }
    
    @Override
    public Object getKey()
    {
        return key;
    }

    @Override
    public Object getValue()
    {
        return value;
    }

     @Override
    public int hashCode()
    {
        int result = key != null ? key.hashCode() : 0;
        result = 31 * result + (value != null ? value.hashCode() : 0);
        return result;
    }

    @Override
    public boolean equals(Object o)
    {
        return key.equals(((MPair)o).key);
    }

    @Override
    public Object setValue(Object v)
    {
        Object result=value;
        this.value=v;
        return result;
    }
    
    @Override
    public String toString()
    {
        return "MPair{" + "key=" + key + ", value=" + value + ‘}‘;
    }

public class SimpleHashMap extends AbstractMap
{
    
    private static final int SZ=3;//定一个初始大小的哈希表容量
    private LinkedList[] linkedLists=new LinkedList[SZ];//建一个hash数组，用linkedList实现
    public Object put(Object key,Object value){
        Object result=null;
        int index=key.hashCode() % SZ;//对key的值做求模法求出index
        if (index<0) index=-index;
        if (linkedLists[index]==null) linkedLists[index]=new LinkedList();//如果这个index位置没有对象，就新建一个

        LinkedList linkedList = linkedLists[index];//取出这个index的对象linkedList
        MPair mPair = new MPair(key,value);//新建要存储的对象mPair
        ListIterator listIterator = linkedList.listIterator();
        boolean found =false;
        while (listIterator.hasNext()){//遍历这个index位置的List,如果查找到跟之前一样的对象(根据equals来比较)，则更新那个key对应的value
            Object next = listIterator.next();
            if (next.equals(mPair)){
                result = ((MPair) next).getValue();
                listIterator.set(mPair);//更新动作
                found=true;
                break;
            }
        }
        if (!found) linkedLists[index].add(mPair);//如果没有找到这个对象，则在这index的List对象上新增一个元素。
        return result;

    }

    public Object get(Object key){
        int index = key.hashCode() % SZ;
        if (index<0) index=-index;
        if (linkedLists[index]==null) return null;
        LinkedList linkedList = linkedLists[index];
        MPair mPair=new MPair(key,null);//新建一个空的对象值，因为equals()的比较是看他们的key是否相等，而在List中的遍历对象的时候，是通过key来查找对象的。
        ListIterator listIterator = linkedList.listIterator();
        while (listIterator.hasNext()){
            Object next = listIterator.next();
            if (next.equals(mPair)) return ((MPair)next).getValue();//找到了这个key就返回这个value
        }
        return null;

    }

    @Override
    public Set<Entry> entrySet()
    {
        Set set=new HashSet();
        for (int i=0;i<linkedLists.length;i++){
            if (linkedLists[i]==null) continue;
            Iterator iterator = linkedLists[i].iterator();
            while (iterator.hasNext()){
                set.add(iterator.next());
            }
        }
        return set;
    }

    public static void main(String[] args)
    {
       SimpleHashMap simpleHashMap=new SimpleHashMap();
        simpleHashMap.put("1", "1");
        simpleHashMap.put("2", "2");
        simpleHashMap.put("3","3");
        simpleHashMap.put("4","4");//这里有四个元素，其中key是1和key是4的index是一样的，所以index为1的List上面存了两个元素。
        System.out.println(simpleHashMap);
        Object o = simpleHashMap.get("1");
        System.out.println(o);
        Object o1 = simpleHashMap.get("4");
        System.out.println(o1);

    }
}