Java 中的`HashMap`迭代

原文：http://zetcode.com/java/hashmapiterate/

Java 教程中的HashMap迭代演示了如何迭代 Java 中的HashMap。

Java `HashMap`

HashMap是一个存储键值对的容器。每个键与一个值关联。 HashMap中的键必须唯一。 HashMap在其他编程语言中称为关联数组或词典。 HashMaps占用更多内存，因为每个值还有一个键。删除和插入操作需要固定的时间。 HashMaps可以存储空值。

Map.Entry表示HashMap中的键/值对。 HashMap的entrySet()返回包含在映射中的映射的Set视图。使用keySet()方法检索一组键。

使用`forEach()`的`HashMap`迭代

在第一个示例中，我们使用 Java8 forEach()方法来迭代HashMap的键值对。 forEach()方法对映射的每个元素执行给定的操作，直到所有元素都已处理或该操作引发异常。

HashMapForEach.java

package com.zetcode;

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

public class HashMapForEach {

    public static void main(String[] args) {

        Map<String, Integer> items = new HashMap<>();
        items.put("coins", 5);
        items.put("pens", 2);
        items.put("chairs", 7);

        items.forEach((k, v) -> {
            System.out.format("key: %s, value: %d%n", k, v);
        });
    }
}

在代码示例中，我们使用 lambda 表达式迭代了HashMap和forEach()。

Map<String, Integer> items = new HashMap<>();
items.put("coins", 5);
items.put("pens", 2);
items.put("chairs", 7);

用两对创建一个HashMap。

items.forEach((k, v) -> {
    System.out.format("key: %s, value: %d%n", k, v);
});

forEach()使代码更简洁。

使用流 API 的`HashMap`迭代

流是来自源的一系列元素，支持顺序和并行聚合操作。源可以是将数据提供给流的集合，IO 操作或数组。

HashMapStreamApi.java

package com.zetcode;

import java.util.HashMap;

public class HashMapStreamApi {

    public static void main(String[] args) {

        HashMap<String, Integer> items = new HashMap<>();
        items.put("coins", 5);
        items.put("pens", 2);
        items.put("chairs", 7);

        items.entrySet().stream().forEach(e -> {
            System.out.format("key: %s, value: %d%n", e.getKey(), e.getValue());
        });
    }
}

该示例使用流 API 在HashMap上进行迭代。我们使用entrySet()方法获得条目集，并使用stream()方法从条目集中获得流。稍后，我们使用forEach()遍历流。

使用增强的`for`循环的`HashMap`迭代

Java 5 中引入的增强的for循环可用于对HashMap进行迭代。

HashMapEnhancedFor.java

package com.zetcode;

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

public class HashMapEnhancedFor {

    public static void main(String[] args) {

        HashMap<String, Integer> items = new HashMap();
        items.put("coins", 5);
        items.put("pens", 2);
        items.put("chairs", 7);

        for (Map.Entry<String, Integer> pair: items.entrySet()) {
            System.out.format("key: %s, value: %d%n", pair.getKey(), pair.getValue());
        }
    }
}

在该示例中，我们迭代具有增强的for循环的HashMap。

for (Map.Entry<String, Integer> pair: items.entrySet()) {
    System.out.format("key: %s, value: %d%n", pair.getKey(), pair.getValue());
}

在每个for周期中，都将新的键值对分配给pair变量。

使用`Iterator`的`HashMap`迭代

在下面的示例中，我们使用Iterator和Map.Entry遍历HashMap。

HashMapIterator.java

package com.zetcode;

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

public class HashMapIterator {

    public static void main(String[] args) {

        Map<String, Integer> items = new HashMap<>();
        items.put("coins", 5);
        items.put("pens", 2);
        items.put("chairs", 7);

        Iterator<Map.Entry<String, Integer>> it = items.entrySet().iterator();

        while (it.hasNext()) {
            Map.Entry<String, Integer> pair = it.next();

            System.out.format("key: %s, value: %d%n", pair.getKey(), 
                    pair.getValue());
        }
    }
}

在代码示例中，我们检索键值对上的迭代器，并在while循环中对映射进行迭代。

Iterator<Map.Entry<String, Integer>> it = items.entrySet().iterator();

我们得到了迭代器对象。首先，我们使用entrySet()方法获得条目集，然后使用iterator()方法从条目集中获得迭代器。

