Java 集合学习笔记：Map

已于 2022-11-18 17:44:02 修改
阅读量724 收藏 1
点赞数
分类专栏： # Java-集合 文章标签： java 学习 开发语言
于 2022-11-17 21:11:53 首次发布
大家好，我是笨笨，笨笨的笨，笨笨的笨，转载请注明出处，谢谢！
本文链接：https://blog.csdn.net/jx520/article/details/127834811
版权

Java 集合学习笔记：Map

UML

在这里插入图片描述

简介

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
.
此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。
.
Map 接口提供三种 collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。映射顺序 定义为迭代器在映射的 collection 视图上返回其元素的顺序。某些映射实现可明确保证其顺序，如 TreeMap 类；另一些映射实现则不保证顺序，如 HashMap 类。
.
注：将可变对象用作映射键时必须格外小心。当对象是映射中某个键时，如果以影响 equals 比较的方式更改了对象的值，则映射的行为将是不确定的。此项禁止的一种特殊情况是不允许某个映射将自身作为一个键包含。虽然允许某个映射将自身作为值包含，但请格外小心：在这样的映射上 equals 和 hashCode 方法的定义将不再是明确的。
.
所有通用的映射实现类应该提供两个“标准的”构造方法：一个 void（无参数）构造方法，用于创建空映射；一个是带有单个 Map 类型参数的构造方法，用于创建一个与其参数具有相同键-值映射关系的新映射。实际上，后一个构造方法允许用户复制任意映射，生成所需类的一个等价映射。尽管无法强制执行此建议（因为接口不能包含构造方法），但是 JDK 中所有通用的映射实现都遵从它。
.
此接口中包含的“破坏”方法可修改其操作的映射，如果此映射不支持该操作，这些方法将抛出 UnsupportedOperationException。如果是这样，那么在调用对映射无效时，这些方法可以（但不要求）抛出 UnsupportedOperationException。例如，如果某个不可修改的映射（其映射关系是“重叠”的）为空，则对该映射调用 putAll(Map) 方法时，可以（但不要求）抛出异常。
.
某些映射实现对可能包含的键和值有所限制。例如，某些实现禁止 null 键和值，另一些则对其键的类型有限制。尝试插入不合格的键或值将抛出一个未经检查的异常，通常是 NullPointerException 或 ClassCastException。试图查询是否存在不合格的键或值可能抛出异常，或者返回 false；某些实现将表现出前一种行为，而另一些则表现后一种。一般来说，试图对不合格的键或值执行操作且该操作的完成不会导致不合格的元素被插入映射中时，将可能抛出一个异常，也可能操作成功，这取决于实现本身。这样的异常在此接口的规范中标记为“可选”。
.
此接口是 Java Collections Framework 的成员。
.
Collections Framework 接口中的很多方法是根据 equals 方法定义的。例如，containsKey(Object key) 方法的规范中写道：“当且仅当此映射包含针对满足 (key==null ? k==null : key.equals(k)) 的键 k 的映射关系时，返回 true”。不 应将此规范解释为：调用具有非空参数 key 的 Map.containsKey 将导致对任意的键 k 调用 key.equals(k)。实现可随意进行优化，以避免调用 equals，例如，可首先比较两个键的哈希码（Object.hashCode() 规范保证哈希码不相等的两个对象不会相等）。一般来说，只要实现者认为合适，各种 Collections Framework 接口的实现可随意利用底层 Object 方法的指定行为。

源码阅读

嵌套类

interface Entry<K,V>

https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html
Map 中存放的是 Entry，Entry 中再存放 Key、Value
在这里插入图片描述

在 HashMap 中有实现 static class Node<K,V> implements Map.Entry<K,V> 详情看 HashMap 学习笔记。

静态方法

访问修饰符&返回类型方法描述
static <K extends Comparable<? super K>,V> Comparator<Map.Entry<K,V>>comparingByKey()返回一个比较器。按 key 升序排列 Map.Entry
static <K,V> Comparator<Map.Entry<K,V>>comparingByKey(Comparator<? super K> cmp)返回一个比较器，使用给定的 key 比较 Map.Entry。
static <K,V extends Comparable<? super V>> Comparator<Map.Entry<K,V>>comparingByValue()返回一个比较器。按 value 升序排列 Map.Entry
static <K,V> Comparator<Map.Entry<K,V>>comparingByValue(Comparator<? super V> cmp)返回一个比较器，使用给定的 value 比较 Map.Entry。
booleanequals(Object o)比较指定对象与此项的相等性。
KgetKey()返回与此项对应的键。
VgetValue()返回与此项对应的值。
inthashCode()返回此映射项的哈希码值。
VsetValue(V value)用指定的值替换与此项对应的值（可选操作）。

comparingByKey()

默认使用 key 按 自然升序 比较。返回的比较器，被强转为可序列化的。

public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
    return (Comparator<Map.Entry<K, V>> & Serializable)
        (c1, c2) -> c1.getKey().compareTo(c2.getKey());
}

comparingByKey(Comparator<? super K> cmp)

使用 key 按给定的比较规则 cmp 比较。返回的比较器，被强转为可序列化的。

public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
    Objects.requireNonNull(cmp);
    return (Comparator<Map.Entry<K, V>> & Serializable)
        (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
}

comparingByValue()

默认使用 vale 按 自然升序 比较。返回的比较器，被强转为可序列化的。

public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
    return (Comparator<Map.Entry<K, V>> & Serializable)
        (c1, c2) -> c1.getValue().compareTo(c2.getValue());
}

comparingByValue(Comparator<? super V> cmp)

使用 value 按给定的比较规则 cmp 比较。返回的比较器，被强转为可序列化的。

public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
    Objects.requireNonNull(cmp);
    return (Comparator<Map.Entry<K, V>> & Serializable)
        (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
}

比较器

Interface Comparable< T >

https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html

访问修饰符&返回类型方法描述
intcompareTo(T o)比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

默认方法

访问修饰符&返回类型方法描述
voidclear()从此映射中移除所有映射关系（可选操作）。
default Vcompute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)对给定 K 的值使用映射函数mappingFunction进行更新并返回新值。如果 新值 为 null，执行 remove(key) 并返回 null
defaultVcomputeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)如果值不存在或为null，使用 mappingFunction 的结果赋值，如果赋值成功，返回新值，否则返回 null 。（mappingFunction结果为 null 时直接返 null）
defaultVcomputeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)如果值存在且非null，使用 mappingFunction 计算新值。如果新值非null更新并返回新值，否则 remove(key) 并返回null。
booleancontainsKey(Object key)如果此映射包含指定键的映射关系，则返回 true。
booleancontainsValue(Object value)如果此映射将一个或多个键映射到指定值，则返回 true。
Set<Map.Entry<K,V>>entrySet()返回此映射中包含的映射关系的 Set 视图。
booleanequals(Object o)比较指定的对象与此映射是否相等。
default voidforEach(BiConsumer<? super K,? super V> action)两个入参的消费者，默认按 entrySet 顺序逐个消费。
Vget(Object key)返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
default VgetOrDefault(Object key, V defaultValue)如果 key 找不到映射的 value（null也算有）。则返回给定的默认值。
inthashCode()返回此映射的哈希码值。
booleanisEmpty()如果此映射未包含键-值映射关系，则返回 true。
SetkeySet()返回此映射中包含的键的 Set 视图。
default Vmerge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)值不存在或为null时用 value 赋值，否则用 mappingFunction 更新。如 mappingFunction 返回null等同于remove。
Vput(K key, V value)将指定的值与此映射中的指定键关联（可选操作）。
voidputAll(Map<? extends K,? extends V> m)从指定映射中将所有映射关系复制到此映射中（可选操作）。
default VputIfAbsent(K key, V value)如果值存在且非空执行 get(k)，否则执行put(k, v)并返回其结果。
Vremove(Object key)如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
default booleanremove(Object key, Object value)键、值都匹配则删除。
default Vreplace(K key, V value)有对应值就执行替换。
default booleanreplace(K key, V oldValue, V newValue)如果key确实映射到 oldValue 则替换值为newValue。
default voidreplaceAll(BiFunction<? super K,? super V,? extends V> function)调用给定函数BiFun，遍历替entry用BiFun返回值替换元素的值，直到完成所有或抛异常。
intsize()返回此映射中的键-值映射关系数。
Collectionvalues()返回此映射中包含的值的 Collection 视图。

Java8 开始引入了默认方法概念，允许向接口中添加默认实现。（用来兼容升级接口）
以下都默认方法。

compute(K key, BiFunction<K, V, V> fun)

  • test
    @Test
    public void computeTest(){
        Map<Object, Object> map = new WeakHashMap<>();
        map.put("a", 1);

        Object result = map.compute("a", (k, v) -> k + " : " + v);
        System.out.println("原值：" + result);          // 1
        System.out.println("更新后：" +map);            // {a=a : 1}

        result = map.compute("b", (k, v) -> null);
        System.out.println("原值：" + result);          //  null
        System.out.println("更新后：" +map);            // {a=a : 1}


        result = map.compute("a", (k, v) -> null);
        System.out.println("原值：" + result);          // null
        System.out.println("更新后：" +map);            // {}
    }
  • compute
    default V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    	// 检测给定的 lambda 方法 remappingFunction 如果为 null 就抛锅。
        Objects.requireNonNull(remappingFunction);
        // 先取出旧值缓存。
        V oldValue = get(key);
		// 对旧值应用给定的 lambda 方法算出新值
        V newValue = remappingFunction.apply(key, oldValue);
        // 如果新值为空，则移除原键值对，返回 null
        // 否则新值不为空，则：用新值替换旧值，并返回新值。
        if (newValue == null) {
        	// 新值为空则，返回 null
        	// 但如果原 key 或 value 存在，则需要先删除原键值对，再返回 null
            if (oldValue != null || containsKey(key)) { 
                remove(key);
                return null;
            } else { 
                return null;
            }
        } else {
            put(key, newValue);
            return newValue;
        }
    }

按理说，新值是否为 null 触发删除逻辑这段不是应该过样写么

		// 不为空，替换，并返回新值
        if (newValue != null) {
            put(key, newValue);
            return newValue;
        }
        // 否则新值为空，key存在或旧值不为空，执行删除。
        if (oldValue != null || containsKey(key)) { 
            remove(key);
        } 
        // 最后返回 null
        return null;

computeIfAbsent(K key, Function<K, V> fun)

    @Test
    public void computeIfAbsentTest() {
        Map<Object, Object> map = new WeakHashMap<>();
        map.put("a", 1);

        Object a = map.computeIfAbsent("a", key -> DateUtil.today());
        Object b = map.computeIfAbsent("b", key -> DateUtil.today());
        Object c = map.computeIfAbsent("c", key -> null);

        System.out.println(a);   // 1
        System.out.println(b);   // 2022-11-16
        System.out.println(c);   // null
        System.out.println(map); // {a=1, b=2022-11-16}
    }
  • computeIfAbsent
    default V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
        // 检测给定的 lambda 方法 remappingFunction 如果为 null 就抛锅。
        Objects.requireNonNull(mappingFunction);
        // 声明返回变量
        V v;
        // 获取 key 对应的值，如果值存在，直接返回
        // 否则 mappingFunction 生成一个新值填充。并返回新值
        // 如果生成的也是 null 直接返回 null
        if ((v = get(key)) == null) {
            V newValue;
            if ((newValue = mappingFunction.apply(key)) != null) {
                put(key, newValue);
                return newValue;
            }
        }

        return v;
    }

