使用两个ArrayList集合实现简单的map

package map;
import java.util.Map;
import java.util.Objects;
/**
 * TODO 类描述
 *
 * @author qijian.
 * @date 2021/7/21 15:35
 */
public class MapEntry<K, V> implements Map.Entry<K, V> {
    private K key;
    private V value;
    public MapEntry(K key, V value) {
        this.key = key;
        this.value = value;
    }
    @Override
    public K getKey() {
        return key;
    }
    @Override
    public V getValue() {
        return value;
    }
    @Override
    public V setValue(V value) {
        V result = value;
        this.value = value;
        return result;
    }
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof MapEntry))
            return false;
        MapEntry me = (MapEntry) o;
        return (key == null ? me.getKey() == null : key.equals(me.getKey())&&
                (value == null ? me.getValue() == null : value.equals(me.getValue())));
    }
    @Override
    public int hashCode() {
        return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode());
    }
    @Override
    public String toString(){
        return key + "=" + value;
    }
}

package map;
import java.util.*;
/**
 * TODO 类描述
 *
 * @author qijian.
 * @date 2021/7/21 15:07
 */
public class SlowMap<K,V> extends AbstractMap<K,V> {
    private List<K> keys = new ArrayList<K>();
    private List<V> values = new ArrayList<V>();
    /**
     * 添加键值对
     * @param key 添加的键
     * @param value 添加的值
     * @return 返回得到旧值，或null
     */
    public V put(K key,V value){
        V oldValue = get(key);//
        if (!keys.contains(key)){
            keys.add(key);
            values.add(value);
        }else {
            values.set(keys.indexOf(key),value);
        }
        return oldValue;
    }
    /**
     * 获得value
     * @param key
     * @return
     */
    public V get(Object key){
        if (!keys.contains(key)){
            return null;
        }
        return values.get(keys.indexOf(key));
    }
    @Override
    public Set<Map.Entry<K, V>> entrySet() {
        Set<Map.Entry<K,V>> set = new HashSet<Map.Entry<K,V>>();
        Iterator<K> ki = keys.iterator();
        Iterator<V> vi = values.iterator();
        while (ki.hasNext()){
            set.add(new MapEntry<K,V>(ki.next(),vi.next()));
        }
        return set;
    }
    @Override
    public int size() {
        return super.size();
    }
    @Override
    public boolean isEmpty() {
        return super.isEmpty();
    }
    @Override
    public boolean containsValue(Object value) {
        return super.containsValue(value);
    }
    @Override
    public boolean containsKey(Object key) {
        return super.containsKey(key);
    }
    @Override
    public V remove(Object key) {
        return super.remove(key);
    }
    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        super.putAll(m);
    }
    @Override
    public void clear() {
        super.clear();
    }
    @Override
    public Set<K> keySet() {
        return super.keySet();
    }
    @Override
    public Collection<V> values() {
        return super.values();
    }
    @Override
    public boolean equals(Object o) {
        return super.equals(o);
    }
    @Override
    public int hashCode() {
        return super.hashCode();
    }
    @Override
    public String toString() {
        return super.toString();
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    public static void main(String[] args) {
        SlowMap<String ,String> m = new SlowMap<>();
        m.put("qijian","zuishuai");
        m.put("tom","diershuai");
        System.out.println(m.size());
    }
}