Java list最佳实践

Question

我需要一些容器来保存元素，所以，如果我尝试获取size()+i元素，我将获得元素编号i。或者使用迭代器，它在尝试获取最后一个元素后从容器的开头开始？这两种情况下的最佳实践是什么？我的意思是性能和易用性。

Answer 1

对于第一部分，也许只需要n % list.size()就可以了？

对于迭代器部分，创建一个包装迭代器的类，当next()返回null时，只需让它重置迭代器。

Answer 2

您可以创建一个简单的ArrayList<T>子类并覆盖get(int n)方法，如下所示：

public T get(int n)
{
    return super.get(n % this.size());
}

至于迭代器，您需要实现自己的迭代器，这应该不是那么困难。

编辑：

假设您的新类名为RingList，下面是一个示例RingIterator (未经测试)：

public class RingIterator<T> implements Iterator<T>
{
    private int cur = 0;
    private RingList<T> coll = null;

    protected RingIterator(RingList<T> coll) { this.coll = coll; }
    public boolean hasNext() { return size() > 0; }
    public T next() 
    { 
        if (!hasNext()) 
            throw new NoSuchElementException();
        int i=cur++; 
        cur=cur%size(); 
        return coll.get(i);
    }
    public void remove() { throw new UnsupportedOperationException(); }
}

然后将RingList<T>中的iterator()方法重写为

public Iterator<T> iterator()
{
    return new RingIterator(this);
}

Answer 3

谢谢大家，这就是我所创造的：

public class RingIterator<E> {
private List<E> _lst;
private ListIterator<E> _lstIter;

public RingIterator(ListIterator<E> iter, List<E> lst) {
    super();
    _lstIter = iter;
    _lst = lst;
}

public E next() {
    if(!_lstIter.hasNext())
        _lstIter = _lst.listIterator();
    return _lstIter.next();
}

public E previous() {
    if(!_lstIter.hasPrevious())
        _lstIter = _lst.listIterator(_lst.size());
    return _lstIter.previous();
}

}

那么get方法：

/*
 * Returns ring iterator,
 * use it with 'ParentClass' type.
 */
public RingIterator<SubClass> getRingIter(int i) {
    return new RingIterator(_subs.listIterator(i),_subs);
}

我使用它：

RingIterator<SubClass> ri = _logic.getRingIter(1);
ParentClass ai = ri.next();

我希望通过getRingIter只提供类型ParentClass (而不是SubClass)，但我没有看到一种方法来实现这一点，而不创建列表-列表的转换。