Java-按降序遍历映射集，返回所需的输出

我必须完成以下工作：

要求：

在包coll.MapSet中，实现一个扩展AbstractMap>并实现Iterable的新类映射集，其中K表示泛型键，V表示泛型值：

public class MapSet<K, V> extends AbstractMap<K, HashSet<V>> implements Iterable<V>

迭代器

实现迭代器，以便只遍历值V。首先按照与键关联的HashSet对象大小的降序遍历值，然后按照HashSet的迭代器顺序遍历值

入口集

必须从AbstractMap实现并重写此方法。它应该只返回地图集的一个集合>。 输出

示例输出如下所示。对于给定的主管道：

public static void main(String[] args) {

    MapSet<String, Integer> map = new MapSet<>();

    map.addValue("B", 4);
    map.addValue("A", 0);
    map.addValue("A", 1);
    map.addValue("B", 3);
    map.addValue("A", 2);

    for (Integer value : map) {
        System.out.println(value);
    }
}

首先遍历键“A”中的值，因为它具有最多的关联元素。“A”中的值然后按照其关联哈希集的迭代器的顺序进行遍历。接下来，对“B”重复遍历

我已经完成了下面的工作，但是我真的不确定从哪里开始使用迭代器

package coll.MapSet;

import java.util.*;
import java.lang.Iterable;

public class MapSet<K, V> extends AbstractMap<K, HashSet<V>> implements Iterable<V> {

    private Map<K, HashSet<V>> contents = new HashMap<>();

    public void addValue(K key, V value) {
            if(contents.containsKey(key)){
                    contents.get(key).add(value);
            }
            else{
                    HashSet<V> set = new HashSet<>();
                    set.add(value);
                    contents.put(key, set);
            }
    }

    @Override
    public Iterator<V> iterator(){
            return new Iterator<>() {
                    private HashMap<K, Integer> sizeMap = new HashMap<>();
                    private List<V> orderedValueList = new ArrayList<>();

//I am really unsure what to do with the iterator to get the required output. Any help would be appreciated. 

                    @Override
                    public boolean hasNext() {
                            return null;
                    }

                    @Override
                    public V next() {
                            if (this.hasNext()) {
                                    return null;
                            } else {
                                    return null;
                            }
                    }
            };

    @Override
    public Set<Entry<K, HashSet<V>>> entrySet(){
            return contents.entrySet();
    }
}

package coll.MapSet；
导入java.util.*；
导入java.lang.Iterable；
公共类映射集扩展AbstractMap实现Iterable{
私有映射内容=新HashMap（）；
公共void addValue（K键，V值）{
if（目录.容器（键））{
contents.get（key）、add（value）；
}
否则{
HashSet=newhashset（）；
增加（价值）；
内容。放置（键，集合）；
}
}
@凌驾
公共迭代器迭代器（）{
返回新的迭代器（）{
私有HashMap sizeMap=newhashmap（）；
private List orderedValueList=new ArrayList（）；
//我真的不确定如何使用迭代器来获得所需的输出。如果您能提供任何帮助，我将不胜感激。
@凌驾
公共布尔hasNext（）{
返回null；
}
@凌驾
公共V next（）{
if（this.hasNext（））{
返回null；
}否则{
返回null；
}
}
};
@凌驾
公共集入口集（）{
返回contents.entrySet（）；
}
}

首先，您应该按照与键关联的HashSet对象大小的降序获得值集合：

contents.values().stream().sorted(Comparator.comparingInt(Set<?>::size).reversed())

试试这个：

@Override
public Iterator<V> iterator() {
    return contents.values().stream().sorted(Comparator.comparingInt(Set<?>::size).reversed())
            .flatMap(Collection::stream).iterator();
}

@覆盖
公共迭代器迭代器（）{
返回contents.values（）.stream（）.sorted（Comparator.comparingInt（Set:：size）.reversed（））
.flatMap（Collection:：stream）.iterator（）；
}

您可以将

addValue

方法简化为

contents.computeIfAbsent（key，x->new HashSet（））.add（value）；

contents.values().stream().sorted(Comparator.comparingInt(Set<?>::size).reversed())

flatMap(Collection::stream).iterator();

@Override
public Iterator<V> iterator() {
    return contents.values().stream().sorted(Comparator.comparingInt(Set<?>::size).reversed())
            .flatMap(Collection::stream).iterator();
}