codestory

Die Anleitung zu Java Map

Folge uns auf unserer fanpage, um jedes Mal benachrichtigt zu werden, wenn es neue Artikel gibt. Facebook

1- Map

In Java, ist Map eine Interface, die ein Objekt vertritt, das die Mappings zwischen Schlüsseln (key) und Werten (value) enthält. Jeder Schlüssel entspricht einem Wert. Eines der typischen Beispiele, die hier erwähnt werden können, ist ein Telefonbuch, die Telefonnummer ist der Schlüssel und der Name der Person ist der Wert. Jeder Schlüssel entspricht nur einem Wert.
Die Hierarchie der Interface der Grupppe Map:
Die Hierarchie der Klasse in der Gruppe Map:
Die Beziehung zwischen die Interface und die Klasse in die Gruppe Map:

2- Examples

Da Map eine Interface ist, können Sie sie nur aus einer der Unterklassen erstellen. In diesem Beispiel erstellen wir ein Objekt Map , das ein Telefonbuch simuliert.
MapEx1.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class MapEx1 {
 
    public static void main(String[] args) {
        Map<String, String> phonebook = new HashMap<String, String>();
 
        phonebook.put("01000005", "Tom");
        phonebook.put("01000002", "Jerry");
        phonebook.put("01000003", "Tom");
        phonebook.put("01000004", "Donald");
        
        Set<String> phoneNumbers = phonebook.keySet();
 
        for (String phoneNumber : phoneNumbers) {
            String name = phonebook.get(phoneNumber);
            
            System.out.println("Phone Number: " + phoneNumber + " ==> Name: " + name);
        }
    }
}
Output:

Phone Number: 01000004 ==> Name: Donald
Phone Number: 01000003 ==> Name: Tom
Phone Number: 01000005 ==> Name: Tom
Phone Number: 01000002 ==> Name: Jerry
Fahren Sie mit dem obigen Beispiel fort. Sie können über eine Sammlung von Map.Entry auf Daten Map zugreifen:
MapEx2.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class MapEx2 {
 
    public static void main(String[] args) {
        Map<String, String> phonebook = new HashMap<String, String>();
 
        phonebook.put("01000005", "Tom");
        phonebook.put("01000002", "Jerry");
        phonebook.put("01000003", "Tom");
        phonebook.put("01000004", "Donald");
        
        Set<Map.Entry<String,String>> contacts = phonebook.entrySet();
 
        for (Map.Entry<String,String> contact: contacts) {
            String phoneNumber = contact.getKey();
            String name = contact.getValue();
            
            System.out.println("Phone Number: " + phoneNumber + " ==> Name: " + name);
        }
    }
}
Output:

Phone Number: 01000004 ==> Name: Donald
Phone Number: 01000003 ==> Name: Tom
Phone Number: 01000005 ==> Name: Tom
Phone Number: 01000002 ==> Name: Jerry

3- Null Key/Value

Map kann einen Schlüssel null zulassen. Das hängt von der Klasse ab, die ihn implementiert, z.B die Klasse HashMap:
MapEx3.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;
 
public class MapEx3 {
 
    public static void main(String[] args) {
        // String employeeNumber, int salary
        Map<String, Integer> mapSalary = new HashMap<String, Integer>();
 
        mapSalary.put("E001", 1200);
        mapSalary.put("E002", 2000);
        
        mapSalary.put(null, 1000); // Base salary
        
        int value = mapSalary.get(null);
        System.out.println(value); // 1000
    }
}
Output:

1000
Map kann ein Mapping mit dem Wert null zulassen. Dies hängt von der Klasse ab, die die Interface Map ​​​​​​​implementiert.
MapEx3.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;

public class MapEx3 {

    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();

        map.put("AA", null);
        
        Integer value = map.get("AA");
        System.out.println("AA ==> " + value);
        
        boolean test = map.containsKey("AA");
        System.out.println("Contains AA? " + test); // true
        
        test = map.containsKey("BB");
        System.out.println("Contains BB? " + test); // false
    }
}
 
Output:

AA ==> null
Contains AA? true
Contains BB? false

4- Map Methods

Die Methode der Interface  Map:

void clear()
boolean containsKey​(Object key)
boolean containsValue​(Object value)
boolean isEmpty()

