Question

I have a class ‘Deck’, that creates an ArrayList called deck.
I’m trying to create a nested Iterator class that traverses the Cards in reverse order.

public class Deck {

    //Nested Iterator class to traverse the Cards in reverse order
    public abstract class DeckIterator implements Iterator<Card>{

        ListIterator it = deck.listIterator(deck.size());

        //Iterate in reverse.
        while(it.hasPrevious()) { //errors
            //System.out.println(it.previous());
            return it.previous();
        }  
    }
}

I have tried the suggestions below but I am still having no luck…
Instead of copying One ArrayList to another in reverse order, i’d rather Iterate over the existing ArrayList in the Outer Class. What is the most efficient way of doing this?

Answer 1

Firstly make Deck implement Iterable<Card>, this will require you to implement the iterator() method. Make that method return an instance of your nested DeckIterator class.

@Override
public Iterator<Card> iterator()
{
    return new DeckIterator(deck);
}

Then make DeckIterator implement Iterator<Card> and implement the hasNext(), next() and remove() methods.

private static class DeckIterator implements Iterator<Card>
{

private int nextCard;
private final List<Card> cards;

public DeckIterator(List<Card> cards)
{
    this.cards = cards;
    this.nextCard = cards.size() - 1;
}

@Override
public boolean hasNext()
{
    if (nextCard < 0)
        return false;
    return true;
}

/**
 * {@inheritDoc}
 */
@Override
public Card next()
{
    if (hasNext())
        return cards.get(nextCard--);
    return null;
}

/**
 * {@inheritDoc}
 */
@Override
public void remove()
{

}
}

Then use,

Iterator<Card> iterator = yourDeck.iterator();
while (iterator.hasNext())
{
 Card card = iterator.next();
}

To iterate backwards over the deck.

However you dont need to create your own Iterator if you just want to iterate in reverse ListIterator can do it for you.

ArrayList<Card> deck = new ArrayList<Card>();
// Do whatever you do with your deck :P

ListIterator<Card> li = deck.listIterator(deck.size());

// Iterate in reverse.
while(li.hasPrevious()) 
{
  Card card = li.previous();
  // Do stuff with the card
}