Применение интерфейса Multiset классом HashMultiset

interface Multiset<E> {
 
    /**
     * Add an element to the multiset.
     * It increases the multiplicity of the element by 1.
     */
    void add(E elem);
 
    /**
     * Remove an element from the multiset.
     * It decreases the multiplicity of the element by 1.
     */
    void remove(E elem);
 
    /**
     * Union this multiset with another one. The result is the modified multiset (this).
     * It will contain all elements that are present in at least one of the initial multisets.
     * The multiplicity of each element is equal to the maximum multiplicity of
     * the corresponding elements in both multisets.
     */
    void union(Multiset<E> other);
 
    /**
     * Intersect this multiset with another one. The result is the modified multiset (this).
     * It will contain all elements that are present in the both multisets.
     * The multiplicity of each element is equal to the minimum multiplicity of
     * the corresponding elements in the intersecting multisets.
     */
    void intersect(Multiset<E> other);
 
    /**
     * Returns multiplicity of the given element.
     * If the set doesn't contain it, the multiplicity is 0
     */
    int getMultiplicity(E elem);
 
    /**
     * Check the multiset contains an element,
     * i.e. the multiplicity > 0
     */
    boolean contains(E elem);
 
    /**
     * The number of unique elements
     */
    int numberOfUniqueElements();
 
    /**
     * The size of the multiset, including repeated elements
     */
    int size();
 
    /**
     * The set of unique elements (without repeating)
     */
    Set<E> toSet();
 
    /**
     * The list of all elements (with repetitions)
     */
    public List<E> toList();                  //добавлен от безысходности (дабы упростить применение union)
 
    /**
     * Secret method to get access to the map
     */
    public Map<E, Integer> giveMeMyMap();      //добавлен от безысходности (дабы упростить применение intersect)
}

class HashMultiset<E> implements Multiset<E> {
 
    private Map<E, Integer> map = new HashMap<>();
 
    @Override
    public List<E> toList() {
        ArrayList<E> arrayList = new ArrayList<>();
        for (Map.Entry<E, Integer> pair : map.entrySet()) {
            for (int i = 0; i < pair.getValue(); i++) {
                arrayList.add(pair.getKey());
            }
        }
        return arrayList;
    }
 
    @Override
    public Map<E, Integer> giveMeMyMap() {
        return map;
    }
 
    @Override
    public void add(E elem) {
        int multiplicity = 1;
 
        if (map.containsKey(elem)) {
            map.put(elem, getMultiplicity(elem) + 1);
            return;
        }
        map.put(elem, multiplicity);
    }
 
    @Override
    public void remove(E elem) {
        if (map.containsKey(elem)) {
            map.put(elem, getMultiplicity(elem) - 1);
            if (getMultiplicity(elem) == 0) {
                map.remove(elem, 0);
            }
        }
    }
 
    @Override
    public void union(Multiset<E> other) {
        for (E key : other.toList()) {
            add(key);
        }
    }
 
    @Override
    public void intersect(Multiset<E> other) {
        //Тут что-то сложно совсем
        for (Map.Entry<E, Integer> pair : map.entrySet()) {
            for (Map.Entry<E, Integer> pair2 : other.giveMeMyMap().entrySet()) {
                if (!pair.getKey().equals(pair2.getKey())) {
                    map.remove(pair.getKey());
                }
                else {
                    if (pair.getValue() > pair2.getValue()) {
                        pair.setValue(pair2.getValue());
                    }
                    break;
                }
            }
        }
    }
 
    @Override
    public int getMultiplicity(E elem) {
        return contains(elem) ? map.get(elem) : 0;
    }
 
    @Override
    public boolean contains(E elem) {
        return map.containsKey(elem);
    }
 
    @Override
    public int numberOfUniqueElements() {
        return map.size();
    }
 
    @Override
    public int size() {
        int size = 0;
        for (int i : map.values()) {
            size += i;
        }
        return size;
    }
 
    @Override
    public Set<E> toSet() {
        return map.keySet();
    }
}