Set<Map.Entry<K,​V>> entrySet()
boolean equals​(Object o)
V get​(Object key)

Set<K> keySet()

Collection<V> values()
V remove​(Object key)
V put​(K key, V value)
void putAll​(Map<? extends K,​? extends V> m)

int size()
int hashCode()

static <K,​V> Map<K,​V> of()
static <K,​V> Map<K,​V> of​(K k1, V v1)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10)
static <K,​V> Map<K,​V> ofEntries​(Map.Entry<? extends K,​? extends V>... entries)
static <K,​V> Map<K,​V> copyOf​(Map<? extends K,​? extends V> map)
static <K,​V> Map.Entry<K,​V> entry​(K k, V v)

default V putIfAbsent​(K key, V value)
default boolean remove​(Object key, Object value)
default V replace​(K key, V value)
default boolean replace​(K key, V oldValue, V newValue)
default void replaceAll​(BiFunction<? super K,​? super V,​? extends V> function)
default V merge​(K key, V value, BiFunction<? super V,​? super V,​? extends V> remappingFunction)
default V compute​(K key, BiFunction<? super K,​? super V,​? extends V> remappingFunction)
default V computeIfAbsent​(K key, Function<? super K,​? extends V> mappingFunction)
default V computeIfPresent​(K key, BiFunction<? super K,​? super V,​? extends V> remappingFunction)
default void forEach​(BiConsumer<? super K,​? super V> action)
default V getOrDefault​(Object key, V defaultValue)
Die Interface Map verfügt über einige optionale Methode, die in der diese Interface implementierende Klasse möglicherweise nicht unterstützt werden. Wenn Sie sie verwenden, erhalten Sie UnsupportedOperationException.

void clear()
V put​(K key, V value)  
void putAll​(Map<? extends K,​? extends V> m)
V remove​(Object key)

5- of(..), ofEntries​(..), copyOf​(..)

Die statische Methode Map.of(..) erstellt ein nicht veränderbares Objekt Map aus Schlüssel- und Wertepaaren.

static <K,​V> Map<K,​V> of()
static <K,​V> Map<K,​V> of​(K k1, V v1)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9)
static <K,​V> Map<K,​V> of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10)
Die statische Methode Map.ofEntry(..) erstellt aus den angegebenen Objekt Map.Entry ein nicht veränderbares Objekt Map.

static <K,​V> Map<K,​V> ofEntries​(Map.Entry<? extends K,​? extends V>... entries)
Die statische Methode Map.copyOf(..) erstellt aus den angegebenen Objekt Map ein nicht veränderbares (unmodifiable) Objekt Map.

static <K,​V> Map<K,​V> copyOf​(Map<? extends K,​? extends V> map)
Die statische Methode Map.of, Map.ofEntriesMap.copyOf bieten eine bequeme Möglichkeiten,um die nichtveränderbaren Objekten Map zu erstellen. Die mit diesen Methoden erstellten Objekten Map haben die folgenden Merkmale:
  • Sie sind nicht veränderbar. Die Schlüssel und Werte können nicht hinzufügt, entfernt oder aktualisiert werden. Das Aufrufen einer Mutator-Methode in Map führt immer zu, dass UnsupportedOperationException ausgelöst wird. Aber wenn die Schlüssel oder Werte selbst veränderbar sind, kann dies dazu führen, dass sich die Map inkonsistent verhält oder sich ihr Inhalt zu ändern scheint. 
  • Sie verbieten die Schlüssel und den Werte null. Versuchen Sie, sie mit den Schüssel oder Werten null zu erstellen, führen Sie zu NullPointerException.
  • Sie sind serialisierbar, wenn alle Schlüssel und Werte serialisierbar sind.
  • Lassen Sie keine doppelten Schlüssel in den Eingabeparametern zu. Wenn nicht, wird IllegalArgumentException ausgelöst.
  • Die Iterationsreihenfolge von Mappings ist nicht angegeben und kann sich ändern.
Map.of Example:
Map_of_ex1.java

package org.o7planning.map.ex;

import java.util.Map;

public class Map_of_ex1 {

