Question

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

Answer 1

您可以创建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(); }
}

然后，您将覆盖iterator()中的RingList<T>方法

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

Answer 2

对于第一部分，或许只询问n % list.size()？

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

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

}

然后获取方法：

/*
 * 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），但是我没有看到没有创建List的方法 - List的转换。

Answer 4

扩展ArrayList类并按照您喜欢的方式实现get(Integer)方法。我认为这是'最佳实践'。

Java列表最佳实践

4 个答案: