Java HashMap 迭代

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

Java HashMap

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

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

使用forEach()HashMap迭代

在第一个示例中,我们使用 Java 8 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 表达式迭代了HashMapforEach()

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()使代码更简洁。

使用 Stream 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变量。

使用IteratorHashMap迭代

在下面的示例中,我们使用IteratorMap.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's 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。 密钥必须唯一; 因此,我们有一个SetSet是一个不包含重复元素的集合。

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()遍历集合。

在包含ArrayListHashMap上进行迭代

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过滤

可以使用 Stream 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

赞(0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

Java 教程