    public static void main(String[] args) {

        // Create an unmodifiable Map:
        Map<String, Integer> empMap = Map.of("E01", 1000, "E02", 2000, "E03", 1200);

        empMap.forEach((empNumber, salary) -> {
            System.out.println("Emp Number: " + empNumber + ", Salary: " + salary);
        });
    }
}
Output:

Emp Number: E03, Salary: 1200
Emp Number: E02, Salary: 2000
Emp Number: E01, Salary: 1000
Map.ofEntries Example:
Map_ofEntry_ex1.java

package org.o7planning.map.ex;

import java.util.Map;

public class Map_ofEntry_ex1 {

    public static void main(String[] args) {

        Map.Entry<String, Integer> entry1 = Map.entry("E01", 1000);
        Map.Entry<String, Integer> entry2 = Map.entry("E02", 2000);
        Map.Entry<String, Integer> entry3 = Map.entry("E03", 1200);

        Map<String, Integer> unmodifiableMap = Map.ofEntries(entry1, entry2, entry3);
        
        unmodifiableMap.forEach((empNumber, salary) -> {
            System.out.println("Emp Number: " + empNumber + ", Salary: " + salary);
        });
    }
}
Output:

Emp Number: E02, Salary: 2000
Emp Number: E03, Salary: 1200
Emp Number: E01, Salary: 1000
Map.copyOf Example:
Map_copyOf_ex1.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;

public class Map_copyOf_ex1 {

    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        
        map.put("E01", 1000);
        map.put("E02", 2000);
        map.put("E03", 1200);

        // Unmodifiable Map
        Map<String, Integer> unmodifiableMap = Map.copyOf(map);
        
        unmodifiableMap.forEach((empNumber, salary) -> {
            System.out.println("Emp Number: " + empNumber + ", Salary: " + salary);
        });
    }
}
Z.B: Das Objekt Map , das durch die statische Methode Map.of, Map.ofEntries und Map.copyOf erstellt wird, sind nicht veränderbar (unmodifiable), und sie unterstützt keine Vorgänge zur Änderung seiner Daten wie put, clear,..
Map_of_ex2.java

package org.o7planning.map.ex;

import java.util.Map;

public class Map_of_ex2 {

    public static void main(String[] args) {

        // Create an unmodifiable Map:
        Map<String, Integer> empMap = Map.of("E01", 1000, "E02", 2000, "E03", 1200);

        // Update new value.
        empMap.put("E02", 5000); // ==> throw UnsupportedOperationException
        
        empMap.put("E05", 3000); // ==> throw UnsupportedOperationException
        
        empMap.remove("E01");  // ==> throw UnsupportedOperationException
        
        empMap.clear();   // ==> throw UnsupportedOperationException
    }
}

6- put​(K key, V value)


public V put​(K key, V value)  // Optional Operation
Fügen Sie der Mapping (key, value) in Map hinzu wenn key nicht existiert und null zurückgibt. Umgekehrts wird der neue Wert durch den alten Wert ersetzt, der dem Schlüssel key entspricht, und der alte Wert wird zurückgegeben.

7- putIfAbsent​(K key, V value)


default V putIfAbsent(K key, V value) {
    V v = get(key);
    if (v == null) {
        v = put(key, value);
    }
    return v;
}
Diese Methode ähnelt der Methode put(key,value) aber funktioniert nur, wenn key nicht in Map vorhanden ist oder einem Wert null zugeordnet ist. Die Methode gibt null oder alten Wert zurück.

8- putAll​(Map)


public void putAll​(Map<? extends K,​? extends V> m)
Kopieren Sie alle Mapping vom angegebenen Objekt Map in das aktuelle Objekt Map .

9- get​(Object key)


public V get​(Object key)
Gibt den Wert der Mapping zurück, der dem key entspricht, oder null wenn keine solche Mapping vorhanden ist.

10- getOrDefault​(Object key, V defaultValue)


public default V getOrDefault(Object key, V defaultValue) // Java 8
Gibt den Wert der Mapping zurück, die dem key entspricht, oder defaultValue wenn keine solche Mapping vorhanden ist.
Zum Beispiel:
Map_getOrDefault​_ex1.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;

public class Map_getOrDefault​_ex1 {

