Refine search
@Override public T set(int index, @Nullable T element) { return forwardList.set(reverseIndex(index), element); }
@Override public List<T> subList(int fromIndex, int toIndex) { checkPositionIndexes(fromIndex, toIndex, size()); return reverse(forwardList.subList(reversePosition(toIndex), reversePosition(fromIndex))); }
@Override protected void removeRange(int fromIndex, int toIndex) { subList(fromIndex, toIndex).clear(); }
@Override public int indexOf(@Nullable Object o) { int index = forwardList.lastIndexOf(o); return (index >= 0) ? reverseIndex(index) : -1; }
@Override public void add(int index, @Nullable T element) { forwardList.add(reversePosition(index), element); }
private int reverseIndex(int index) { int size = size(); checkElementIndex(index, size); return (size - 1) - index; }
private int reversePosition(int index) { int size = size(); checkPositionIndex(index, size); return size - index; }
@Override public Iterator<T> iterator() { return listIterator(); }
@Override public T remove(int index) { return forwardList.remove(reverseIndex(index)); }
@Override public T get(int index) { return forwardList.get(reverseIndex(index)); }
/** * Returns a reversed view of the specified list. For example, {@code * Lists.reverse(Arrays.asList(1, 2, 3))} returns a list containing {@code 3, 2, 1}. The returned * list is backed by this list, so changes in the returned list are reflected in this list, and * vice-versa. The returned list supports all of the optional list operations supported by this * list. * * <p>The returned list is random-access if the specified list is random access. * * @since 7.0 */ public static <T> List<T> reverse(List<T> list) { if (list instanceof ImmutableList) { return ((ImmutableList<T>) list).reverse(); } else if (list instanceof ReverseList) { return ((ReverseList<T>) list).getForwardList(); } else if (list instanceof RandomAccess) { return new RandomAccessReverseList<>(list); } else { return new ReverseList<>(list); } }
@Override public List<T> subList(int fromIndex, int toIndex) { checkPositionIndexes(fromIndex, toIndex, size()); return reverse(forwardList.subList(reversePosition(toIndex), reversePosition(fromIndex))); }
private int reversePosition(int index) { int size = size(); checkPositionIndex(index, size); return size - index; }
@Override public T get(int index) { return forwardList.get(reverseIndex(index)); }
@Override public T set(int index, @NullableDecl T element) { return forwardList.set(reverseIndex(index), element); }
private int reverseIndex(int index) { int size = size(); checkElementIndex(index, size); return (size - 1) - index; }
private int reversePosition(int index) { int size = size(); checkPositionIndex(index, size); return size - index; }
@Override public List<T> subList(int fromIndex, int toIndex) { checkPositionIndexes(fromIndex, toIndex, size()); return reverse(forwardList.subList(reversePosition(toIndex), reversePosition(fromIndex))); }
@Override public Iterator<T> iterator() { return listIterator(); }
@Override public void add(int index, @NullableDecl T element) { forwardList.add(reversePosition(index), element); }