开放地址法实现HashTable

前注:本文不是讲解Java类库的Hashtable实现原理，而是根据计算机哈希表原理自己实现的一个Hashtable。

HashTable内部是用数组存放一个(Key-Value pair)键值对的引用，其原理是根据Key的hashCode来计算出数组下标。因为存放位置是直接计算出来，不需要遍历数据结构，这使得hash table具有快速增删查改的优势。下面介绍HashTable的实现步骤:

• 取得Key的hashCode。

　　通过Eclipse等工具可以轻松的复写Object的hashCode方法，生成的hashCode是不会有重复值的。

• 将hashCode与地址映射(压缩地址):

　　但是，Hashtable内部是用一个数组来存储Key-Value对的，数组容量有限，本文中设置数组容量为10。那么现在的问题就是如何将hashCode和数组地址相对应？一个简单的方法就是对hashCode取模运算(hashCode%10)。这样就可以将hashCode与数组地址做映射（多对一）。同时注意，hashCode可能为负数，而数组的下标不能为负数，所以在映射的时候需要处理一下。

int hashCode =  Math.abs(key.hashCode())% this.maxSize;

• 解决hashCode重复问题：

上文已经说过，数组容量为10，当我们在将hashCode映射为数组下标的时候，肯定会遇到有重复的情况。比如hashCode为21和31，分别对他们取模运算，结果都是1，也就是说这两个hashCode对应数组的下标都是1.那么第一个元素添加上去后，再添加第二个元素，则新元素会覆盖之前的元素。这时，如果我们想后面添加的重复地址元素也能添加上去，只能将其放在其它位置。这时，我们可以将新元素放在改地址的下一位，如果下一位已经有元素，那么就继续往后找，直到找到空位为止（其实这个过程有些边界条件需要考虑，比如找到数组末尾后应跳到数组开头继续找。以及数组已经满了，找遍数组都找不到合适的位置，就应该提示该数组已满，不能插入）。 

现在既然解决了上面的问题，也就是说每个元素都能在数组中找到合适的位置（除非数组已满）。那么可以根据这个算法实现数组的增删查改。下面是Hashtable的实现代码:

package org.lyk.impl;

public class HashTable<K, V>
{
    /**
     * Key-Value pair 存放键值对
     * @author liuyuank
     *
     */
    private class KeyValue
    {
        K key;
        V value;

        private KeyValue(K key, V value)
        {
            this.key = key;
            this.value = value;
        }

        public K getKey()
        {
            return key;
        }

        public void setKey(K key)
        {
            this.key = key;
        }

        public V getValue()
        {
            return value;
        }

        public void setValue(V value)
        {
            this.value = value;
        }

    }

    private Object[] table;
    private int maxSize = 10;
    private int currentAmmount = 0;

    public HashTable()
    {
        this.table = new Object[this.maxSize];
    }

    public HashTable(int maxSize) throws Exception
    {
        if (0 == maxSize || maxSize < 0 || maxSize > 100)
        {
            throw new Exception("table容量非法!");
        }

        this.maxSize = maxSize;
        this.table = new Info[maxSize];
    }

    /**
     * 增加一个键值对
     * @param key
     * @param value
     */
    public void add(K key, V value)
    { 
        //将hashCode映射到数组下标
        int hashCode =  Math.abs(key.hashCode())% this.maxSize;
        
        //将元素插入到数组中，如果该位置已经被占用，则循环查找下一个位置，直到找到合适的位置，或发现数组已满，退出循环
        while (this.table[hashCode] != null
                && (this.currentAmmount < this.maxSize))
        {
            hashCode++;
            hashCode = hashCode % this.maxSize;
        }

        if (this.currentAmmount == this.maxSize)
        {
            //数组已满
            System.out.println("Hash table 已满");
        } else
        {
            //找到合适位置
            this.table[hashCode] = new KeyValue(key, value); 
            this.currentAmmount++;
        }
    }