computeIfPresent(K key, BiFunction<K, V, V> fun)

  • test
    @Test
    public void computeIfPresentTest(){
        Map<String, Integer> map = new WeakHashMap<>();
        map.put("a", 1);
        map.put("b", null);

        // 值不为空，替换新值
        Integer result = map.computeIfPresent("a", (k, v) -> 2 );
        System.out.println("原值：" + result);          //  2
        System.out.println("更新后：" +map);            // {a=2, b=null}

        // 值为 null，啥也不做，直接返回 null
        result = map.computeIfPresent("b", (k, v) -> 666 );
        System.out.println("原值：" + result);          //  null
        System.out.println("更新后：" +map);            // {a=2, b=null}

        // 按 key 找到值，执行 lambda 得到新值为空，移除键值对
        result = map.computeIfPresent("a", (k, v) -> null );
        System.out.println("原值：" + result);          //  null
        System.out.println("更新后：" +map);            // {b=null}
    }
  • computeIfPresent
    default V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    	// 非空检测，如果为 null 就抛锅。
        Objects.requireNonNull(remappingFunction);
        // 声明临时变量用于存放旧值
        V oldValue;
        // 按 key 获取对应值，并付给 oldValue，如果为空直接返回 null
        // 否则使用给定的 remappingFunction 处理原键值对，得出新值 newValue 
        // 新值不为空：调用 put 修改为 newValue。并返回 newValue
        // 否则移除 键值对。返回 null
        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;
        }
    }

forEach(BiConsumer<K, V> action)

  • test
    @Test
    public void forEachTest(){
        Map<String, Integer> map = new WeakHashMap<>();
        map.put("a", 1);
        map.put("b", 2);
        map.forEach((k,v) -> {
            System.out.println( "键="+ k + "; 值=" + v);
        });
    }
  • forEach
	default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        // 遍历 map 中的 键值对。
        // 通过 entrySet() 拿到一个 Set<Entry>，set 的每个 Entry 元素就是一个键值对
        // 从 Entry 中分别取出键和值，使用 lambda 函数 action 消费 k, v
        for (Map.Entry<K, V> 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);
        }
    }

getOrDefault(Object key, V defaultValue)

  • test
    @Test
    public void getOrDefaultTest(){
        Map<Object, Object> map = new WeakHashMap<>();
        map.put("a", 1);
        map.put("b", null);
        System.out.println(map.getOrDefault("a", "默认值1")); // 1
        System.out.println(map.getOrDefault("b", "默认值2")); // null
        System.out.println(map.getOrDefault("c", "默认值3")); // 默认值3
    }
  • getOrDefault
	default V getOrDefault(Object key, V defaultValue) {
        V v;
        // 取到值就返回（哪怕是 null 也行）
        // 如果没取到，就返回给定的默认值 defaultValue
        return (((v = get(key)) != null) || containsKey(key)) ? v : defaultValue;
        // 值为 null 有两种情况：
        // key 对应的值确实是 null
        // key 不存在。
    }

拆解 (((v = get(key)) != null) || containsKey(key)) ? v : defaultValue;

V v = get(key);
if(v != null) || containsKey(key)){
	return v;
}else{
	return defaultValue;
}

merge(K key, V value, BiFunction<V, V, V> fun)

  • test
    @Test
    public void mergeTest(){
        Map<Object, Object> map = new WeakHashMap<>();
        map.put("a", 1);
        map.put("b", null);
        System.out.println(map.merge("a", 10, (k,v) -> "更新")); // 更新
        System.out.println(map.merge("b", 22, (k,v) -> "xxxx")); // 22
        System.out.println(map.merge("x", 99, (k,v) -> "xxxx")); // 99
        System.out.println(map);    // {x=99, a=更新, b=22}
    }
  • merge
	default V merge(K key,
					V value,
            		BiFunction<? super V, ? super V, ? extends V> remappingFunction
    ) {
    	// 非空检测，如果为 null 就抛锅。
        Objects.requireNonNull(remappingFunction);
        Objects.requireNonNull(value);
        // 取出原值临时保存在 oldValue
        // 计算新值 newValue
        // oldValue 为空使用传进来的给定什 value
        // 否则使用 remappingFunction 计算新值。
        V oldValue = get(key);
        V newValue = (oldValue == null) ? value : remappingFunction.apply(oldValue, value);
        // 新值为空执行 remove(key); 否则执行 put(key, newValue);
        if(newValue == null) {
            remove(key);
        } else {
            put(key, newValue);
        }
        // 最后返回新值
        return newValue;
    }

