「Java」咦，它就是Map和List的儿子吧

经常遇到的一个场景，将map放进list中，同时又会经常频繁操作这个list里的map，鉴于这种情况，就偷懒写了个MapList，里面都是些自己常用的方法，来个抛砖引玉，让大家指导下，还有什么可以改进下，又或者有什么方法可以替代这种方式。

以下就是代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MapList<K, V> extends ArrayList<Map<K, V>> {
    private final int DEFAULT_CAPACITY = 16;

    /**
     * 键类型class
     */
    private final Class<K> keyClass;
    /**
     * 值类型class
     */
    private final Class<V> valueClass;
    
    private MapList(Class<K> keyClass, Class<V> valueClass){
        this.keyClass = keyClass;
        this.valueClass = valueClass;
    }
    
    /**
     * 新建键值对集合
     * @param keyClass    键类型class
     * @param valueClass  值类型class
     * @param <K>       键类型
     * @param <V>       值类型
     * @return  键值对Map集合
     */
    public static <K,V> MapList<K, V> newMapList(Class<K> keyClass, Class<V> valueClass){
        return new MapList<>(keyClass, valueClass);
    }
    
    /**
     * 新建键值对集合
     * @param maps        键值对容器数组
     * @param keyClass    键类型class
     * @param valueClass  值类型class
     * @param <K>         键类型
     * @param <V>         值类型
     * @return  键值对Map集合
     */
    public static <K,V> MapList<K, V> newMapList(Map<K, V>[] maps, Class<K> keyClass, Class<V> valueClass){
        List<Map<K, V>> list = Arrays.asList(maps);
        return newMapList(list, keyClass, valueClass);
    }
    
    /**
     * 新建键值对集合
     * @param keyClass      键类型class
     * @param valueClass    值类型class
     * @param list          键值对Map集合
     * @param <K>           键类型
     * @param <V>           值类型
     * @return  键值对Map集合
     */
    public static <K,V> MapList<K, V> newMapList(List<Map<K, V>> list, Class<K> keyClass, Class<V> valueClass){
        MapList<K, V> mapList = new MapList<>(keyClass, valueClass);
        mapList.addAll(list);
        return mapList;
    }
    
    /**
     * 获取最后一个Map的值
     * @param key   键
     * @return  值
     */
    public V get(K key){
        return getLastMap().get(key);
    }
    
    /**
     * 获取指定Map的值
     * @param index 下标
     * @param key   键
     * @return  值
     */
    public V get(int index, K key){
        return get(index).get(key);
    }
    
    /**
     * 新增多个键值对
     * @param keyValues 键值二维数组
     * @return  返回添加的map
     */
    public Map<K, V> put(Object[]... keyValues){
        Object key,value;
        Map<K, V> map = null;
        int i = 0;
        for(Object[] keyValue : keyValues){
            key = keyValue[0];
            value = keyValue[1];
    
            if(i == 0) {
                map = putNew(keyClass.cast(key), valueClass.cast(value));
            }else{
                map = put(keyClass.cast(key), valueClass.cast(value));
            }
            i++;
        }
        return map;
    }
    
    /**
     * 新增一个键值对
     * @param key   键
     * @param value 值
     * @return      返回添加的键值对容器
     */
    public Map<K, V> put(K key, V value){
        Map<K, V> map = getLastMap();
        map.put(key, value);
        return map;
    }
    
    /**
     * 新增一个new新的map，且添加值key-value
     * @param key   key
     * @param value value
     * @return  新增的map
     */
    public Map<K, V> putNew(K key, V value){
        Map<K, V> map = getNewMap();
        map.put(key, value);
        return map;
    
    }
    
    /**
     * 新增一个键值对
     * @param index 键
     * @param key   键
     * @param value 值
     * @return  返回添加的键值对容器
     */
    public Map<K, V> put(int index, K key, V value){
        Map<K, V> map = get(index);
        map.put(key, value);
        return map;
    }
    
    /**
     * 与另一个mapList比较
     * @param mapList   另一个mapList
     * @return  相等返回true，不想等返回false
     */
    public boolean equals(MapList<K, V> mapList){
        if(mapList == null){
            return false;
        }
        if(this == mapList){
            return true;
        }
        int size = size();
        if(size != mapList.size()){
            return false;
        }
    
        for(int i = 0; i < size; i++){
            if(!isSameMap(get(i), mapList.get(i))){
                return false;
            }
        }
    
        return true;
    }
    
    /**
     * 获取包含某个key的列表
     * @param key   key
     * @return  列表
     */
    public List<Map<K, V>> getContainKeyList(K key){
        return stream().filter(map -> map.containsKey(key)).collect(Collectors.toList());
    }
    
    /**
     * 获取包含某个key的列表
     * @param key   key
     * @return  列表
     */
    public MapList<K, V> getContainKeyMapList(K key){
        return newMapList(getContainKeyList(key), keyClass, valueClass);
    }
    
    /**
     * 校验两个map是否相等
     * @param map           第一个map
     * @param anotherMap    第二个map
     * @return  相等返回true，不想等返回false
     */
    private boolean isSameMap(Map<K, V> map, Map<K, V> anotherMap){
        if(isNotSameObject(map, anotherMap)){
            return false;
        }
        if(map.size() != anotherMap.size()){
            return false;
        }
    
        K key;
        V value, anotherValue;
        for(Map.Entry<K, V> entry: map.entrySet()){
            key = entry.getKey();
            if(!anotherMap.containsKey(key)){
                return false;
            }
            value = entry.getValue();
            anotherValue = anotherMap.get(key);
    
            if(isNotSameObject(value, anotherValue)){
                return false;
            }
        }
        return true;
    }
    
    /**
     * 校验两个Object是否相等
     * @param object        第一个object
     * @param anotherObject 第二个object
     * @return  相等返回true，不想等返回false
     */
    private boolean isNotSameObject(Object object, Object anotherObject){
        if(object == anotherObject){
            return false;
        }
        if(object != null && anotherObject == null){
            return true;
        }
        if(object == null){
            return true;
        }
        return !object.equals(anotherObject);
    }
    
    /**
     * 获取最后一个Map
     * @return  最后一个map
     */
    private Map<K,V> getLastMap(){
        if(isEmpty()){
            add(new HashMap<>(DEFAULT_CAPACITY));
        }
        int size = size();
    
        return get(size -1);
    }
    
    /**
     * 获取一个新的Map
     * @return  新的Map
     */
    private Map<K,V> getNewMap(){
        Map<K, V> map = new HashMap<>(DEFAULT_CAPACITY);
        add(map);
    
        return map;
    }
}