android java 错误: 类型 Deque＜E＞ 和 List＜E＞ 不兼容；两者都定义了reversed()；

由于升级了android SDK版本，在SDK35之前能用的代码，到SDK35之后出现了错误。即：错误: 类型 Deque 和 List 不兼容；两者都定义了reversed();

究其原因是因为升级SDK35之后，不允许使用低版本的JDK了，而JDK的升级导致了java代码的兼容性问题。
https://inside.java/2023/05/12/quality-heads-up/

在SDK35之前List和Deque类中，都没有定义reversed()方法，用户有需要的话，需要自己实现。而在SDK35之后，List和Deque类中都实现了reversed()方法，所以产生了冲突，并报错。

具体的解决办法，是参考JDK中LinkedList.java的写法，根据调用的具体调用的接口分别返回对应List或者Deque的super.reversed()。

reversed()方法都在JDK中已经实现，需要做的就是根据具体情况返回对应的super.reversed()。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{

    public LinkedList<E> reversed() {
        return new ReverseOrderLinkedListView<>(this, super.reversed(), Deque.super.reversed());
    }

    // all operations are delegated to the reverse-ordered views.
    // TODO audit all overridden methods
    @SuppressWarnings("serial")
    static class ReverseOrderLinkedListView<E> extends LinkedList<E> implements java.io.Externalizable {
        final LinkedList<E> list;
        final List<E> rlist;
        final Deque<E> rdeque;

        ReverseOrderLinkedListView(LinkedList<E> list, List<E> rlist, Deque<E> rdeque) {
            this.list = list;
            this.rlist = rlist;
            this.rdeque = rdeque;
        }

        public String toString() {
            return rlist.toString();
        }

        public boolean retainAll(Collection<?> c) {
            return rlist.retainAll(c);
        }

        public boolean removeAll(Collection<?> c) {
            return rlist.removeAll(c);
        }

        public boolean containsAll(Collection<?> c) {
            return rlist.containsAll(c);
        }

        public boolean isEmpty() {
            return rlist.isEmpty();
        }

        public Stream<E> parallelStream() {
            return rlist.parallelStream();
        }

        public Stream<E> stream() {
            return rlist.stream();
        }

        public boolean removeIf(Predicate<? super E> filter) {
            return rlist.removeIf(filter);
        }

        public <T> T[] toArray(IntFunction<T[]> generator) {
            return rlist.toArray(generator);
        }

        public void forEach(Consumer<? super E> action) {
            rlist.forEach(action);
        }

        public Iterator<E> iterator() {
            return rlist.iterator();
        }

        public int hashCode() {
            return rlist.hashCode();
        }

        public boolean equals(Object o) {
            return rlist.equals(o);
        }

        public List<E> subList(int fromIndex, int toIndex) {
            return rlist.subList(fromIndex, toIndex);
        }

        public ListIterator<E> listIterator() {
            return rlist.listIterator();
        }

        public void sort(Comparator<? super E> c) {
            rlist.sort(c);
        }

        public void replaceAll(UnaryOperator<E> operator) {
            rlist.replaceAll(operator);
        }

        public LinkedList<E> reversed() {
            return list;
        }

        public Spliterator<E> spliterator() {
            return rlist.spliterator();
        }

        public <T> T[] toArray(T[] a) {
            return rlist.toArray(a);
        }

        public Object[] toArray() {
            return rlist.toArray();
        }

        public Iterator<E> descendingIterator() {
            return rdeque.descendingIterator();
        }

        public ListIterator<E> listIterator(int index) {
            return rlist.listIterator(index);
        }

        public boolean removeLastOccurrence(Object o) {
            return rdeque.removeLastOccurrence(o);
        }

        public boolean removeFirstOccurrence(Object o) {
            return rdeque.removeFirstOccurrence(o);
        }

        public E pop() {
            return rdeque.pop();
        }

        public void push(E e) {
            rdeque.push(e);
        }

        public E pollLast() {
            return rdeque.pollLast();
        }

        public E pollFirst() {
            return rdeque.pollFirst();
        }

        public E peekLast() {
            return rdeque.peekLast();
        }

        public E peekFirst() {
            return rdeque.peekFirst();
        }

        public boolean offerLast(E e) {
            return rdeque.offerLast(e);
        }

        public boolean offerFirst(E e) {
            return rdeque.offerFirst(e);
        }

        public boolean offer(E e) {
            return rdeque.offer(e);
        }

        public E remove() {
            return rdeque.remove();
        }

        public E poll() {
            return rdeque.poll();
        }

        public E element() {
            return rdeque.element();
        }

        public E peek() {
            return rdeque.peek();
        }

        public int lastIndexOf(Object o) {
            return rlist.lastIndexOf(o);
        }

        public int indexOf(Object o) {
            return rlist.indexOf(o);
        }

        public E remove(int index) {
            return rlist.remove(index);
        }

        public void add(int index, E element) {
            rlist.add(index, element);
        }

        public E set(int index, E element) {
            return rlist.set(index, element);
        }

        public E get(int index) {
            return rlist.get(index);
        }

        public void clear() {
            rlist.clear();
        }

        public boolean addAll(int index, Collection<? extends E> c) {
            return rlist.addAll(index, c);
        }

        public boolean addAll(Collection<? extends E> c) {
            return rlist.addAll(c);
        }

        public boolean remove(Object o) {
            return rlist.remove(o);
        }

        public boolean add(E e) {
            return rlist.add(e);
        }

        public int size() {
            return rlist.size();
        }

        public boolean contains(Object o) {
            return rlist.contains(o);
        }

        public void addLast(E e) {
            rdeque.addLast(e);
        }

        public void addFirst(E e) {
            rdeque.addFirst(e);
        }

        public E removeLast() {
            return rdeque.removeLast();
        }

        public E removeFirst() {
            return rdeque.removeFirst();
        }

        public E getLast() {
            return rdeque.getLast();
        }

        public E getFirst() {
            return rdeque.getFirst();
        }

        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
            throw new java.io.InvalidObjectException("not serializable");
        }

        public void writeExternal(ObjectOutput out) throws IOException {
            throw new java.io.InvalidObjectException("not serializable");
        }
    }

    @NonNull
    @Override
    public ListIterator<E> listIterator(int index) {
        return null;
    }

    @Override
    public void addFirst(E e) {

    }

    @Override
    public void addLast(E e) {

    }

    @Override
    public boolean offerFirst(E e) {
        return false;
    }

    @Override
    public boolean offerLast(E e) {
        return false;
    }

    @Override
    public E removeFirst() {
        return null;
    }

    @Override
    public E removeLast() {
        return null;
    }

    @Nullable
    @Override
    public E pollFirst() {
        return null;
    }

    @Nullable
    @Override
    public E pollLast() {
        return null;
    }

    @Override
    public E getFirst() {
        return null;
    }

    @Override
    public E getLast() {
        return null;
    }

    @Nullable
    @Override
    public E peekFirst() {
        return null;
    }

    @Nullable
    @Override
    public E peekLast() {
        return null;
    }

    @Override
    public boolean removeFirstOccurrence(@Nullable Object o) {
        return false;
    }

    @Override
    public boolean removeLastOccurrence(@Nullable Object o) {
        return false;
    }

    @Override
    public boolean offer(E e) {
        return false;
    }

    @Override
    public E remove() {
        return null;
    }

    @Nullable
    @Override
    public E poll() {
        return null;
    }

    @Override
    public E element() {
        return null;
    }

    @Nullable
    @Override
    public E peek() {
        return null;
    }

    @Override
    public void push(E e) {

    }

    @Override
    public E pop() {
        return null;
    }

    @Override
    public int size() {
        return 0;
    }

    @NonNull
    @Override
    public Iterator<E> descendingIterator() {
        return null;
    }
}