devstory

Le Tutoriel de Java Map

  1. Map
  2. Examples
  3. Null Key/Value
  4. Map Methods
  5. of(..), ofEntries​(..), copyOf​(..)
  6. put​(K key, V value)
  7. putIfAbsent​(K key, V value)
  8. putAll​(Map)
  9. get​(Object key)
  10. getOrDefault​(Object key, V defaultValue)
  11. containsKey​(Object key)
  12. containsValue​(Object value)
  13. remove​(Object key)
  14. remove​(Object key, Object value)
  15. clear()
  16. forEach​(BiConsumer)
  17. keySet()
  18. entrySet()
  19. values()
  20. size()
  21. replace​(K key, V value)
  22. replace​(K key, V oldValue, V newValue)
  23. replaceAll​(BiFunction)
  24. merge​(K key, V value, BiFunction)
  25. compute​(K key, BiFunction)
  26. computeIfAbsent​(K key, Function)
  27. computeIfPresent​(K key, BiFunction)

1. Map

Dans Java, Map est une interface qui représente un objet contenant des mappages entre des clés (key) et des valeurs (value). Chaque clé correspond à une valeur. L'un des exemples typiques que l'on peut mentionner est un annuaire téléphonique, le numéro de téléphone est la clé et le nom de la personne est la valeur. Chaque clé correspondra à une seule valeur.
L'hiérarchie des interfaces du groupe Map:
L'hiérarchie des classes dans le groupe Map:
Relations entre les interfaces et les classes dans le groupe Map:

2. Examples

Puisque Map est une interface, vous ne pouvez la créer qu'à partir d'une des sous-classes. Dans cet exemple, on va créer un objet Map simulant un annuaire téléphonique.
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
Observer l'exemple ci-dessus, vous pouvez accéder aux données de la Map via une collection de Map.Entry(s):
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 peut autoriser la clé null, cela dépend de la classe qui l'implémente, telle que la classe 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 peut autoriser un mappage avec une valeur null. Cela dépend de la classe qui implémente l'interface Map.
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

Les méthodes de l'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)
L'interface de Map a quelques méthodes facultatives qui peuvent ne pas être autorisées dans la classe laquelle implémente cette interface. Si vous les utilisez, vous obtiendrez 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​(..)

La méthode statique Map.of(..) crée un objet Map non modifiable (unmodifiable) à partir de paires clé et valeur.
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)
La méthode statique Map.ofEntry(..) crée un objet Map non modifiable (unmodifiable) à partir des objets Map.Entry donnés.
static <K,​V> Map<K,​V> ofEntries​(Map.Entry<? extends K,​? extends V>... entries)
La méthode statique Map.copyOf(..) crée un objet Map non modifiable (unmodifiable) à partir d'un objet Map donné.
static <K,​V> Map<K,​V> copyOf​(Map<? extends K,​? extends V> map)
Les méthodes statiques Map.of, Map.ofEntries et Map.copyOf fournissent un moyen pratique pour créer des Map(s) non modifiables. Les instances de Map créées par ces méthodes ont les caractéristiques suivantes:
  • Ils ne sont pas modifiables. Les clés et les valeurs ne peuvent pas être ajoutées, supprimées ou mises à jour. L'appel d'une méthode de mutateur sur la Map provoquera toujours la levée d'une exception UnsupportedOperationException. Toutefois, si les clés ou les valeurs contenues sont elles-mêmes modifiables, cela peut entraîner un comportement incohérent de la Map ou une modification de son contenu.
  • Ils interdisent les clés et valeurs null. Les tentatives de création avec des clés ou des valeurs null aboutissent à NullPointerException.
  • Ils sont sérialisables (serializable) si toutes les clés et valeurs sont sérialisables.
  • Ne pas autoriser les clés dupliquées dans les paramètres d'entrée. Sinon, IllegalArgumentException sera levé.
  • L'ordre d'itération des mappages n'est pas spécifié et est sujet de changement.
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);
        });
    }
}
Exemple: L'objet Map créé par les méthodes statiques Map.of, Map.ofEntries et Map.copyOf n'est pas modifiable. Il ne supporte aucune opération pour modifier ses données. Par exemple, 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
Ajouter un mappage (key,value) à Map si key n'existe pas et retournez null. Sinon, la nouvelle valeur sera remplacée par l'ancienne valeur correspondant à key et renverra l'ancienne valeur.

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;
}
Cette méthode est similaire à la méthode put(key,value) mais elle ne fonctionne que si key n'existe pas dans Map ou si elle est mappée à une valeur null. La méthode renvoie une valeur null ou ancienne.

8. putAll​(Map)

public void putAll​(Map<? extends K,​? extends V> m)
Copier tous les mappages de l'objet Map spécifié vers l'objet Map actuel.

9. get​(Object key)

public V get​(Object key)
Renvoyer la valeur du mappage correspondant à key, ou null si un tel mappage n'existe pas.

10. getOrDefault​(Object key, V defaultValue)

