Question

我想实现一个类似于subList（a，b）的方法，但是当＆gt; b时可以使用。 subList（a，b）和subList（b，a）应返回相同作用域的List视图，但迭代和计算方式不同。在＆gt; b的情况下，视图应该颠倒。有可能吗？

我现在的解决方案非常原始。第一个问题是，对于＆gt; b的情况下的子列表（a，b）没有相应地调整编号（对于remove或get方法的使用）。但更重要的是，反向的List视图实际上是一个副本，而不是实际视图，我甚至不知道如何解决这个问题。

@SuppressWarnings("serial")
class ReverseLinkedList <T> extends LinkedList<T>
{
    ReverseLinkedList(final List<T> l)
    {
        super(l); // problem, I want a view not a copy
    }
    @Override
    public Iterator<T> iterator()
    {
        return new Iterator<T>()
        {
            ListIterator<T> listIter = listIterator(size());
            public boolean hasNext() 
            { 
                return listIter.hasPrevious(); 
            }
            public T next() 
            { 
                return listIter.previous(); 
            }
            public void remove() 
            { 
                listIter.remove(); 
            }  
        };
    }
}

@SuppressWarnings("serial")
class CleverList<T> extends LinkedList<T>
{
    @Override
    public List<T> subList(int fromIndex, int toIndex)
    {
        if ( fromIndex < toIndex )
        {
            return super.subList(fromIndex, toIndex);
        }
        else
        {
            return new ReverseLinkedList<T>(super.subList(toIndex-1,fromIndex-1));
        }
    }
}

现在如何运作：

    CleverList<Integer> list = new CleverList<Integer>();
    for ( int i=1; i<=10; ++i )
    {
        list.add(i);
    }
    List<Integer> listA = list.subList(2,8);
    printList(listA);
    // "3 4 5 6 7 8 " ok
    List<Integer> listB = list.subList(8,2);
    printList(listB);
    // "7 6 5 4 3 2 " ok

    listB.remove(2);
    printList(listB);
    // "7 6 5 3 2 " not ok, the point was to remove "5"
    printList(list);
    // "1 2 3 4 5 6 7 8 9 10 " not ok, nothing was removed

Answer 1

一种可能的解决方案是使用组合而不是继承。它看起来像这样：

class ReverseLinkedList<T> implements List<T> {
    // A reference to the actual list.
    private final List<T> list;

    public ReverseLinkedList(final List<T> list) {
        // Does not create a copy.
        // Stores a reference to the original list instead.
        this.list = list;
    }

    @Override 
    public T get(int index) {
        // Adjusts the index and calls the method on an actual list.
        return list.get(list.size() - 1 - index);
    }

    //And so on for all the other methods declared in the List interface...

}

它完全符合您的需要：它不会创建传递给构造函数的列表的副本，您可以控制所有方法（获取，删除等）以正确调整索引。这种方法的缺点是需要编写的代码量：List接口中声明的每个方法都必须在ReverseLinkedList类中定义。

是否有可能实现类似于subList（a，b）的方法，但是当＆gt; b时有效？

1 个答案: