class ListWrapper<T> implements List<T>

ListWrapper.java

public class ListWrapper<T> implements List<T> {

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof ListWrapper)) return false;
            ListWrapper<?> that = (ListWrapper<?>) o;
            return inner.equals(that.inner);
        }

        @Override
        public int hashCode() {
            return Objects.hash(inner);
        }

        private List<T> inner;

        public ListWrapper(List<T> inner) {
            this.inner = inner;
        }

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

        @Override
        public boolean isEmpty() {
            return inner.isEmpty();
        }

        @Override
        public boolean contains(@Nullable Object o) {
            return inner.contains(o);
        }

        @NonNull
        @Override
        public Iterator<T> iterator() {
            return inner.iterator();
        }

        @Nullable
        @Override
        public Object[] toArray() {
            return inner.toArray();
        }

        @Override
        public <T> T[] toArray(@Nullable T[] a) {
            return inner.toArray(a);
        }

        @Override
        public boolean add(T o) {
            return inner.add(o);
        }

        @Override
        public boolean remove(@Nullable Object o) {
            return inner.remove(o);
        }

        @Override
        public boolean containsAll(@NonNull Collection<?> c) {
            return inner.containsAll(c);
        }

        @Override
        public boolean addAll(@NonNull Collection<? extends T> c) {
            return inner.addAll(c);
        }

        @Override
        public boolean addAll(int index, @NonNull Collection<? extends T> c) {
            return inner.addAll(index, c);
        }

        @Override
        public boolean removeAll(@NonNull Collection<?> c) {
            return inner.removeAll(c);
        }

        @Override
        public boolean retainAll(@NonNull Collection<?> c) {
            return inner.retainAll(c);
        }

        @Override
        public void clear() {
            inner.clear();
        }

        @Override
        public T get(int index) {
            return inner.get(index);
        }

        @Override
        public T set(int index, T element) {
            return inner.set(index, element);
        }

        @Override
        public void add(int index, T element) {
             inner.add(index, element);
        }

        @Override
        public T remove(int index) {
            return inner.remove(index);
        }

        @Override
        public int indexOf(@Nullable Object o) {
            return inner.indexOf(o);
        }

        @Override
        public int lastIndexOf(@Nullable Object o) {
            return inner.lastIndexOf(o);
        }

        @NonNull
        @Override
        public ListIterator<T> listIterator() {
            return inner.listIterator();
        }

        @NonNull
        @Override
        public ListIterator<T> listIterator(int index) {
            return inner.listIterator(index);
        }

        @NonNull
        @Override
        public List<T> subList(int fromIndex, int toIndex) {
            return inner.subList(fromIndex, toIndex);
        }
    }