制作一个自己保持相反顺序的列表

Question

我的任务是解决以下问题：创建一个将实现 List 的集合 ReverseList。通过使用 for 循环 (for(E e:list)) 迭代 ReverseList 类型的对象列表，我们将按照与输入顺序相反的顺序获取项目。 在从 ArrayList 扩展时实现以下类，

所以本质上我需要创建一个不遵循插入自然顺序的集合 让我澄清一下，我不想在创建列表后反转列表并使用 Collections.reverse() 之类的内容添加项目，而是让列表保持自己的顺序，

到目前为止我尝试过的是制作自定义迭代器。但是由于某种原因，当尝试迭代列表时，我被 IndexOutOfBoundsException 抛出（即使列表不为空） 我的代码：

public class ReverseList<E> extends ArrayList<E> implements List<E>{    
private class ReverseIterator<E> extends ReverseList<E> implements Iterator<E> 
{
    private int pos;
    public ReverseIterator()
    {
        pos = super.size()-1;
    }
    public ReverseIterator(ReverseList<E> r)
    {
        pos = r.size()-1;
    }
    
    @Override
    public boolean hasNext() {          
        return pos >= 0;
    }

    @Override
    public E next() {
        return super.get(pos--);
    }
    
}
@Override
public Iterator<E> iterator() {
    // TODO Auto-generated method stub
    return new ReverseIterator<E>(this);
}

public static void main(String[] args)
{
    ReverseList<Integer> r = new ReverseList<>();
    r.add(new Integer(1));
    r.add(new Integer(2));
    r.add(new Integer(3));
    r.add(new Integer(4));
    
    for(Integer i:r)
    {
        System.out.println(i);
    }
}
}

抛出错误：线程“main”java.lang.IndexOutOfBoundsException中的异常：索引3超出长度0的范围（在for循环中抛出）

为什么列表的长度为0？

我的方法可行吗？有更好的方法吗？

Answer 1

您的 ReverseIterator 是 ReverseList 的子类。这意味着，它本身就是一个列表。然后，您混淆了这两个列表的状态。在 ReverseIterator(ReverseListr) 中，您在 next()< 中使用 r 的大小来初始化 pos /code> 您使用 super.get(pos--) 访问另一个列表的内容。其他列表始终为空。

迭代器永远不应该是集合。当您将迭代器实现为内部类时，您可以隐式访问外部集合的状态。

除此之外，您的列表显然违反了 List 接口的约定，并且将来会导致很多其他问题，因为它的 iterator() 与其他 不一致>List 功能，如所有基于索引的操作或 listIterator()。

您不应该仅仅为了单个操作（即向后迭代）而更改类的基本原理。相反，将此单个操作实现为不同的操作。

例如：

public class ReversibleList<T> extends ArrayList<T> {
    private class ReverseIterator implements Iterator<T> {
        private int pos = size() - 1;
  
        @Override
        public boolean hasNext() {          
            return pos >= 0;
        }
  
        @Override
        public T next() {
            return get(pos--);
        }      
    }
  
    public Iterable<T> reverse() {
        return () -> new ReverseIterator();
    }
  
    public static void main(String[] args) {
        ReversibleList<Integer> r = new ReversibleList<>();
        r.add(1);
        r.add(2);
        r.add(3);
        r.add(4);
  
        for(Integer i: r.reverse()) {
            System.out.println(i);
        }
    }
}

reverse() 视图没有自己的存储空间，但始终以相反的顺序反映列表的当前内容。原来的List继续履行它的契约。

请注意，可以创建列表的反向视图，支持除 iterator() 之外的 List 接口的其他操作：

public class ReversibleList<T> extends ArrayList<T> {
    private class ReversedList extends AbstractList<T> implements RandomAccess {
      @Override
      public T get(int index) {
        return ReversibleList.this.get(size() - index - 1);
      }

      @Override
      public int size() {
        return ReversibleList.this.size();
      }
    }

    public List<T> reverse() {
        return new ReversedList();
    }

    public static void main(String[] args) {
        ReversibleList<Integer> r = new ReversibleList<>();
        r.add(1);
        r.add(2);
        r.add(3);
        r.add(4);

        r.reverse().subList(1, 4).stream().forEach(System.out::println);
    }
}

Answer 2

自然顺序与插入顺序

创建一个不遵循插入自然顺序的集合

这是一个矛盾的术语。自然排序不是插入顺序。

• 自然顺序表示按类的compareTo 比较接口。
• 显然，插入顺序是指将项目添加到集合中的顺序。

列表#reversed

我不打算在创建后反转列表

因此以正常方向构建列表。之后，在 Java 21+ 中，只需调用 List#reversed 获取该列表的视图，该视图呈现与默认遭遇顺序相反的遭遇顺序。

List < Integer > integers = new ArrayList <>( 3 );
integers.add( 42 );
integers.add( 99 );
integers.add( 7 );
System.out.println( "integers = " + integers );

Collections.sort( integers );  // Sort in natural order.
List < Integer > reversedIntegers = integers.reversed( );  // Present encounter order that is opposite of the previously set natural order.

System.out.println( "integers = " + integers );
System.out.println( "reversedIntegers = " + reversedIntegers );

运行时：

integers = [42, 99, 7]
integers = [7, 42, 99]
reversedIntegers = [99, 42, 7]

要了解更多信息，请参阅JEP 431：排序集合。