putIfAbsent(K key, V value)

  • test
    @Test
    public void putIfAbsentTest(){
        Map<Object, Object> map = new WeakHashMap<>();
        map.put("a", 1);
        map.put("b", null);
        System.out.println(map.putIfAbsent("a", 10)); // 1
        System.out.println(map.putIfAbsent("b", 20)); // null
        System.out.println(map.putIfAbsent("c", 20)); // null
        System.out.println(map);                      // {a=1, c=20, b=20}
    }
  • putIfAbsent
	default V putIfAbsent(K key, V value) {
		// 取值，如果非 null 直接返回。
		// 否则执行 put 并返回其结果。
        V v = get(key);
        if (v == null) {
            v = put(key, value);
        }
        return v;
    }

remove(Object key, Object value)

  • test
    @Test
    public void removeTest(){
        Map<Object, Object> map = new WeakHashMap<>();
        map.put("a", 1);
        map.put("b", null);
        System.out.println(map.remove("a", 10));    // false
        System.out.println(map);                    // {a=1, b=null}
        System.out.println(map.remove("a", 1));     // true
        System.out.println(map);                    // {b=null}
        System.out.println(map.remove("b", 20));    // false
        System.out.println(map);                    // {b=null}
        System.out.println(map.remove("b", null));  // true
        System.out.println(map);                    // {}
    }
  • remove
	default boolean remove(Object key, Object value) {
		// 获取当前值
        Object curValue = get(key);
        // 如果当前值与给定值不相等，直接返回 false
        // 或者如果当前值为 null 并且当前 map 中不存在 key ，直接返回 false
        if (!Objects.equals(curValue, value)
         	|| (curValue == null && !containsKey(key))) 
        {           
        	return false;
        }
        // 移除
        remove(key);
        return true;
    }

尝试改写，更符合语义。官方的写法尽量避免 containsKey 是为了提升效率。

	default boolean remove(Object key, Object value) {
        if (containsKey(key) && Objects.equals(get(key), value)) {     
        	remove(key);      
        	return true;
        }       
        return false;
    }

replace(K key, V value)

  • test
    @Test
    public void replaceTest() {
        Map<Object, Object> map = new WeakHashMap<>();
        map.put("a", 1);
        map.put("b", null);
        
        Object a = map.replace("a", 11);
        System.out.println(a);          // 1
        System.out.println(map);        // {a=11, b=null}
        
        Object b = map.replace("b", 2);
        System.out.println(b);          // null
        System.out.println(map);        // {a=11, b=2}
        
        Object c = map.replace("c", 3);
        System.out.println(c);          // null
        System.out.println(map);        // {a=11, b=2}
    }
  • replace(K key, V value)
	default V replace(K key, V value) {
        V curValue; //  null
        // 取出当前值，如果非空或者 key 存在，执行 put 并返回结果
         if (((curValue = get(key)) != null) || containsKey(key)) {
            curValue = put(key, value);
        }
        // 否则直接返回
        return curValue;
    }

replace(K key, V oldValue, V newValue)

  • test
@Test
    public void replace3Test() {
        Map<Object, Object> map = new WeakHashMap<>();
        map.put("a", 1);
        map.put("b", null);

        Object a = map.replace("a", 2, 11);
        System.out.println(a);          // false
        System.out.println(map);        // {a=1, b=null}

        a = map.replace("a", 1, 111);
        System.out.println(a);          // true
        System.out.println(map);        // {a=111, b=null}
        
        Object b = map.replace("b", 2, 22);
        System.out.println(b);          // false
        System.out.println(map);        // {a=111, b=null}       
        
        b = map.replace("b", null, 222);
        System.out.println(b);          // true
        System.out.println(map);        // {a=111, b=222}

        Object c = map.replace("c", null, 333);
        System.out.println(c);          // false
        System.out.println(map);        // {a=111, b=222}
    }
  • boolean replace(K key, V oldValue, V newValue)
	default boolean replace(K key, V oldValue, V newValue) {
		// 取出当前值
        Object curValue = get(key);
        // 如果当前值与给定的 oldValue 不同，直接返回 false
        // 或者当前值为空且key不存在，直接返回 false
        if (!Objects.equals(curValue, oldValue) || (curValue == null && !containsKey(key))) {
            return false;
        }
        // 否则更新为 newValue
        put(key, newValue);
        return true;
    }

