Java集合之Map的示例代码详解

Map架构：

如上图：

（1）Map是映射接口，Map中存储的内容是键值对（key-value）

（2）AbstractMap是继承于Map的抽象类，实现了Map中的大部分API。

（3）SortedMap是继承于Map的接口，SortedMap中的内容是排序的键值对，排序的方法是通过比较器。

（4）NavigableMap继承于SortedMap，其中有一系列的导航方法，如“获取大于或等于某对象的键值对”等等

（5）TreeMap继承于AbstractMap和NavigableMap接口，因此TreeMap中的内容是有序的键值对。

（6）HashMap继承于AbstractMap，内容也是键值对，但不保证次序。

（7）WeakHashMap继承于AbstractMap，它和HashMap的键类型不同，WeakHashMap是弱键。

（8）HashTable继承于Directionary同时也实现了Map,因此是键值对的，但不保证次序，同时是线程安全的。

总结：

HashMap是基于”拉链法“实现的散列表，一般用于单线程，键值都可以为空，支持Iterator（迭代器）遍历

Hashtable是基于”拉链法“实现的散列表，是线程安全的，可以用于多线程程序中。支持Iterator（迭代器）遍历和Enumeration（枚举器）两种遍历方式。

WeakHashMap也是基于”拉链法“实现的散列表，同时是弱键

TreeMap 是有序的散列表，通过红黑树来实现的，键值都不能为空。

Java8的Map接口的源码：

public interface map {
    int size();//数目
    boolean isempty();//判断是否为空
    boolean containskey(object key);//判断是否含有某个key
    boolean containsvalue(object value);//判断是否含有某个值
    v get(object key);//通过key获得value
    v put(k key, v value);//插入键值对
    v remove(object key);//通过key删除
    void putall(mapextends k, ? extends v> m);//将一个map插入
    void clear();//清空
    set keyset();//返回key集合
    collection values();//返回value
    set> entryset();//实体集合，map的改变会影响到它
    interface entry {
        k getkey();//获得key
        v getvalue();//获得value
        v setvalue(v value);//设置值
        boolean equals(object o);//判断对象是否相等
        int hashcode();//返回hashcode
        //比较器，比较两个key
        public static super k>, v> comparator> comparingbykey() {
            return (comparator> & serializable)
                    (c1, c2) -> c1.getkey().compareto(c2.getkey());
        }
        //比较两个值
        public static > comparator> comparingbyvalue() {
            return (comparator> & serializable)
                    (c1, c2) -> c1.getvalue().compareto(c2.getvalue());
        }
        //比较两个key
        public static  comparator> comparingbykey(comparator cmp) {
            objects.requirenonnull(cmp);
            return (comparator> & serializable)
                    (c1, c2) -> cmp.compare(c1.getkey(), c2.getkey());
        }
        //比较两个值
        public static  comparator> comparingbyvalue(comparator cmp) {
            objects.requirenonnull(cmp);
            return (comparator> & serializable)
                    (c1, c2) -> cmp.compare(c1.getvalue(), c2.getvalue());
        }
    }
    //比较map是否相等
    boolean equals(object o);
    int hashcode();//hashcode
    default v getordefault(object key, v defaultvalue) {
        v v;
        return (((v = get(key)) != null) || containskey(key))
                ? v
                : defaultvalue;
    }
    default void foreach(biconsumer action) {
        objects.requirenonnull(action);
        for (map.entry entry : entryset()) {
            k k;
            v v;
            try {
                k = entry.getkey();
                v = entry.getvalue();
            } catch(illegalstateexception ise) {
                // this usually means the entry is no longer in the map.
                throw new concurrentmodificationexception(ise);
            }
            action.accept(k, v);
        }
    }
    default void replaceall(bifunction function) {
        objects.requirenonnull(function);
        for (map.entry entry : entryset()) {
            k k;
            v v;
            try {
                k = entry.getkey();
                v = entry.getvalue();
            } catch(illegalstateexception ise) {
                // this usually means the entry is no longer in the map.
                throw new concurrentmodificationexception(ise);
            }

            // ise thrown from function is not a cme.
            v = function.apply(k, v);

            try {
                entry.setvalue(v);
            } catch(illegalstateexception ise) {
                // this usually means the entry is no longer in the map.
                throw new concurrentmodificationexception(ise);
            }
        }
    }
    default v putifabsent(k key, v value) {
        v v = get(key);
        if (v == null) {
            v = put(key, value);
        }

        return v;
    }
    //删除某个key和value对应的对象
    default boolean remove(object key, object value) {
        object curvalue = get(key);
        if (!objects.equals(curvalue, value) ||
                (curvalue == null && !containskey(key))) {
            return false;
        }
        remove(key);
        return true;
    }
    //将某个key和oldvalue对应的值替换为newvalue
    default boolean replace(k key, v oldvalue, v newvalue) {
        object curvalue = get(key);
        if (!objects.equals(curvalue, oldvalue) ||
                (curvalue == null && !containskey(key))) {
            return false;
        }
        put(key, newvalue);
        return true;
    }
    //替换key的值
    default v replace(k key, v value) {
        v curvalue;
        if (((curvalue = get(key)) != null) || containskey(key)) {
            curvalue = put(key, value);
        }
        return curvalue;
    }
    default v computeifabsent(k key,
                              function mappingfunction) {
        objects.requirenonnull(mappingfunction);
        v v;
        if ((v = get(key)) == null) {
            v newvalue;
            if ((newvalue = mappingfunction.apply(key)) != null) {
                put(key, newvalue);
                return newvalue;
            }
        }

        return v;
    }
    default v computeifpresent(k key,
                               bifunction remappingfunction) {
        objects.requirenonnull(remappingfunction);
        v oldvalue;
        if ((oldvalue = get(key)) != null) {
            v newvalue = remappingfunction.apply(key, oldvalue);
            if (newvalue != null) {
                put(key, newvalue);
                return newvalue;
            } else {
                remove(key);
                return null;
            }
        } else {
            return null;
        }
    }
    default v compute(k key,
                      bifunction remappingfunction) {
        objects.requirenonnull(remappingfunction);
        v oldvalue = get(key);

        v newvalue = remappingfunction.apply(key, oldvalue);
        if (newvalue == null) {
            // delete mapping
            if (oldvalue != null || containskey(key)) {
                // something to remove
                remove(key);
                return null;
            } else {
                // nothing to do. leave things as they were.
                return null;
            }
        } else {
            // add or replace old mapping
            put(key, newvalue);
            return newvalue;
        }
    }
    default v merge(k key, v value,
                    bifunction remappingfunction) {
        objects.requirenonnull(remappingfunction);
        objects.requirenonnull(value);
        v oldvalue = get(key);
        v newvalue = (oldvalue == null) ? value :
                remappingfunction.apply(oldvalue, value);
        if(newvalue == null) {
            remove(key);
        } else {
            put(key, newvalue);
        }
        return newvalue;
    }
}

							

								
								

									可赞AI
									
文字一秒可视化，免费AI办公神器
								
								下载