    public static void main(String[] args) {
         Map<String, String> appConfigs = new HashMap<String, String>();
        
         appConfigs.put("INPUT_DIRECTORY", "C:/App/input");
         appConfigs.put("IMAGE_DIRECTORY", "C:/App/image");
        
        
         String outputDir = appConfigs.getOrDefault("OUTPUT_DIRECTORY", "C:/App/output");
        
         System.out.println("App Output Directory: " + outputDir);
    }
}
Output:

App Output Directory: C:/App/output

11- containsKey​(Object key)


public boolean containsKey​(Object key)
Gibt true zurück, wenn diese Map eine Mapping für den angegebenen Schlüssel enthält.

12- containsValue​(Object value)


public boolean containsValue​(Object value)
Gibt true zurück wenn diese Map mindestens eine Mapping zum angegebenen Wert hat.
Z.B: Ein Map enthält die Mappings zwischen Markenname und Land. Überprüfen Sie, ob eine Marke aus einem bestimmten Land stammt.
Map_containsValue​_ex1.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;

public class Map_containsValue​_ex1 {
    
    public static void main(String[] args)  {
        // String brand ==> String country
        Map<String, String> brandMap  = new HashMap<String, String>();
        
        brandMap.put("SamSung", "Korea");
        brandMap.put("LG", "Korea");
        brandMap.put("Alibaba", "China");
        brandMap.put("Toyota", "Japan");
        brandMap.put("Hyundai", "Korea");
        brandMap.put("Vinfast", "Vietnam"); // value = "Vietnam"!
        brandMap.put("Honda", "Japan");
        brandMap.put("Huwei", "China");
        
        boolean contain = brandMap.containsValue("Vietnam");
        System.out.println("Does the Map contain 'Vietnam' value? " + contain);
      
        contain = brandMap.containsValue("Thailand");
        System.out.println("Does the Map contain 'Thailand' value? " + contain);
    }  
}
Output:

Does the Map contain 'Vietnam' value? true
Does the Map contain 'Thailand' value? false

13- remove​(Object key)


public V remove​(Object key) // Optional Operation
Entfernen Sie die dem key entsprechenden Mapping aus Map. Geben Sie den Wert von Mapping zurück oder null, wenn die Mapping nicht vorhanden ist.

14- remove​(Object key, Object value)


public default boolean remove(Object key, Object value)  {
    if (this.containsKey(key) && Objects.equals(this.get(key), value)) {
        this.remove(key);
         return true;
     } else {
         return false;
     }
}
Entfern Sie die Mapping (key,value) aus Map, und gibt true zurück wenn sie tatsächlich vorhanden ist. Andernfalls wird false zurückgegeben.

15- clear()


public void clear()  // Optional operation.
Entfernen Sie alle Mappings von dieser Map. Die Map ist nach dem Aufruf der Methode leer.

16- forEach​(BiConsumer)


public default void forEach​(BiConsumer<? super K,​? super V> action)
Führen Sie eine bestimmten Aktion für jedes Paar (key,value) von Map aus, bis alle Paare behandelt wurden oder eine Ausnahme auftritt.
Z.B: Ein Objekt Map enthält die Mappings zwischen Ländername und Bevölkerung.
Map_forEach_ex1.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;

public class Map_forEach_ex1 {
    
    public static void main(String[] args)  {
        // Data in 2021.
        // String  country ==> Integer population (Million)
        Map<String, Integer> populationMap  = new HashMap<String, Integer>();
        
        populationMap.put("Vietnam", 98);  
        populationMap.put("Phillipine", 109);
        populationMap.put("United States", 330);
        populationMap.put("Indonesia", 273);
        populationMap.put("Russia", 145);
        
        // forEach(BiConsumer):
        populationMap.forEach((country, population) -> System.out.println(country + " --> " + population));
    }  
}
Output:

Vietnam --> 98
United States --> 330
Phillipine --> 109
Indonesia --> 273
Russia --> 145

17- keySet()


