使用匿名内部类遍历一个map集合

可以使用以下代码来遍历一个Map集合：

Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);

// 遍历Map集合
map.forEach(new BiConsumer<String, Integer>() {
    @Override
    public void accept(String key, Integer value) {
        System.out.println(key + " = " + value);
    }
});

上面的代码中使用了匿名内部类来实现 `BiConsumer` 接口，该接口包含了一个 `accept` 方法，用于接收Map中的键值对。在 `accept` 方法中可以对键值对进行处理，例如打印输出。

相关问题

使用Java 创建一个 map接口的实现类， 并对该类进行增删改查操作。对于遍历操作， 要求写出至少包含 for的普通、增强循环及利用迭代器对象实习对该双列集合的元素实现遍历的4种方法。

在Java中，我们可以创建一个`HashMap`类作为Map接口的一个具体实现，它内部使用哈希表数据结构提供高效的键值对存储。以下是一个简单的`HashMap`实现，并演示了如何进行增删改查以及遍历操作：

import java.util.*;

public class MyHashMap<K, V> implements Map<K, V> {
    private int capacity = 16;
    private Entry[] table;

    // 其他构造函数、equals、hashCode等方法省略...

    @Override
    public void put(K key, V value) {
        if (table == null || table.length == capacity * 3 / 4) {
            resize(capacity *= 2);
        }
        int hash = key.hashCode();
        int index = hash % table.length;
        while (table[index] != null && !key.equals(table[index].getKey())) {
            index = (index + 1) % table.length;
        }
        table[index] = new Entry<>(key, value);
    }

    // 删除、查找等方法类似，省略...

    // 遍历四种方法
    // 普通for循环遍历
    public void traverseForLoop() {
        for (Entry<K, V> entry : table) {
            if (entry != null) {
                System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
            }
        }
    }

    // 增强for循环遍历
    public void traverseEnhancedForLoop() {
        for (Entry<K, V> entry : table) {
            if (entry != null) {
                System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
            }
        }
    }

    // 迭代器遍历
    public void traverseIterator() {
        Iterator<Entry<K, V>> iterator = table.iterator();
        while (iterator.hasNext()) {
            Entry<K, V> entry = iterator.next();
            if (entry != null) {
                System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
            }
        }
    }

    // 利用ListIterator遍历
    public void traverseListIterator() {
        List<_ENTRY> list = new ArrayList<>();
        for (Entry<K, V> entry : table) {
            if (entry != null) {
                list.add(entry);
            }
        }
        ListIterator<Entry<K, V>> listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Entry<K, V> entry = listIterator.next();
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }

    // 定义一个匿名内部类简化Entry的定义
    static class Entry<K, V> extends AbstractMap.SimpleEntry<K, V> {
        // 实体代码省略...
    }

    private void resize(int newCapacity) {
        // 扩展数组并迁移数据到新数组的省略部分...
    }
}

选择合适的Map集合保存5位学员的学号和姓名，然后按照学号的自然顺序的倒叙将这些键值对一一打印出来。要求如下： 1）创建TreeMap集合。 2）使用put()方法将学号("1""2""3""4""5")和姓名("Lucy""John""Smith""Aimme""Tom")存储到Map中，存的时候可以打乱顺序观察排序后的效果。可重复插入相同的value，不同的key观察结果。 3）使用两种方法遍历集合

好的，我的回答如下：

import java.util.Map;
import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        // 创建TreeMap集合
        Map<String, String> map = new TreeMap<>((o1, o2) -> o2.compareTo(o1));
        // 使用put()方法将学号和姓名存储到Map中
        map.put("1", "Lucy");
        map.put("3", "Smith");
        map.put("2", "John");
        map.put("5", "Tom");
        map.put("4", "Aimme");
        // 遍历集合方法一
        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
        // 遍历集合方法二
        map.forEach((key, value) -> System.out.println(key + " " + value));
    }
}

输出结果为：

5 Tom
4 Aimme
3 Smith
2 John
1 Lucy

解释一下代码：

1. 首先创建了一个 `TreeMap` 对象，同时我们需要自定义 `Comparator` 对象来实现按照学号的自然顺序的倒叙排序，所以我们在创建 `TreeMap` 对象时传入了一个 `Comparator` 对象。这里用的是 lambda 表达式，也可以使用匿名内部类来实现。
2. 使用 `put()` 方法将学号和姓名存储到 `Map` 中。这里我们按照题目要求打乱顺序存储，同时可以重复插入相同的值。
3. 遍历集合有两种方法，第一种是使用 `entrySet()` 方法获取 `Map` 对象的 `Set` 视图，然后使用增强型 `for` 循环遍历。第二种是使用 `forEach()` 方法来遍历，这个方法是 `Map` 接口中的默认方法，可以直接使用。

最后输出的结果是按照学号的自然顺序的倒叙排列的。