while (it.hasNext()) {

如果迭代具有更多元素，则迭代器的hasNext()方法返回true。

Map.Entry<String, Integer> pair = it.next();

next方法返回下一对。

System.out.format("key: %s, value: %d", pair.getKey(), 
        pair.getValue());

使用getKey()和getValue()方法，我们可以获得键对和值。

以下示例是相同的，但是使用for循环而不是while。

HashMapIterator2.java

package com.zetcode;

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

public class HashMapIterator2 {

    public static void main(String[] args) {

        Map<String, Integer> items = new HashMap<>();
        items.put("coins", 5);
        items.put("pens", 2);
        items.put("chairs", 7);

        for (Iterator<Map.Entry<String, Integer>> it = items.entrySet().iterator(); 
                it.hasNext();) {

            Map.Entry<String, Integer> pair = it.next();
            System.out.format("key: %s, value: %d%n", pair.getKey(), pair.getValue());
        }
    }
}

在示例中，我们使用迭代器和for循环迭代HashMap。

在下一个示例中，我们使用HashMap的keySet()方法在迭代器上迭代键集，该方法返回此映射中包含的键的Set视图。此迭代效率较低。

HashMapIterator3.java

package com.zetcode;

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

public class HashMapIterator3 {

    public static void main(String[] args) {

        Map<String, Integer> items = new HashMap<>();
        items.put("coins", 5);
        items.put("pens", 2);
        items.put("chairs", 7);

        Iterator<String> it = items.keySet().iterator();

        while (it.hasNext()) {
            String key = it.next();

            System.out.format("key: %s, value: %d%n", key,
                    items.get(key));
        }
    }
}

在示例中，我们使用迭代器迭代映射的键集。在while循环中使用迭代器来遍历映射的键。以后使用该键获取相应的值。

Iterator<String> it = items.keySet().iterator();

我们得到键集的迭代器对象。

while (it.hasNext()) {

在while循环中，我们遍历HashMap的键。

String key = it.next();

检索下一个键。

System.out.format("key: %s, value: %d%n", key,
        items.get(key));

使用get()方法检索该值。

`HashMap`迭代键

我们可能只需要遍历HashMap的键。

HashMapKeys.java

package com.zetcode;

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

public class HashMapKeys {

    public static void main(String[] args) {

        Map<String, Integer> items = new HashMap<>();
        items.put("coins", 5);
        items.put("pens", 2);
        items.put("chairs", 7);

        Set<String> keys = items.keySet();

        keys.forEach(System.out::println);
    }
}

该示例迭代HashMap的键。

Set<String> keys = items.keySet();

用keySet()方法检索HashMap的键，该方法返回键Set。键必须唯一；因此，我们有一个Set。 Set是一个不包含重复元素的集合。

keys.forEach(System.out::println);

我们用forEach()遍历键集。

`HashMap`迭代值

我们可能只需要迭代HashMap的值。

HashMapValues.java

package com.zetcode;

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

public class HashMapValues {

    public static void main(String[] args) {

        Map<String, Integer> items = new HashMap<>();
        items.put("coins", 5);
        items.put("pens", 2);
        items.put("chairs", 7);

        Collection<Integer> vals = items.values();

        vals.forEach(System.out::println);
    }
}

该示例迭代HashMap的值。

Collection<Integer> vals = items.values();

HashMap的值通过values()方法检索。

vals.forEach(System.out::println);

我们使用forEach()遍历集合。

在包含`ArrayList`的`HashMap`上进行迭代

HashMap可以包含列表作为值。在这种情况下，我们需要一个额外的循环。

HashMapList.java

package com.zetcode;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class HashMapList {

    public static void main(String[] args) {

        Map<String, List<String>> m = new HashMap<>();

        m.put("colours", Arrays.asList("red", "green", "blue"));
        m.put("sizes", Arrays.asList("small", "medium", "big"));

        for (Map.Entry<String, List<String>> me : m.entrySet()) {

            String key = me.getKey();
            List<String> values = me.getValue();

            System.out.println("Key: " + key);
            System.out.print("Values: ");

            for (String e : values) {

                System.out.printf("%s ", e);
            }

            System.out.println();
        }
    }
}

在示例中，我们迭代包含ArrayLists作为值的HashMap。我们使用两个for循环。

Map<String, List<String>> m = new HashMap<>();

m.put("colours", Arrays.asList("red", "green", "blue"));
m.put("sizes", Arrays.asList("small", "medium", "big"));

我们定义一个以ArrayLists为值的HashMap。

for (Map.Entry<String, List<String>> me : m.entrySet()) {

使用增强的for循环，我们遍历条目集。每个条目都有一个键字符串和列表值。

String key = me.getKey();

我们通过getKey()方法获得键。

List<String> values = me.getValue();

我们用getValue()获得列表。

for (String e : values) {

    System.out.printf("%s ", e);
}

在内部for循环中，我们遍历值列表。

`HashMap`过滤

可以使用流 API 的filter()方法过滤HashMap。

HashMapFilter.java

package com.zetcode;

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class HashMapFilter {

    public static void main(String[] args) {

        Map<String, String> capitals = new HashMap<>();

        capitals.put("svk", "Bratislava");
        capitals.put("ger", "Berlin");
        capitals.put("hun", "Budapest");        
        capitals.put("czk", "Prague");
        capitals.put("pol", "Warsaw");
        capitals.put("ita", "Rome");

        Map<String, String> filteredCapitals = capitals.entrySet().stream()
                .filter(map ->  map.getValue().startsWith("B"))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

        filteredCapitals.entrySet().forEach(System.out::println);
    }
}

在此示例中，我们有一个国家及其首都的映射。我们将映射过滤为仅包含值以 B 开头的对。

在本教程中，我们展示了如何迭代 Java 中的HashMap。您可能也对相关教程感兴趣： Java HashMap教程， Java8 forEach教程，用 Java 读取文本文件，读写 ICO Java 中的图像， Java Swing 教程，Java 教程，用 Java 显示图像。

我们一直在努力

apachecn/AiLearning

Java 中的HashMap迭代

Java HashMap

使用forEach()的HashMap迭代

使用流 API 的HashMap迭代

使用增强的for循环的HashMap迭代

使用Iterator的HashMap迭代

HashMap迭代键

HashMap迭代值

在包含ArrayList的HashMap上进行迭代

HashMap过滤