MostFrequent метод сумки ADT (абстрактные типы данных)

Question

Я пытаюсь реализовать метод с именем mostFrequent в сумке, которая находит наиболее часто встречающийся объект в сумке. Например, если B = {Боб, Джо, Боб, Нед, Боб, Боб}, то метод возвращает Боба. Подсказка: метод O(n^2).

public E MostFrequent (Bag<E> B){ 
// implementation here
}

Adt из сумки является следующим:

package edu.uprm.ece.icom4035.bag;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class StaticBag implements Bag {

    private int currentSize;

    private Object elements[];

    private class BagIterator implements Iterator {

        private int currentPosition;

        public BagIterator(){
            this.currentPosition = 0;
        }

        @Override
        public boolean hasNext() {
            return this.currentPosition < currentSize;
        }

        @Override
        public Object next() {
            if (hasNext()){
                return elements[this.currentPosition++];
            }
            else {
                throw new NoSuchElementException();
            }
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

    }

    public StaticBag(int maxSize){
        if (maxSize < 1){
            throw new IllegalArgumentException("Max size must be at least 1.");
        }

        this.currentSize = 0;
        this.elements = new Object[maxSize];
    }

    @Override
    public void add(Object obj) {
        if (obj == null){
            throw new IllegalArgumentException("Value cannot be null.");
        }
        else if (this.size() == this.elements.length){
            throw new IllegalStateException("Bag is full.");
        }
        else {
            this.elements[this.currentSize++] = obj;
        }
    }

    @Override
    public boolean erase(Object obj) {
        int target = -1;
        for (int i=0; i < this.size(); ++i){
            if (this.elements[i].equals(obj)){
                target = i;
                break;
            }
        }
        if (target == -1){
            return false;
        }
        else {
            this.elements[target] = this.elements[this.currentSize-1];
            this.elements[this.currentSize-1] = null;
            this.currentSize--;
            return true;
        }


    }

    @Override
    public int eraseAll(Object obj) {
        int copies = 0;
        while(this.erase(obj)){
            copies++;
        }

        return copies;
    }

    @Override
    public int count(Object obj) {
        int counter = 0;
        for (int i=0; i < this.size(); ++i){
            if (elements[i].equals(obj)){
                counter++;
            }
        }
        return counter;
    }

    @Override
    public void clear() {
        for (int i=0; i < this.size(); ++i){
            this.elements[i] = null;
        }
        this.currentSize = 0;
    }

    @Override
    public boolean isEmpty() {
        return this.size() == 0;
    }

    @Override
    public int size() {
        return this.currentSize;
    }

    @Override
    public boolean isMember(Object obj) {
        return this.count(obj) > 0;
    }

    @Override
    public Iterator iterator() {
        return new BagIterator();
    }

}

метод должен быть реализован наиболее эффективным способом и, если возможно, с использованием методов, уже указанных в пакете adt

То, что я пытался это следующее:

public E MostFrequent(Bag<E> B){
    for(E e : B){
        int counter = B.count(e)

    }
}

но я, кажется, не думаю о способе вернуть объект с большим количеством частот внутри цикла