当前位置：极客教程 > Java > Java 教程 > Java HashMap 迭代

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 表达式迭代了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()使代码更简洁。

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

使用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'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。 密钥必须唯一； 因此，我们有一个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过滤

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

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

Java 精品教程