ArrayList与LinkedList集合实现简单HashMap

equals和hashCode（）

在介绍ArrayList和LinkedList来实现基本的HashMap中的存储,我们有必要介绍一下equals()和hashCode()之间的区别
1.equal()相等的两个对象他们的hashCode()肯定相等，也就是用equal()对比是绝对可靠的。
2.hashCode()相等的两个对象他们的equal()不一定相等，也就是hashCode()不是绝对可靠的。
我们来看一个简单的例子:

public class TestHashCode {
    public static void main(String[] args) {
        /**
         *  hashCode和Equals都可以比较对象
         *  两个对象的hashCode相同 但是对象不一定相同
         *  两个对象使用equals比较,那么对象一定相同
         */
        String a = "a";
        Integer b = new Integer(97);
        System.out.println(a.hashCode()); //97
        System.out.println(b.hashCode()); //97
    }
}

关于hashCode和equals的文章 好文推荐：https://www.cnblogs.com/keyi/p/7119825.html

ArrayList

这里我们模拟了 HashMap中的put方法和get方法,具体的代码如下:

1.定义一个Entry(关键)

public class Entry<K,V> {
   /**
    * @param
    * @Desciption key
    * @return
    */
   private K k;
   /**
    * @param
    * @Desciption value
    * @return
    */
   private V v;
   public Entry(K k,V v){
       this.k = k;
       this.v = v;
   }
   public K getKey(){
       return k;
   }
   public V getValue(){
       return v;
   }

   public void setValue(V value) {
       v =  value;
   }
}

2.定义ArrayList实现HashMap

public class ArrayListHashMap<K,V> {
    private List<Entry<K,V>> listEntry = new ArrayList<>();

    public V put(K key,V value){
        Entry<K,V> entry = new Entry<>(key,value);
        listEntry.add(entry);
        return value;
    }

    public V get(K key){
        for (Entry entry: listEntry) {
             if(entry.getKey().equals(key)){
                 return (V)entry.getValue();
             }
        }
        return null;
    }
    public int size(){
        return listEntry.size();
    }
}

3.测试

public class Test {
    public static void main(String[] args) {
         ArrayListHashMap<String,Object> map = new ArrayListHashMap();
         map.put("yznl",2);
         System.out.println(map.get("yznl")); //2
    }
}

我们使用ArrayList来实现HashMap时,有一个问题就是ArrayList的 缺点: 遍历所有 查询效率极低

LinkedList

当我们采用LinkedList作为基本集合时,非常接近JDK 1.7的hashMap,并且使用hash值来存储key,查询效率高

public class LinkedListHashMap<K,V> {
    private LinkedList<Entry>[] objects =  new LinkedList[100];


    public V put(K key,V value){
         int hash = hash(key);
        Entry entry1 = new Entry(key,value);
       //查询出相同的hashCode linkedList集合是否存在
        LinkedList<Entry> linkedList = objects[hash];
        if(linkedList == null){
            //说明没有发生hash冲突
            linkedList = new LinkedList();
            linkedList.add(entry1);
            objects[hash] = linkedList;
            return value;
        }
        //产生hashCode冲突
        // 1:  可能修改
         for(Entry entry : linkedList) {
             if(entry.getKey().equals(key)){
                  entry.setValue(value);
                  return value;
             }
         }
         // 不修改  hashcode相同 对象不同
         linkedList.add(entry1);
         objects[hash]  = linkedList;
         return value;
    }

    public V get(K key){
        if(key==null){
            return null;
        }
        int hash =hash(key);
        LinkedList<Entry> linkedList = objects[hash];
        for(Entry entry : linkedList) {
            if(entry.getKey().equals(key)){
                return (V)entry.getValue();
            }
        }
        return null;
    }
    private int hash(K key){
        int hashCode = key.hashCode();
        int hash = hashCode % objects.length;
        return hash;
    }
}

2.测试

public class TestLinkedList {
    public static void main(String[] args) {
        LinkedListHashMap<Object, Object> map = new LinkedListHashMap<>();
        map.put("a","冲突1");
        map.put(97,"冲突2");
        System.out.println(map.get(97));
        System.out.println(map.get("a"));
    }
}
//冲突2
//冲突1