Question

Would someone help please, with code to finish. Iterator and entrySet, I need help. please
```

package coll.MapSet;

import java.util.*;

public class MapSet extends AbstractMap> implements Iterable  {

    private Map> mapset = new HashMap<>();

    /*
    Implement addValue such that calling this method adds the given
    value to the HashSet associated with the given key.
    This method must have the following signature:
    addValue(K key, V value)
     */

    public void addValue(K key, V value) {

        // If the set has the key, get teh key and set the value
        if (mapset.containsKey(key)) {
            mapset.get(key).add(value);
        } else {
            // or else create a new set and add the value, then assign the key to the set
            HashSet set = new HashSet<>();
            set.add(value);
            mapset.put(key, set);
        }

    }

    /*
    Implement the iterator such that only values V are traversed.
    Values are traversed first in descending order of the size of
    HashSet objects associated with keys, and then in the iterator
    order for the HashSet.
     */

    @Override
    public Iterator iterator() {
        return null;
    }

    /*
    This method must be implemented and overridden from AbstractMap.
    It should simply return a Set> of the MapSet.
     */

    @Override
    public Set>> entrySet() {
        return null;
    }

    public static void main(String[] args) {
        MapSet 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);
        }
    }

}

```

Answer 1

import java.util.*;
import java.lang.*;
class Main{
public static void main(String args[]){
// To traverse the values normally
addValue();
// To Traverse the values in DescendingOrder
descendingOrder();
  

}
public static void addValue(){
Map<Integer,String> map=new HashMap<Integer,String>();
map.put(100,"A");
map.put(101,"B");
map.put(102,"C");
//Elements can traverse in any order
System.out.println("Elements can traverse in any order");
for(Map.Entry m:map.entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
}
public static void descendingOrder(){
Map<Integer,String> map=new HashMap<Integer,String>();
map.put(100,"A");
map.put(101,"B");
map.put(102,"C");
System.out.println("Elements can traverse in DescendingOrder ");
//Returns a Set view of the mappings contained in this map
map.entrySet()
//Returns a sequential Stream with this collection as its source
.stream()
//Sorted according to the provided Comparator
.sorted(Map.Entry.comparingByKey(Comparator.reverseOrder()))
//Performs an action for each element of this stream
.forEach(System.out::println);
}

}