Java 8 Stream 中异常处理--收集异常，不停止流处理

对于Java 8的Stream，个人很喜欢用来做批处理，但是工作中，较难对数据有完全预估。若数据超出预期，会导致stream停止，

我们即想要获取异常的数据，又想要完成正确数据的处理，该怎么办？

那么我们就需要一个方法来优雅地完成这个任务！！！如果你说在lambda 写try..catch..那就当我没说......

话不多说直接上代码！！！！！！

@FunctionalInterface
public interface CheckedFunction<T,R> {
    R apply(T t) throws Exception;
}

import jdk.nashorn.internal.objects.annotations.Getter;
import org.apache.commons.lang3.tuple.Pair;

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


public class Either<L, R> {
    private final L left;
    private final R right;

    private Either(L left, R right) {
        this.left = left;
        this.right = right;
    }

    public static <T, R> Function<T, Either> liftWithValue(CheckedFunction<T, R> function) {
        return t -> {
            try {
                return Either.Right(function.apply(t));
            } catch (Exception ex) {
                return Either.Left(Pair.of(ex, t));
            }
        };
    }

    public static <T, R> Function<T, Either> lift(CheckedFunction<T, R> function) {
        return t -> {
            try {
                return Either.Right(function.apply(t));
            } catch (Exception ex) {
                return Either.Left(ex);
            }
        };
    }

    public static <L, R> Either<L, R> Left(L value) {
        return new Either(value, null);
    }

    public static <L, R> Either<L, R> Right(R value) {
        return new Either(null, value);
    }

    public <T> Optional<T> mapLeft(Function<? super L, T> mapper) {
        if (isLeft()) {
            return Optional.of(mapper.apply(left));
        }
        return Optional.empty();
    }

    public <T> Optional<T> mapRight(Function<? super R, T> mapper) {
        if (isRight()) {
            return Optional.of(mapper.apply(right));
        }
        return Optional.empty();
    }

    public String toString() {
        if (isLeft()) {
            return "Left(" + left + ")";
        }
        return "Right(" + right + ")";
    }

    public Optional<L> getLeft() {
        return Optional.ofNullable(left);
    }

    public Optional<R> getRight() {
        return Optional.ofNullable(right);
    }

    public boolean isLeft() {
        return left != null;
    }

    public boolean isRight() {
        return right != null;
    }


}

再来解释下

CheckedFunction，属于自己定义的一个方法接口，为函数编写自己的方法接口

Either 则将处理的数据分为两部分，异常的部分放入left，正确的数据放入Right。

那么我们就把正确1处理的数据和异常的数据区分开了。

具体实现方法如下：

List<String> valueStrs = new ArrayList();
valueStrs.parallelStream()
              .map(Either.liftWithValue(val -> doSomething(val)))
              .forEach(value -> {
                 System.out.println(JSONObject.toJSONString(value.getLeft().get()));
                 if (value.getRight().isPresent()) {
                    tList.add((T) value.getRight().get());
                 }
              });

这里我只取出了正确的数据，可根据自己需要收集异常数据。

感谢博主【zl1zl2zl3】！

学习自博主链接这里这里