public default V getOrDefault(Object key, V defaultValue) // Java 8
Renvoyer la valeur du mappage correspondant à key, ou defaultValue si un tel mappage n'existe pas.
Par exemple:
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)
Renvoyer true si cette Map contient un mappage pour la clé spécifiée.

12. containsValue​(Object value)

public boolean containsValue​(Object value)
Renvoyer true si cette Map a au moins un mappage à la valeur spécifiée.
Exemple: Une Map contient des mappages entre le nom de la marque et le pays, vérifier si une marque provient ou non d'un certain pays.
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
Supprimer le mappage correspondant à key de Map. Renvoyer la valeur du mappage, ou null si le mappage n'existe pas.

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;
     }
}
Supprimer le mappage (key,value) de Map et renvoie true s'il existe réellement, sinon renvoie false.

15. clear()

public void clear()  // Optional operation.
Supprimer tous les mappages de cette Map. Map sera vide après l'appel de la méthode.

16. forEach​(BiConsumer)

public default void forEach​(BiConsumer<? super K,​? super V> action)
Exécuter une action spécifiée sur chaque paire (key,value) de Map jusqu'à ce que toutes les paires soient gérées ou qu'une exception se produise.
Exemple: Un objet Map contient des mappages entre le nom du pays et la population.
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()
Renvoyer une vue sous forme de Set contenant toutes les clés de Map. L'objet Set et l'objet Map actuel sont liés. Les changements sur Map affecteront Set et vice versa.
  • L'ajout ou la suppression d'un mappage de Map ajoutera ou supprimera un élément de Set.
  • Les méthodes qui suppriment des éléments de Set telles que Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear.. supprimeront les mappages correspondants de Map.
  • Cet objet Set ne prend pas en charge les opérations Set.add, Set.addAll.
Exemple: Un objet Map contient des mappages entre le nom du pays et la population.
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()
Renvoyer une vue sous la forme d'un Set contenant tous les éléments Map.Entry de la Map. L'objet Set et l'objet Map actuel sont liés. Les changements sur Map affecteront Set et vice versa.
  • L'ajout ou la suppression d'un mappage de Map ajoutera ou supprimera un élément de Set.
  • Les méthodes qui suppriment des éléments de Set telles que Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear.. supprimeront les mappages correspondants de Map.
  • Cet objet Set ne prend pas en charge les opérations Set.add, Set.addAll.
Exemple: Un objet Map contient des mappages entre le nom du pays et la population.
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
Continuer avec l'exemple ci-dessus, on supprime les pays dont la population est supérieure à 200 (millions) de l'objet 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()
Renvoyer une vue en tant que Collection contenant toutes les valeurs de la Map. L'objet Collection et l'objet Map actuel sont liés l'un à l'autre. Les changements sur Map affecteront la Collection et vice versa.
  • L'ajout ou la suppression d'une carte de la Map ajoutera ou supprimera un élément de la Collection.
  • Modifier la valeur d'un mappage affectera Collection.
  • Les méthodes qui suppriment des éléments de Collection telles que Collection.iterator().remove, Collection.remove, Collection.removeAll, Collection.retainAll, Collection.clear... supprimeront les mappages correspondants de la Map.
  • Cet objet Collection ne supporte pas les opérations Collection.add, Collection.addAll.
Exemple: Un objet Map contient des mappages entre le nom de la marque (brand) et le pays. Imprimer les valeurs de l'objet Map.
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
Continuer avec l'exemple ci-dessus, supprimer ces marques de Chine de l'objet 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()
Renvoyer le nombre de mappings dans cette Map. SiMap contient plus que l'élément Integer.MAX_VALUE, renvoyer Integer.MAX_VALUE.

21. replace​(K key, V value)

public default V replace​(K key, V value)
S'il y a un mappage avec la clé key dans Map, qui sera remplacé par le mappage (key,value) et renvoyer l'ancienne valeur. À l'inverse, aucune action est exécutée et null est renvoyée.
Par exemple:
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)
Si le mappage (key,oldValue) existe réellement dans Map, il sera remoplacé par le mappage (key,newValue) et renverra true. À l'inverse, aucune action n'est exécutée et renvoyer false.

23. replaceAll​(BiFunction)

public default void replaceAll​(BiFunction<? super K,​? super V,​? extends V> function)
Utiliser function fournie par le paramètre pour remplacer la valeur pour tous les mappages dans Map. Convoquer la méthode ci-dessus est l'équivalent de l'exécution du code suivant:
for (Map.Entry<K, V> entry : map.entrySet()) {
    entry.setValue(function.apply(entry.getKey(), entry.getValue()));
}
Par exemple: Un objet Map contenant les mappages entre le numéro d'employé (Employee Number) et le salaire. Utiliser la méthode replaceAll pour augmenter le salaire de 50% pour chaque salarié.
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;
    }
}

Tutoriels de Java Collections Framework

Show More

Articles les plus récents

Show More