Java 8 Streams um eigene Operationen erweitern

[Thomas Darimont]

Hallo,

hier mal ein kleines Beispiel wie man Java 8 Streams um eigene Operationen erweitern kann:

package de.thomasdarimont.labs;

import java.lang.invoke.MethodHandles;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.function.Function;
import java.util.stream.Stream;

/**
 * @author Thomas Darimont
 */
public class DynamicStreamExtensionsExample {

    public static void main(String[] args) throws Throwable {

        Stream.of(1, 2, 3).map(i -> i * 2).forEach(System.out::println);

        System.out.println("###");

        ExtendedStream<Integer> extendedStream = extendStream(Stream.of(1, 2, 3), ExtendedStream.class);

        extendedStream.map2(i -> i * 2).forEach(System.out::println);
    }

    private static <T> T extendStream(final Object target, Class<T> targetInterface, Class<?>... additionalInterfaces) throws Throwable {

        ClassLoader cl = Thread.currentThread().getContextClassLoader();

        Class<?>[] interfaces = Arrays.copyOf(additionalInterfaces, additionalInterfaces.length + 1);
        interfaces[additionalInterfaces.length] = targetInterface;

        InvocationHandler handler = (Object proxy, Method method, Object[] args) -> {

            if (method.isDefault()) {
                return MethodHandles.lookup() //
                        .in(method.getDeclaringClass())
                        .unreflectSpecial(method, method.getDeclaringClass())
                        .bindTo(proxy)
                        .invokeWithArguments(args);
            }

            return method.invoke(target, args);
        };

        return targetInterface.cast(Proxy.newProxyInstance(cl, interfaces, handler));
    }

    static interface ExtendedStream<I> extends Stream<I> {

        default <O> Stream<O> map2(Function<? super I, O> func) {
            return map(func);
        }
    }
}

Viele Grüße,
Tom