Java ListIterator澄清

Question

I am working on implementing a method that checks for number of max number consecutive equal elements in an ArrayList:

public class ArrayReader<E> {

    public int getMaxConsecutiveEqualElements(ArrayList<E> array){

        if (array == null){
            throw new IllegalArgumentException("Array is null");
        }
        if (array.size() == 0){
            throw  new IllegalArgumentException("Array has 0 elements");
        }

        int max = 1;
        int currentMax = 0;
        int index = 0;
        ListIterator<E> listIterator = array.listIterator(0);

        while (listIterator.hasNext()){
            E currentItem = array.get(index);
            E nextItem = listIterator.next();

            System.out.println("Current item: "
                    + "index (" + listIterator.previousIndex() + ") "
                    + currentItem.toString() + "   Next item: "
                    + "index (" + (listIterator.previousIndex() + 1) + ") "
                    + nextItem.toString());

            if (currentItem.equals(nextItem)){
                currentMax++;
                if (currentMax > max){
                    max = currentMax;
                }
            } else {
                currentMax = 1;
            }

            index++;
        }

        return max;
    }

}

public static void main(String[] args){

        ArrayList<Integer> array = new ArrayList<>();
        array.add(2);
        array.add(2);
        array.add(2);
        array.add(5);
        array.add(5);
        array.add(5);
        array.add(5);

        ArrayReader<Integer> intArrayReader = new ArrayReader<>();
        System.out.println(intArrayReader.getMaxConsecutiveEqualElements(array));

    }

However, the output I am getting indicates that it isn't truly comparing the current element to the next:

Current item: index (0) 2   Next item: index (1) 2
Current item: index (1) 2   Next item: index (2) 2
Current item: index (2) 2   Next item: index (3) 2
Current item: index (3) 5   Next item: index (4) 5
Current item: index (4) 5   Next item: index (5) 5
Current item: index (5) 5   Next item: index (6) 5
Current item: index (6) 5   Next item: index (7) 5
7

What is wrong with this implementation?

Answer 1

E currentItem = array.get(index);

E nextItem = listIterator.next();

Both of these statements will return you 0th element in the first iteration, 1st in the next and so on. You are ending up comparing each element with itself and not the other way.

Answer 2

However, the output I am getting indicates that it isn't truly comparing the current element to the next

Indeed, it will be comparing one item with itself in each case.

After all, you start with index = 0 and on the first iteration you use array.get(index) and listIterator.next() , both of which will return the first element.

A better approach (IMO) would be to get rid of the index part entirely, and even remove the ListIterator bit. Just use:

Iterator<E> iterator = array.iterator();
if (!iterator.hasNext()) {
    return 0;
}
E current = iterator.next();
while (iterator.hasNext()) {
    E next = iterator.next();
    // Do comparisons here
    current = next;
}

Then you can change your method to be much more general:

public int getMaxConsecutiveEqualElements(Iterable<E> sequence)

You can't take the count now, of course - but you can throw an exception instead of returning 0 if the first call to hasNext() returns false, if you want.

Answer 3

I suppose you have a problem here :

        E currentItem = array.get(index);
        E nextItem = listIterator.next();

Because when the while loop starts your index is 0 your iterator points to first element (with index 0). Then next() moves your iterator and your increment the inex. So you compare every element with itself.

Hope this helps.

Answer 4

You are always comparing the same index with itself. For example in the first iteration of your loop index is 0 and listIterator.next() will also return the 0th element of your list.

You can try something like this (assuming you have no null values in your list):

int max = 0;
int currentMax = 0;
E lastItem = null;

for(E item : array) {

    if(item.equals(lastItem)) {
        // Count maximum up
        currentMax++;
        if(currentMax > max) {
            max = currentMax;
        }
    else {
        // Reset if consecutive sequence ends
        currentMax = 0;
    }

    // Save item for next round
    lastItem = item;
}

Answer 5

The problem lies here:

E currentItem = array.get(index);
E nextItem = listIterator.next();

The nextItem variable is the same as the currentItem every time.