尝试改写，更符合语义。官方的写法尽量避免 containsKey 是为了提升效率。

	default boolean replace(K key, V oldValue, V newValue) {
        if (containsKey(key) && Objects.equals(get(key), oldValue)) {
            put(key, newValue);
        	return true;
        }
        return false;
    }

replaceAll(BiFunction<K, V, V> function)

  • test
    @Test
    public void replaceAllTest() {
        Map<String, Integer> map = new WeakHashMap<>();
        map.put("a", 1);
        map.put("b", 2);
        map.replaceAll((k,v) -> v * 10 );
        System.out.println(map);    // {a=10, b=20}
    }
  • replaceAll
	default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
		// 非空检测，如果为 null 就抛锅。
        Objects.requireNonNull(function);
        // 遍历所有键值对，并更新值
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // 取不到 k 或 v 说明可能被别人动了。抛锅。
                throw new ConcurrentModificationException(ise);
            }
			// 执行映射函数并获得结果
            v = function.apply(k, v);

            try {
                entry.setValue(v);
            } catch(IllegalStateException ise) {
                // entry 不存了在，抛锅
                throw new ConcurrentModificationException(ise);
            }
        }
    }

参考资料

Interface Map<K,V>
Interface Map.Entry<K,V>
Class WeakHashMap<K,V>