public Set<K> keySet()
Gibt eine Ansicht als Set zurück, die alle Schlüssel Map enthält. Das Objekt Set und das aktuelle Map sind miteinander verbunden. Die Änderungen auf der Map wirken sich auf das Set aus und umgekehrt.
  1. Durch Hinzufügen oder Entfernen einer Zuordnung zu Map wird ein Element zu Set hinzufügt oder daraus entfernt.
  2. Die Methoden, die Elemente aus Set entfernen, wie z.B Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear.. entfernen die entsprechenden Mappings aus Map.
  3. Dieses Objekt Set ünterstützt die Vorgänge Set.add, Set.addAll ​​​​​​​nicht.
Zum Beispiel: Ein Objekt Map enthält die Mappings zwischen Ländername und Bevölkerung.
Map_keySet_ex1.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Map_keySet_ex1 {
    
    public static void main(String[] args)  {
        // Data in 2021.
        // String  country ==> Integer population (Million)
        Map<String, Integer> populationMap  = new HashMap<String, Integer>();
        
        populationMap.put("Vietnam", 98);  
        populationMap.put("Phillipine", 109);
        populationMap.put("United States", 330);
        populationMap.put("Indonesia", 273);
        populationMap.put("Russia", 145);
        
        Set<String> countrySet  = populationMap.keySet();
        
        for(String country: countrySet)  {
            System.out.println(country);
        }
    }  
}
Output:

Vietnam
United States
Phillipine
Indonesia
Russia
Map_keySet_ex2.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Map_keySet_ex2 {
    
    public static void main(String[] args)  {
        // Data in 2021.
        // String  country ==> Integer population (Million)
        Map<String, Integer> populationMap  = new HashMap<String, Integer>();
        
        populationMap.put("Vietnam", 98);  
        populationMap.put("Phillipine", 109);
        populationMap.put("United States", 330);
        populationMap.put("Indonesia", 273);
        populationMap.put("Russia", 145);
        
        Set<String> countrySet  = populationMap.keySet();
        
        System.out.println("--- Countries: ---");
        for(String country: countrySet)  {
            System.out.println(country);
        }
        //
        countrySet.remove("Phillipine");
        countrySet.remove("Indonesia");
        
        System.out.println();
        System.out.println("--- Map (After removal): ---");
        
        populationMap.forEach((country, population) -> {
            System.out.println(country +" --> " + population);
        });
    }  
}
Output:

--- Countries: ---
Vietnam
United States
Phillipine
Indonesia
Russia

--- Map (After removal): ---
Vietnam --> 98
United States --> 330
Russia --> 145

18- entrySet()


public Set<Map.Entry<K,​V>> entrySet()
Gibt eine Ansicht als Set zurück, die alle Elemente Map.Entry von Map enthält. Das Objekt Set und das aktuelle Objekt Map sind miteinander verbunden. Die Änderungen auf Map wirken sich auf das Set aus und umgekehrt.
  1. Durch Hinzufügen oder Entfernen des Mapping aus Map wird ein Element zu Set hinzugefügt oder daraus entfernt.
  2. Die Methode, die die Elemente aus Set wie Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear.. entfernt, wird die entsprechenden Mappings aus Map auslösen.
  3. Dieses Objekt Set unterstützt die Vorgänge Set.add, Set.addAll ​​​​​​​nicht.
Beispiel: Ein Objekt Map enthält die Mappings zwischen Ländername und Bevölkerung.
Map_entrySet_ex1.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Map_entrySet_ex1 {
    
    public static void main(String[] args)  {
        // Data in 2021.
        // String  country ==> Integer population (Million)
        Map<String, Integer> populationMap  = new HashMap<String, Integer>();
        
        populationMap.put("Vietnam", 98);  
        populationMap.put("Phillipine", 109);
        populationMap.put("United States", 330);
        populationMap.put("Indonesia", 273);
        populationMap.put("Russia", 145);
        
        Set<Map.Entry<String,Integer>> set = populationMap.entrySet();
        
        for(Map.Entry<String,Integer> entry: set) {
            System.out.println(entry.getKey() +" --> " + entry.getValue());
        }
    }  
}
Output:

