openplanning

Hướng dẫn sử dụng Java Map

Xem thêm các chuyên mục:

1- Map

Trong Java, Map là một interface đại diện cho một đối tượng chứa các ánh xạ giữa các khoá (key) và các giá trị (value). Mỗi khoá sẽ tương ứng với một giá trị. Một trong các ví dụ tiêu biểu có thể kể tới ở đây là một danh bạ điện thoại, số điện thoại là khoá và tên tên người là giá trị, mỗi khoá sẽ chỉ tương ứng với duy nhất một giá trị.
Hệ thống phân cấp các interface của nhóm Map:
  • TODO Link!
  • TODO Link!
Hệ thống phân cấp các lớp trong nhóm Map:
Mối quan hệ giữa các interface và các lớp trong nhóm Map:

2- Map Methods

Các phương thức của 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)
Interface Map có một vài phương thức là tuỳ chọn, chúng có thể không được hỗ trợ trong lớp thi hành interface này. Nếu sử dụng chúng bạn sẽ nhận được UnsupportedOperationException.
void clear()
V put​(K key, V value)  
void putAll​(Map<? extends K,​? extends V> m)
V remove​(Object key)

3- Examples

Map là một interface nên bạn chỉ có thể tạo ra nó từ một trong các lớp con. Trong ví dụ này chúng ta sẽ tạo một đối tượng Map mô phỏng một danh bạ điện thoại.
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
Tiếp tục với ví dụ trên, bạn có thể truy cập vào các dữ liệu Map thông qua tập hợp các Map.Entry:
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

4- Null Key/Value

Map có thể cho phép khoá null, điều này tuỳ thuộc vào lớp thi hành nó, chẳng hạn như lớp 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 có thể cho phép một ánh xạ với giá trị null, điều này phụ thuộc vào lớp thi hành 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

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

Phương thức tĩnh Map.of(..) tạo ra một đối tượng Map không thể sửa đổi (unmodifiable) từ các cặp khoá và giá trị.
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)
Phương thức tĩnh Map.ofEntry(..) tạo ra một đối tượng Map không thể sửa đổi (unmodifiable) từ các đối tượng Map.Entry đã cho.
static <K,​V> Map<K,​V> ofEntries​(Map.Entry<? extends K,​? extends V>... entries)
Phương thức tĩnh Map.copyOf(..) tạo ra một đối tượng Map không thể sửa đổi (unmodifiable) từ một đối tượng Map đã cho.
static <K,​V> Map<K,​V> copyOf​(Map<? extends K,​? extends V> map)
Các phương thức tĩnh Map.of, Map.ofEntriesMap.copyOf cung cấp một cách thuận tiện để tạo các đối tượng Map không thể sửa đổi. Các đối tượng Map được tạo bởi các phương thức này có các đặc điểm sau:
  • Chúng không thể thay đổi được. Không thể thêm, xóa hoặc cập nhật khóa và giá trị. Việc gọi bất kỳ phương thức đột biến nào trên Map sẽ luôn khiến UnsupportedOperationException được ném ra. Tuy nhiên, nếu các khóa hoặc giá trị tự chúng có thể tự thay đổi, điều này có thể khiến Map hoạt động không nhất quán hoặc nội dung của nó có vẻ thay đổi.
  • Chúng không cho phép các khóa và giá trị null. Cố gắng tạo chúng bằng các khóa hoặc giá trị null sẽ dẫn đến NullPointerException.
  • Chúng có thể tuần tự hóa (serializable) nếu tất cả các khóa và giá trị đều có thể tuần tự hóa.
  • Không cho phép khoá trùng lặp trong tham số đầu vào. Nếu không IllegalArgumentException sẽ được ném ra.
  • Thứ tự lặp lại của các ánh xạ là không xác định và có thể thay đổi.

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);
        });
    }
}
Ví dụ: Đối tượng Map được tạo ra bởi phương thức tĩnh Map.of, Map.ofEntriesMap.copyOf là không thể sửa đổi (unmodifiable), nó không hỗ bất cứ hoạt động nào nhằm thay đổi dữ liệu của nó chẳng hạn 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
Thêm một ánh xạ (key, value) vào trong Map nếu key chưa tồn tại và trả về null. Ngược lại, giá trị mới sẽ được thay thế cho giá trị cũ tương ứng với khoá key, và trả về giá trị cũ.

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;
}
Phương thức này tương tự như phương thức put(key,value) nhưng nó chỉ hoạt động nếu key không tồn tại trong Map hoặc nó đang ánh xạ tới một giá trị null. Phương thức trả về null hoặc giá trị cũ.

8- putAll​(Map)

public void putAll​(Map<? extends K,​? extends V> m)
Sao chép tất cả các ánh xạ (mapping) từ đối tượng Map được chỉ định vào đối tượng Map hiện tại.

9- get​(Object key)

public V get​(Object key)
Trả về giá trị của ánh xạ tương ứng với key, hoặc trả về null nếu không tồn tại ánh xạ như vậy.

10- getOrDefault​(Object key, V defaultValue)

public default V getOrDefault(Object key, V defaultValue) // Java 8
Trả về giá trị của ánh xạ tương ứng với key, hoặc trả về defaultValue nếu không tồn tại ánh xạ như vậy.
Ví dụ:
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)
Trả về true nếu Map này chứa ánh xạ cho khóa được chỉ định.

12- containsValue​(Object value)

