Java 8 : Chain Consumer to Function

Question

探索Java 8的新特性，无意间想创建一个Consumer<X>通过链接 Consumer<Y>至 Function<X,Y> .

这有意义吗？如果是这样，好的(通用)解决方案会是什么样子？

---

我尝试过的(比较特殊的例子):

给定

@FunctionalInterface
public interface PartialFunction<X, Y> {
    Y apply(X x) throws Exception;
}

和

import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;

public class PartialFunctions {

    public static <X, Y> Function<X, Optional<Y>> withOptionalResults(final PartialFunction<X, Y> funcThatThrows) {
        return z -> {
            try {
                return Optional.of(funcThatThrows.apply(z));
            } catch (final Exception e) {
                return Optional.empty();
            }
        };
    }

    public static <X, Y> Consumer<X> acceptOnSuccess(final PartialFunction<X, Y> g, final Consumer<Y> c) {
        return x -> withOptionalResults(x).apply(t).ifPresent(c);
    }
}

我最终得到了这样一种可能的用法:

files.forEach(PartialFunctions.<File, BufferedImage>acceptOnSuccess(
        ImageIO::read, images::add));

但是，对显式通用规范的需求并不是最优的。希望有更好的东西？

Answer 1

interface IgnoreThrowing<F,V> extends Function<F,V> {
    public default V apply(F from) {
        try {
            return ignore(from);
        } catch(Exception e) {
            return null;
        }
    }
    public V ignore(F from) throws Exception;
}

class Throwables {
    public static <F,V> Function<F,V> ignore(IgnoreThrowing<F,V> f) {
        return f;
    }
}

static {
    files.map(Throwables.ignore(ImageIO::read)).collect(...)
}

如果您添加一个忽略空值的收集器作为输入，情况会变得更好。

编辑:我写这篇文章时没有进行语法检查或编译，所以不能完全确定默认值的位置，以及编译器是否可以成功推断出链式函数类型参数。