Vietnam --> 98
United States --> 330
Phillipine --> 109
Indonesia --> 273
Russia --> 145
Fahren Sie mit dem obigen Beispiel fort. Wir entfernen Länder mit einer Bevölkerung von mehr als 200 (Milionen) aus dem Objekt Map.
Map_entrySet_ex2.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Map_entrySet_ex2 {
    
    public static void main(String[] args)  {
        // Data in 2021.
        // String  country ==> Integer population (Million)
        Map<String, Integer> populationMap  = new HashMap<String, Integer>();
        
        populationMap.put("Vietnam", 98);  
        populationMap.put("Phillipine", 109);
        populationMap.put("United States", 330);
        populationMap.put("Indonesia", 273);
        populationMap.put("Russia", 145);
        
        Set<Map.Entry<String,Integer>> set = populationMap.entrySet();
        
        Iterator<Map.Entry<String,Integer>> iterator = set.iterator();
        
        // Remove the Countries with population greater than 200 Million.
        while(iterator.hasNext()) {
            Map.Entry<String,Integer> entry = iterator.next();
            
            if(entry.getValue() > 200)  {
                iterator.remove();
            }
        }
        // After removal.
        // forEach(Consumer)
        set.forEach(entry -> {
            System.out.println(entry.getKey() +" --> " + entry.getValue());
        });
    }  
}
Output:

Vietnam --> 98
Phillipine --> 109
Russia --> 145

19- values()


public Collection<V> values()
Gibt eine Ansicht als Collection zurück, die alte Werten von Map enthält. Das Objekt Collection und aktuelles Objekt Map sind miteinander verbunden. Die Änderungen an Map wirken sich auf die Collection aus und umgekehrt.
  1. Durch HInzufügen oder Entfernen eines Mapping aus Map wird ein Element zur Collection hinzugefügt oder daraus entfernt.
  2. Das Ändern des Werts eines Mapping wirkt sich auf die Collection aus.
  3. Die Methoden, die Elemente aus Collection entfernen, wie Collection.iterator().remove, Collection.remove, Collection.removeAll, Collection.retainAll, Collection.clear.. entfernen die entsprechenden Mappings aus Map.
  4. Das Objekt Collection unterstützt die Vorgänge Collection.add, Collection.addAll nicht
Beispiel: Ein Objekt Map enthält die Mappings zwischen Markenname und Land. Drucken Sie die Werte vom Objekt Map aus.
Map_values_ex1.java

package org.o7planning.map.ex;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class Map_values_ex1 {
    
    public static void main(String[] args)  {
        // String brand ==> String country
        Map<String, String> brandMap  = new HashMap<String, String>();
        
        brandMap.put("SamSung", "Korea");
        brandMap.put("LG", "Korea");
        brandMap.put("Alibaba", "China");
        brandMap.put("Toyota", "Japan");
        brandMap.put("Hyundai", "Korea");
        brandMap.put("Vinfast", "Vietnam");
        brandMap.put("Honda", "Japan");
        brandMap.put("Huwei", "China");
        
        Collection<String> countries = brandMap.values();
        
        for(String country: countries)  {
            System.out.println(country);
        }
    }  
}
Output:

China
Japan
Vietnam
Korea
China
Korea
Korea
Japan
Fahren Sie mit dem obigen Beispiel fort udn entfernen Sie diese Marken aus China aus dem Objekt Map:
Map_values_ex2.java

package org.o7planning.map.ex;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class Map_values_ex2 {
    
    public static void main(String[] args)  {
        // String brand ==> String country
        Map<String, String> brandMap  = new HashMap<String, String>();
        
        brandMap.put("SamSung", "Korea");
        brandMap.put("LG", "Korea");
        brandMap.put("Alibaba", "China");
        brandMap.put("Toyota", "Japan");
        brandMap.put("Hyundai", "Korea");
        brandMap.put("Vinfast", "Vietnam");
        brandMap.put("Honda", "Japan");
        brandMap.put("Huwei", "China");
        
        Collection<String> countries = brandMap.values();
        
        Iterator<String> countryIte = countries.iterator();
        
        String country;
        while(countryIte.hasNext()) {
            country = countryIte.next();
            if("China".equals(country)) {
                countryIte.remove();
            }
        }
        // After remove
        for(String brand: brandMap.keySet()) {
            System.out.println(brand +" : " + brandMap.get(brand));
        }
    }  
}
Output:

Toyota : Japan
Vinfast : Vietnam
SamSung : Korea
LG : Korea
Hyundai : Korea
Honda : Japan

20- size()


