Unterschiede zwischen den Methoden „getOrDefault“, „putIfAbsent“, „computeIfAbsent“ und „merge“ von Map in JDK1.8

1. getOrDefault

1. Beschreibung

getOrDefault: Gibt nur den Wert zurück. Wenn er nicht vorhanden ist, wird der angegebene Standardwert zurückgegeben und die Kartenstruktur nicht geändert.

2. Quellcode

    default V getOrDefault(Object key, V defaultValue) {
    
    
        V v;
        //如果key对应得value不为空，或者Map包含了key，则取得value得值，否则得到默认值。
        return (((v = get(key)) != null) || containsKey(key))
            ? v
            : defaultValue;
    }

3. Codebeispiele

public class Demo1 {
    
    
    public static void main(String[] args) {
    
    
        Map<String, String> map = new HashMap<>();
        map.put("name", "lxj");
        map.put("age", "24");
        map.put("sex", "女");
        String name = map.getOrDefault("name", "test");
        System.out.println(name);// lxj，map中存在name,获得name对应的value
        String address = map.getOrDefault("address", "北京");
        System.out.println(address);// 北京，map中不存在address,使用默认值“北京”
    }
}

2. putIfAbsent

1. Beschreibung

putIfAbsent fügt ein Schlüssel-Wert-Paar hinzu. Wenn in der Kartensammlung kein Wert vorhanden ist, der dem Schlüssel entspricht, wird er direkt hinzugefügt. Wenn der entsprechende Wert bereits vorhanden ist, bleibt er der ursprüngliche Wert.

Im Vergleich zu put:
put fügt ein Schlüssel-Wert-Paar hinzu. Wenn in der Kartensammlung kein Wert vorhanden ist, der dem Schlüssel entspricht, wird er direkt hinzugefügt. Wenn der entsprechende Wert bereits vorhanden ist, wird der alte Wert überschrieben.

2. Quellcode

    default V putIfAbsent(K key, V value) {
    
    
        V v = get(key);
        //如果键为空，则添加
        if (v == null) {
    
    
            v = put(key, value);
        }
        //否则跳过该值不处理
        return v;
    }

3. Codebeispiele

    public static void main(String[] args) {
    
    
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1,"tcc");
        map.putIfAbsent(2,"tcc2");
        System.out.println(map);
        //key为1存在，不会覆盖value值
        map.putIfAbsent(1,"tccIf");
        System.out.println(map);
        //key为1存在，会覆盖value值
        map.put(1,"tccPut");
        System.out.println(map);
    }

Die Ausgabe ist wie folgt:

    {
    
    1=tcc, 2=tcc2}
    {
    
    1=tcc, 2=tcc2}
    {
    
    1=tccPut, 2=tcc2}

3. Berechnen Sie IfAbsent

1. Beschreibung

Die Funktionen von computeIfAbsent und putIfAbsent sind grundsätzlich ähnlich, die Unterschiede sind:

Wenn der übergebene Wert null ist, führt „computeIfAbsent“ keinen Put-Vorgang aus, aber „putIfAbsent“ führt einen Put-Vorgang aus.
Die Parameter des Werts sind unterschiedlich. Die Methode „computeIfAbsent“ stellt die Funktion zur Wertberechnung bereit. Wenn die Berechnung des Werts Zeit in Anspruch nimmt, können Sie „computeIfAbsent“ verwenden, um Zeit zu sparen.

2. Quellcode

    default V computeIfAbsent(K key,
            Function<? super K, ? extends V> mappingFunction) {
    
    
        Objects.requireNonNull(mappingFunction);
        V v;
        //如果key对应得value为空
        if ((v = get(key)) == null) {
    
    
            V newValue;
            //如果传入的value不为空则put
            if ((newValue = mappingFunction.apply(key)) != null) {
    
    
                put(key, newValue);
                return newValue;
            }
        }

        return v;
    }

3. Codebeispiele

    public static void main(String[] args) {
    
    
        HashMap<Integer, String> map = new HashMap<>();
        map.computeIfAbsent(1, v -> "tcc");
        //key存在，不会覆盖
        map.computeIfAbsent(1, v -> "tccIf");
        System.out.println(map);
        //value为空，不会put
        map.computeIfAbsent(2, v -> null);
        System.out.println(map);
    }

Die Laufergebnisse sind wie folgt:

    {
    
    1=tcc}
    {
    
    1=tcc}

4. zusammenführen

1. Beschreibung

Durch Zusammenführen wird ein Schlüssel-Wert-Paar hinzugefügt. Wenn der dem Schlüssel entsprechende Wert nicht vorhanden ist, wird der Wert direkt gespeichert. Wenn der Wert vorhanden ist, wird der Wert aktualisiert. Wir können die Aktualisierungsregeln anpassen.

Überschreiben Sie den alten Wert mit dem neuen Wert: (Wert1, Wert2) -> Wert2
behält den alten Wert: (Wert1, Wert2) -> Wert1
speichert den neuen Wert+alten Wert, zum Beispiel: (Wert1, Wert2) -> Wert1+Wert2

2. Quellcode

	//BiFunction函数式接口，提供apply方法
    default V merge(K key, V value,
            BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
    
    
        Objects.requireNonNull(remappingFunction);
        Objects.requireNonNull(value);
        V oldValue = get(key);
        //经过函数修改后的value
        V newValue = (oldValue == null) ? value :
                   remappingFunction.apply(oldValue, value);
        //计算出来的value为空，删除这个key
        if(newValue == null) {
    
    
            remove(key);
        } else {
    
    
        //存入修改后的value
            put(key, newValue);
        }
        return newValue;
    }

3. Codebeispiele

    public static void main(String[] args) {
    
    
        HashMap<Integer, Integer> map = new HashMap<>();
        map.put(1,10);
        map.put(1,20);
        map.merge(1,50,(v1,v2)->v1+v2);
        map.merge(2,100,(v1,v2)->v2);
        System.out.println(map);

    }

Operationsergebnis:

  {
    
    1=70, 2=100}