    /**
     * 与add方法同样的算法，根据key值找到数组中元素，然后将改元素设置为null
     * @param key
     * @return
     */
    public boolean remove(K key)
    {
        int hashCode = Math.abs(key.hashCode()) % this.maxSize;
        int count = 0;
        while (this.table[hashCode] != null && count < this.maxSize)
        {
            if (((KeyValue) this.table[hashCode]).getKey().equals(key))
            {
                this.table[hashCode] = null;
                return true;
            }
            count++;
            hashCode++;
            hashCode = hashCode%this.maxSize;
        }

        return false;
    }

    public V get(K key)
    {
        int hashCode = Math.abs(key.hashCode()) % this.maxSize;
        int count = 0;
        while (this.table[hashCode] != null && count < this.maxSize)
        {
            if (key.equals(((KeyValue)this.table[hashCode]).getKey()))
                return ((KeyValue) this.table[hashCode]).getValue();
            
            hashCode++;
            count++;
            hashCode = hashCode%this.maxSize;
        }
        return null;
    }

    public boolean contains(K key)
    {
        if (this.get(key) != null)
        {
            return true;
        } else
        {
            return false;
        }
    }
    
    public void replace(K key, V value)
    {
        KeyValue kv = this.find(key);
        if(kv != null)
        { 
            kv.setValue(value);
        }
    }
    
    private KeyValue find(K key)
    {
        int hashCode = Math.abs(key.hashCode()) % this.maxSize;
        int count = 0;
        while (this.table[hashCode] != null && count < this.maxSize)
        {
            if (key.equals(((KeyValue)this.table[hashCode]).getKey()))
                return ((KeyValue) this.table[hashCode]);
            
            hashCode++;
            count++;
            hashCode = hashCode%this.maxSize;
        }
        return null;
    }
}

package org.lyk.impl;

import java.math.BigInteger;

public class Info
{
    private String name;
    private String address;
    private Integer age; 
    
    
    public Info(String name, String address, Integer age)
    {
        super();
        this.name = name;
        this.address = address;
        this.age = age;
    }
    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((address == null) ? 0 : address.hashCode());
        result = prime * result + ((age == null) ? 0 : age.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    
//    @Override
//    public int hashCode()
//    {
//        final int prime = 27;
//        int result = 1;
//        result = prime*result + (this.name == null ? 0:this.name.hashCode());
//        result = prime*result + (this.address == null ? 0:this.address.hashCode());
//        result = prime*result + (this.age == null ? 0 : this.age.hashCode());
//        return result;
//    }
    
    
    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Info other = (Info) obj;
        if (address == null)
        {
            if (other.address != null)
                return false;
        } else if (!address.equals(other.address))
            return false;
        if (age == null)
        {
            if (other.age != null)
                return false;
        } else if (!age.equals(other.age))
            return false;
        if (name == null)
        {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public String getAddress()
    {
        return address;
    }
    public void setAddress(String address)
    {
        this.address = address;
    }
    public Integer getAge()
    {
        return age;
    }
    public void setAge(Integer age)
    {
        this.age = age;
    }
    @Override
    public String toString()
    {
        return "Info [name=" + name + ", address=" + address + ", age=" + age
                + "]";
    }
    
    
    
    
}

测试代码:String为Key Info为Value

package org.lyk.main;
 

import org.lyk.impl.BiTree;
import org.lyk.impl.HashTable;
import org.lyk.impl.Info;

public class Main
{
    public static void main(String[] args)
    {
        HashTable<String, Info> ht = new HashTable<>();
        for(int i =0; i <15;i++)
        {
            Info info = new Info("sheldon" + i, "address" + i , i);
            //System.out.println("hashCode in main:" + info.getName().hashCode());
            ht.add(info.getName(), info);
        }
        
        String key = "sheldon3";
        System.out.println(ht.contains(key));
        ht.replace(key, new Info("谢耳朵","美国洛杉矶", 999));
        System.out.println(ht.contains(key));
        System.out.println(ht.get(key));
        System.out.println("///~ main done");
    } 
     
}