笑虾
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java集合（完整笔记）
05-14
作者在学习过程中自己整理的Java集合笔记，包括开发中常见的单列集合（Collection）和双列集合（Map）以及开发中集合常用的接口，类，以及方法等，适合零基础小白，笔记详细，希望和大家一起学习的道路上我们可以...
java内部学习笔记.docx
02-18
4.21 Map集合的实现类HashMap 46 4.22单例模式和模版方法模式 48 Java SE核心II 49 5.1 Java异常处理机制 49 5.2 File文件类 51 5.3 RandomAccessFile类 53 5.4基本流：FIS和FOS 55 5.5缓冲字节高级流：BIS和BOS 56 ...
JAVA集合 Map接口 简介
程序猿-Jojo
12-31 417
文章目录[一] 简述:[二] Map 接口:[三] 具体实现 注释和代码来自 JDK 1.6 [一] 简述: public interface Map&amp;lt;K,V&amp;gt;将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。 Map 接口提供三种collection 视图，允许以键集、值集或键-...
stream流对map的key和value进行排序（支持字符串）
m0_46360888的博客
04-19 2831
stream
hashMap如何按照value排序
qq_30093131的博客
05-24 4109
1、hashMap和treeMap比较 简单来说，hashMap为无序，通过数组+链表+红黑树实现。treeMap由于实现了sortedMap接口，默认按照key进行排序。 2、应用场景 某些特殊情况下，我们需要对map的value值进行排序输出，Map.Entry.comparingByValue()中已经为我们实现了按照值排序，实现代码如下： HashMap<String, String> map = new HashMap<String, String&g...
java中Map根据key排序，根据value排序
魑魅魍魉
08-18 4093
java中Map根据key排序，根据value排序，使用EntryMap
map根据键值排序
啊谋的博客
02-11 690
Map<String, Double> content = new HashMap<>(); //根据map的值排序 content.entrySet().stream().sorted(Map.Entry.comparingByValue()).forEach(single -> { content.put(single.getKey(), single.getValue()); });
亚信java笔试题-study:学习笔记
06-03
学习笔记 戏剧性教育 自适应 vue官网地址： vue学习笔记地址： 生命周期 ajax、 vue实例的属性和方法 自定义指令 过度动画 组件 es6学习笔记地址： let const 变量的解构赋值 symbol set weakset map Iterator ...
java学习笔记
12-02
java学习必看，适合初学者辅助学习。集合中常用的是：ArrayList，HashSet，HashMap。其中ArrayList和HashMap使用最为广泛。 使用HashMap，put()表示放置元素，get()表示取元素。 遍历Map，使用keySet()可以返回set...
JDK8 新特性-Map对key和value分别排序实现
qq_40603010的博客
02-04 1188
在Java 8 中使用Stream 例子对一个 Map 进行按照keys或者values排序. 快速入门 在java 8中按照此步骤对map进行排序. 将 Map 转换为 Stream 对其进行排序 Collect and return a new LinkedHashMap (保持顺序) Map result = map.entrySet().stream() .sorted(Map.Entry.comparingByKey()) .collect(Collectors.toMap(Map.Ent
Stream流实现 map 以 value 值排序
m0_69237510的博客
04-03 2403
Stream流实现map按照value排序的几种写法。。
Java Map按值排序的正确姿势
热门推荐
明明如月的技术博客
03-23 3万+
在实际业务开发中，可能会遇到Java Map按值排序的需要。 Java Map按值排序的常见思路是： 1、 将map中的entry放到List中 2、 对List中的entry通过比较器按值排序 3 、将排序后的entry放到linkedhashmap中 Java 8利用Stream import java.util.Collections; import java.ut...
Map按值的升序或降序排序最简单的方法
yf.z的专栏
07-05 4485
使用jdk8的新特性private List&lt;Map.Entry&lt;String, Integer&gt;&gt; sortMap(Map&lt;String, Integer&gt; map, boolean asc) { Stream&lt;Map.Entry&lt;String, Integer&gt;&gt; stream = null; if (asc) { ...
Map基本操作
zhanghe687的博客
04-29 587
//Map按照value 倒序 LinkedHashMap<Integer, Integer> sortedMap = support_level_map.entrySet().stream() .sorted(Collections.reverseOrder(Map.Entry.comparingByValue())) .collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue(), .
java map的存储结构_Java中Map存储结构根据值排序(sort by values)
weixin_35711852的博客
03-06 835
需求：Map中可以根据key， value 进行排序，由于 key 都是唯一的，可以很方便的进行比较操作，但是每个key 对应的value不是唯一的，有可能出现多个 相同的value对应key 是不一样的，所以需要采用不一样的方式。详解：Map 的目的是用来快速访问的存储结构。通用的方法：import java.util.ArrayList;import java.util.LinkedHashM...
Stream排序Map集合
李佳航的博客
03-11 1万+
前置知识: Lamdba表达式 StreamApi map根据value倒序排序 map.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).forEach(System.out::println); map根据key倒序排序 map.entryS...
对map的value排序
weixin_57463074的博客
10-10 316
对map的value排序
关于map按值排序
汪汪汪汪吁的博客
06-23 285
java版本1.8之前可以使用这个，利用list存储map，然后利用map.entry中自带的比较器比较。最后存入LinkedHashMap public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) { List<Map.Entry<K, V>> list = new ArrayList<>(ma
java ml介绍_Java学习笔记一：数据类型I
最新发布
06-09
Java是一种面向对象的编程语言，广泛应用于各种应用程序的开发，包括机器学习。在Java中，数据类型是程序设计的基本构建块之一。Java中的数据类型可以分为两类：基本数据类型和引用数据类型。 Java的基本数据类型包括：byte、short、int、long、float、double、char和boolean。这些数据类型是原始的、简单的数据类型，可以直接在内存中存储和操作。 Java的引用数据类型包括：类、接口、数组和枚举。这些数据类型是由程序员定义的，它们的实例在内存中是以引用的形式存储的。 在机器学习中，Java通常被用于开发和部署机器学习模型，尤其是在企业级应用中。Java的机器学习库包括Weka、Mahout和DeepLearning4j等。这些库提供了各种机器学习算法和工具，使得Java成为一个非常有用的机器学习平台。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

笑虾

多情黯叹痴情癫。情癫苦笑多情难

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值