手写LinkedHashMap

package com.fcc.jdk8api.sjjg_sf.array.map;

import java.util.Arrays;
import java.util.HashMap;

/**
 * @Description:
 * @Author: CC.F
 * @Date: 23:27 2018/12/16
 */
public class MyLinkedHashMap<K, V> {

    private Integer size = 0;

    private Integer initLength = 16;

    private double loadFactor = 0.75D;

    private Entry<K, V>[] table;

    private Entry<K,V> head;
    private Entry<K,V> tail;

    MyLinkedHashMap(Integer initLength, double loadFactor) {
        this.initLength = initLength;
        this.loadFactor = loadFactor;
        this.table = new Entry[initLength];
    }

    MyLinkedHashMap() {
        this.table = new Entry[initLength];
    }

    Integer getHash(K key) {
        return Math.abs((key.hashCode() % (initLength - 1)));
    }

    public V put(K key, V value) {
        Integer index = getHash(key);
        if (table.length < index + 1) {
            Integer len = table.length + (int) (table.length * loadFactor);
            Entry<K, V>[] newArr = Arrays.copyOf(table, len);
            this.table = newArr;
        }
        Entry<K,V> kvEntry=table[index];
        if(kvEntry==null){
            table[index]=newNode(key,value,null,index);
            size++;
        }else{
            if(kvEntry.key.equals(key)){
                table[index]=newNode(key,value,kvEntry.node,index);
            }else{
                table[index]=newNode(key,value,kvEntry,index);
                size++;
            }
        }
        return table[index].getValue();
    }

    public V getValue(K key){
        Integer index = getHash(key);
        return table[index].getValue();
    }

    Entry<K,V> newNode( K key, V value, Entry<K,V> next,Integer hash) {
        Entry<K,V> p= new Entry( key, value, next,hash);
        linkNodeLast(p);
        return p;
    }

    private void linkNodeLast(Entry<K,V> p){
        Entry<K,V> last=tail;
        tail=p;
        if(last==null){
            head=p;
        }else{
            p.before=last;
            last.after=p;
        }
    }

    class Entry<K, V> {
        private Entry<K, V> node;
        private Integer index;
        private K key;
        private V value;
        private Entry<K,V> before;
        private Entry<K,V> after;


        Entry(K key, V value, Entry<K, V> node, Integer index) {
            this.key = key;
            this.value = value;
            this.node = node;
            this.index = index;
        }

        Entry() {
        }

        public K getKey() {
            return this.key;
        }

        public V getValue() {
            return this.value;
        }
    }
}