public int size()
Gibt die Anzahl der Mappings in dieser Map zurück. Wenn die Map mehr als Elemente Integer.MAX_VALUE enthält, wird Integer.MAX_VALUE zurückgegeben.

21- replace​(K key, V value)


public default V replace​(K key, V value)
Wenn ein Mapping mit dem Schlüssel key im Map vorhanden ist, wird diese durch Mapping (key,value) ersetzt und der alte Wert zurückgegeben. Andernfalls wird keine Aktion durchgeführt und null zurückgegeben.
Zum Beispiel:
Map_replace_ex1.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;

public class Map_replace_ex1 {

    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();

        map.put("A", 1200);
        map.put("B", null);
        map.put("C", 1500);

        // key does not exists, no replace, return null
        Integer oldValue1 = map.replace("A1", 3000);

        // key exists!, replace!, return null (old value).
        Integer oldValue2 = map.replace("B", 5000);

        // key exists!, replace!, return 1500 (old value).
        Integer oldValue3 = map.replace("C", 2000);

        System.out.println("oldValue1: " + oldValue1); // null
        System.out.println("oldValue2: " + oldValue2); // null (old value).
        System.out.println("oldValue3: " + oldValue3); // 1500 (old value).
        System.out.println();

        for (String key : map.keySet()) {
            System.out.println(key + " ==> " + map.get(key));
        }
    }
}
Output:

oldValue1: null
oldValue2: null
oldValue3: 1500

A ==> 1200
B ==> 5000
C ==> 2000

22- replace​(K key, V oldValue, V newValue)


public default boolean replace​(K key, V oldValue, V newValue)
Wenn Mapping (key,oldValue) tatsächlich in Map vorhanden ist, wird sie durch die Mapping (key,newValue) ersetzt und gibt true zurück. Andernfalls wird keine Aktion durchgeführt und false zurückgegeben.

23- replaceAll​(BiFunction)


public default void replaceAll​(BiFunction<? super K,​? super V,​? extends V> function)
Verwenden Sie die vom Paramter angegebene function , um den Wert für die Mappings in Map zu ersetzen. Das Aufrufen der obigen Methode entspricht dem Durchführen des folgenden Codes:

for (Map.Entry<K, V> entry : map.entrySet()) {
    entry.setValue(function.apply(entry.getKey(), entry.getValue()));
}
Beispiel: Ein Objekt Map enthält die Mapping zwischen Mitarbeiternummer (Employee Number) und Gehalt. Verwenden Sie die Methode replaceAll um das Gehalt pro Mitarbeiter um 50% zu erhöhen.
Map_replaceAll_ex1.java

package org.o7planning.map.ex;

import java.util.HashMap;
import java.util.Map;

public class Map_replaceAll_ex1 {

    public static void main(String[] args) {

        // Create Map (Employee Number --> Salary)
        Map<String, Float> empMap = new HashMap<>();
        empMap.put("E01", 1000f);
        empMap.put("E02", 2000f);
        empMap.put("E03", 1200f);
        
        // Salary update for all employees, 50% increase.
        empMap.replaceAll((empNumber, salary) -> {
            return salary + salary * 0.5f;
        });
        // Print out:
        empMap.forEach((empNumber, salary) -> {
            System.out.println(empNumber + " --> " + salary);
        });
    }
}
Output:

E02 --> 3000.0
E01 --> 1500.0
E03 --> 1800.0

24- merge​(K key, V value, BiFunction)


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);
    V newValue = (oldValue == null) ? value :
               remappingFunction.apply(oldValue, value);
    if (newValue == null) {
        remove(key);
    } else {
        put(key, newValue);
    }
    return newValue;
}

25- compute​(K key, BiFunction)


default V compute(K key,
        BiFunction<? super K, ? super V, ? extends V> 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;
    }
}

26- computeIfAbsent​(K key, Function)


default V computeIfAbsent(K key,
        Function<? super K, ? extends V> 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;
}

27- computeIfPresent​(K key, BiFunction)


default V computeIfPresent(K key,
        BiFunction<? super K, ? super V, ? extends V> 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;
    }
}
Vielleicht bist du interessiert

Das sind die Online-Courses außer der Website o7planning, die wir empfehlen. Sie können umsonst sein oder Discount haben.