Question

我有一个类'Deck'，它创建一个名为deck的ArrayList。我正在尝试创建一个嵌套的迭代器类，它以相反的顺序遍历卡片。

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();
        }  
    }
}

我已尝试过以下建议，但我仍然没有运气...... 而不是以相反的顺序将One ArrayList复制到另一个，我宁愿迭代外类中的现有ArrayList。这样做最有效的方法是什么？

Answer 1

首先让Deck实施Iterable<Card>，这将要求您实施iterator()方法。使该方法返回嵌套DeckIterator类的实例。

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

然后让DeckIterator实施Iterator<Card>并实施hasNext()，next()和remove()方法。

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()
{

}
}

然后使用，

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

在甲板上向后迭代。

但是，如果您只想反向迭代Iterator，则无需创建自己的ListIterator即可。

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
}

Answer 2

Iterator是接口，因此您需要在其中实现方法。有关详细信息，请参阅this SO question。

但是，也许最简单的方法是在Deck中创建一个方法

以相反的顺序创建集合的副本
通过集合

请注意，由于您现在正在迭代原始集合的副本，因此应该不会受到从桌面添加/删除卡片的其他线程的影响。

Answer 3

使用Guava，您可以反转列表并迭代结果。看着： http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/Lists.html#reverse%28java.util.List%29

这应该很容易，不应该导致太多变化/重构。

嵌套的迭代器类

3 个答案: