익명 타입을 사용한 리스트 확장

MixinTest.java

import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class MixinTest {

    public static void main(String... args) {
        List<String> values = Arrays.asList("A", "B", "C");

        mixin((DelegateList<String> & ListExtendedMethods<String>) () -> values, list -> {
            List<String> strings = list.map(String::toUpperCase);
            strings.forEach(System.out::println);
        });
    }

    static <T, U extends Supplier<T>> void mixin(U u, Consumer<U> consumer) {
        consumer.accept(u);
    }

    interface DelegateList<T> extends Supplier<List<T>>, List<T> {

        default int size() {
            return get().size();
        }

        default boolean isEmpty() {
            return get().isEmpty();
        }

        default boolean contains(Object o) {
            return get().contains(o);
        }

        default Iterator<T> iterator() {
            return get().iterator();
        }

        default Object[] toArray() {
            return get().toArray();
        }

        default <N> N[] toArray(N[] a) {
            return get().toArray(a);
        }

        default boolean add(T t) {
            return get().add(t);
        }

        default boolean remove(Object o) {
            return get().remove(o);
        }

        default boolean containsAll(Collection<?> c) {
            return get().containsAll(c);
        }

        default boolean addAll(Collection<? extends T> c) {
            return get().addAll(c);
        }

        default boolean addAll(int index, Collection<? extends T> c) {
            return get().addAll(index, c);
        }

        default boolean removeAll(Collection<?> c) {
            return get().removeAll(c);
        }

        default boolean retainAll(Collection<?> c) {
            return get().retainAll(c);
        }

        default void replaceAll(UnaryOperator<T> operator) {
            get().replaceAll(operator);
        }

        default void sort(Comparator<? super T> c) {
            get().sort(c);
        }

        default void clear() {
            get().clear();
        }

        default T get(int index) {
            return get().get(index);
        }

        default T set(int index, T element) {
            return get().set(index, element);
        }

        default void add(int index, T element) {
            get().add(index, element);
        }

        default T remove(int index) {
            return get().remove(index);
        }

        default int indexOf(Object o) {
            return get().indexOf(o);
        }

        default int lastIndexOf(Object o) {
            return get().lastIndexOf(o);
        }

        default ListIterator<T> listIterator() {
            return get().listIterator();
        }

        default ListIterator<T> listIterator(int index) {
            return get().listIterator(index);
        }

        default List<T> subList(int fromIndex, int toIndex) {
            return get().subList(fromIndex, toIndex);
        }

        default Spliterator<T> spliterator() {
            return get().spliterator();
        }


        // Collection Inteface

        default boolean removeIf(Predicate<? super T> filter) {
            return get().removeIf(filter);
        }

        default Stream<T> stream() {
            return get().stream();
        }

        default Stream<T> parallelStream() {
            return get().parallelStream();
        }


        // Iterable Inteface

        default void forEach(Consumer<? super T> action) {
            get().forEach(action);
        }


        // boolean equals(Object o);
        // int hashCode();

    }

    interface ListExtendedMethods<T> extends Supplier<List<T>> {
        default <R> List<R> map(Function<T,R> mapper) {
            return get().stream().map(mapper).collect(Collectors.toList());
        }
    }

}