public boolean containsValue​(Object value)
Trả về true nếu Map này có ít nhất một ánh xạ tới giá trị được chỉ định.
Ví dụ: Một Map chứa các ánh xạ giữa tên thương hiệu và quốc gia, kiểm tra xem có hay không một thương hiệu đến từ một quốc gia nào đó.
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
Loại bỏ ánh xạ tương ứng với key ra khỏi Map. Trả về giá trị của ánh xạ hoặc trả về null nếu ánh xạ không tồn tại.

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;
     }
}
Loại bỏ ánh xạ (key,value) ra khỏi Map, và trả về true nếu nó thực sự tồn tại, ngược lại trả về false.

15- clear()

public void clear()  // Optional operation.
Loại bỏ tất cả các ánh xạ khỏi Map này. Map sẽ rỗng sau khi phương thức được gọi.

16- forEach​(BiConsumer)

public default void forEach​(BiConsumer<? super K,​? super V> action)
Thực hiện một hành động đã cho với từng cặp (key,value) của Map cho tới khi tất cả các cặp được xử lý hoặc ngoại lệ xẩy ra.
Ví dụ: Một đối tượng Map chứa các ánh xạ giữa tên quốc gia và dân số.
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()
Trả về một chế độ xem dưới dạng Set chứa tất cả các khoá của Map . Đối tượng Set và đối tượng Map hiện tại có liên quan với nhau, các thay đổi trên Map sẽ ảnh hưởng tới Set và ngược lại.
  1. Thêm hoặc loại bỏ một ánh xạ từ Map sẽ thêm hoặc loại bỏ một phần tử từ Set.
  2. Các phương thức loại bỏ các phần tử khỏi Set như Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear.. sẽ loại bỏ các ánh xạ tương ứng khỏi Map.
  3. Đối tượng Set này không hỗ trợ hoạt động Set.add, Set.addAll.
Ví dụ: Một đối tượng Map chứa các ánh xạ giữa tên quốc gia và dân số.
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()
Trả về một chế độ xem dưới dạng Set chứa tất cả các phần tử Map.Entry của Map . Đối tượng Set và đối tượng Map hiện tại có liên quan với nhau, các thay đổi trên Map sẽ ảnh hưởng tới Set và ngược lại.
  1. Thêm hoặc loại bỏ một ánh xạ từ Map sẽ thêm hoặc loại bỏ một phần tử từ Set.
  2. Các phương thức loại bỏ các phần tử khỏi Set như Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear.. sẽ loại bỏ các ánh xạ tương ứng khỏi Map.
  3. Đối tượng Set này không hỗ trợ hoạt động Set.add, Set.addAll.
Ví dụ: Một đối tượng Map chứa các ánh xạ giữa tên quốc gia và dân số.
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
Tiếp tục với ví dụ trên, chúng ta loại bỏ các quốc gia với dân số lớn hơn 200 (Triệu) ra khỏi đối tượng 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()
Trả về một chế độ xem dưới dạng Collection chứa tất cả các giá trị của Map. Đối tượng Collection và đối tượng Map hiện tại có liên quan với nhau, các thay đổi trên Map sẽ ảnh hưởng tới Collection và ngược lại.
  1. Thêm hoặc loại bỏ một ánh xạ từ Map sẽ thêm hoặc loại bỏ một phần tử từ Collection.
  2. Sửa đổi giá trị của một ánh xạ sẽ ảnh hưởng tới Collection.
  3. Các phương thức loại bỏ các phần tử khỏi Collection như Collection.iterator().remove, Collection.remove, Collection.removeAll, Collection.retainAll, Collection.clear.. sẽ loại bỏ các ánh xạ tương ứng khỏi Map.
  4. Đối tượng Collection này không hỗ trợ hoạt động Collection.add, Collection.addAll.
Ví dụ: Một đối tượng Map chứa các ánh xạ giữa tên thương hiệu (brand) và quốc gia. In ra các giá trị của đối tượng 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
Tiếp tục với ví dụ trên, loại bỏ các thương hiệu đến từ Trung Quốc ra khỏi đối tượng 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()
Trả về số lượng ánh xạ trong Map này. Nếu Map chứa nhiều hơn Integer.MAX_VALUE phần tử, trả về Integer.MAX_VALUE.

21- replace​(K key, V value)

public default V replace​(K key, V value)
Nếu tồn tại một ánh xạ với khoá key trong Map, nó sẽ được thay thế bởi ánh xạ (key,value) và trả về giá trị cũ, ngược lại không hành động nào được thực hiện và trả về null.
Ví dụ:
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)
Nếu ánh xạ (key,oldValue) thực sự tồn tại trong Map, nó sẽ được thay thế bởi ánh xạ (key,newValue) và trả về true, ngược lại không có hành động nào được thực hiện và trả về false.

23- replaceAll​(BiFunction)

public default void replaceAll​(BiFunction<? super K,​? super V,​? extends V> function)
Sử dụng function cho bởi tham số để thay thế giá trị cho tất cả các ánh xạ trong Map. Gọi phương thức trên sẽ tương đương với thực hiện đoạn mã sau:
for (Map.Entry<K, V> entry : map.entrySet()) {
    entry.setValue(function.apply(entry.getKey(), entry.getValue()));
}
Ví dụ: Một đối tượng Map chứa các ánh xạ giữa mã số nhân viên (Employee Number) và lương. Sử dụng phương thức replaceAll để tăng lương 50% cho mỗi nhân viên.
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;
    }
}

Xem thêm các chuyên mục:

Có thể bạn quan tâm

Đây là các khóa học trực tuyến bên ngoài website o7planning mà chúng tôi giới thiệu, nó có thể bao gồm các khóa học miễn phí hoặc giảm giá.