如何從Java 8流中拋出檢查過的異常？如何從Java 8流/lambda中拋出檢查過的異常？換句話說，我希望像這樣編譯代碼：public List<Class> getClasses() throws ClassNotFoundException {
List<Class> classes =
Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
.map(className -> Class.forName(className))
.collect(Collectors.toList());
return classes;
}此代碼不編譯，因為Class.forName()以上拋出方法ClassNotFoundException，這是檢查過的。請注意，我不希望將選中的異常包裝在運行時異常中，而是拋出已包裝的未檢查異常。我想拋出檢查過的異常本身。，而不加丑陋try/catches去小溪。
3 回答
慕的地10843
TA貢獻1785條經驗 獲得超8個贊
LambdaExceptionUtil
Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
.map(rethrowFunction(Class::forName))
.collect(Collectors.toList());Class::forNameClassNotFoundExceptionClassNotFoundException
public final class LambdaExceptionUtil {@FunctionalInterfacepublic interface Consumer_WithExceptions<T, E extends Exception> {
void accept(T t) throws E;
}@FunctionalInterfacepublic interface BiConsumer_WithExceptions<T, U, E extends Exception> {
void accept(T t, U u) throws E;
}@FunctionalInterfacepublic interface Function_WithExceptions<T, R, E extends Exception> {
R apply(T t) throws E;
}@FunctionalInterfacepublic interface Supplier_WithExceptions<T, E extends Exception> {
T get() throws E;
}@FunctionalInterfacepublic interface Runnable_WithExceptions<E extends Exception> {
void run() throws E;
}/** .forEach(rethrowConsumer(name -> System.out.println(Class.forName(name)))); or .
forEach(rethrowConsumer(ClassNameUtil::println)); */public static <T, E extends Exception> Consumer<T>
rethrowConsumer(Consumer_WithExceptions<T, E> consumer) throws E {
return t -> {
try { consumer.accept(t); }
catch (Exception exception) { throwAsUnchecked(exception); }
};
}public static <T, U, E extends Exception> BiConsumer<T, U> rethrowBiConsumer(BiConsumer_WithExceptions<T, U, E> biConsumer) throws E {
return (t, u) -> {
try { biConsumer.accept(t, u); }
catch (Exception exception) { throwAsUnchecked(exception); }
};
}/** .map(rethrowFunction(name -> Class.forName(name))) or .map(rethrowFunction(Class::forName))
*/public static <T, R, E extends Exception> Function<T, R> rethrowFunction(Function_WithExceptions<T, R, E> function) throws E {
return t -> {
try { return function.apply(t); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
};
}/** rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))),
*/public static <T, E extends Exception> Supplier<T> rethrowSupplier(Supplier_WithExceptions<T, E> function) throws E {
return () -> {
try { return function.get(); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
};
}/** uncheck(() -> Class.forName("xxx")); */public static void uncheck(Runnable_WithExceptions t)
{
try { t.run(); }
catch (Exception exception) { throwAsUnchecked(exception); }
}/** uncheck(() -> Class.forName("xxx")); */public static <R, E extends Exception> R uncheck(Supplier_WithExceptions<R, E> supplier)
{
try { return supplier.get(); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
}/** uncheck(Class::forName, "xxx");
*/public static <T, R, E extends Exception> R uncheck(Function_WithExceptions<T, R, E> function, T t) {
try { return function.apply(t); }
catch (Exception exception) { throwAsUnchecked(exception); return null; }
}@SuppressWarnings ("unchecked")private static <E extends Throwable> void throwAsUnchecked(Exception exception) throws E
{ throw (E)exception; }}LambdaExceptionUtil):
@Testpublic void test_Consumer_with_checked_exceptions() throws IllegalAccessException {
Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
.forEach(rethrowConsumer(className -> System.out.println(Class.forName(className))));
Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
.forEach(rethrowConsumer(System.out::println));
}@Testpublic void test_Function_with_checked_exceptions() throws ClassNotFoundException {
List<Class> classes1 = Stream.of("Object", "Integer", "String")
.map(rethrowFunction(className -> Class.forName("java.lang." + className)))
.collect(Collectors.toList());
List<Class> classes2 = Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
.map(rethrowFunction(Class::forName))
.collect(Collectors.toList());
}@Testpublic void test_Supplier_with_checked_exceptions() throws ClassNotFoundException {
Collector.of(
rethrowSupplier(() -> new StringJoiner(new String(new byte[]{77, 97, 114, 107}, "UTF-8"))),
StringJoiner::add, StringJoiner::merge, StringJoiner::toString);
}@Test public void test_uncheck_exception_thrown_by_method() {
Class clazz1 = uncheck(() -> Class.forName("java.lang.String"));
Class clazz2 = uncheck(Class::forName, "java.lang.String");
}@Test (expected = ClassNotFoundException.class)public void test_if_correct_exception_is_still_thrown_by_method() {
Class clazz3 = uncheck(Class::forName, "INVALID");
}附注1：rethrowLambdaExceptionUtil
附注2：uncheckLambdaExceptionUtil
uncheckString text = uncheck(() -> new String(byteArr, "UTF-8"));
uncheck
uncheckRuntimeException
參考資料：
慕桂英4014372
TA貢獻1871條經驗 獲得超13個贊
class WrappedException extends RuntimeException {
Throwable cause;
WrappedException(Throwable cause) { this.cause = cause; }}static WrappedException throwWrapped(Throwable t) {
throw new WrappedException(t);}try
source.stream()
.filter(e -> { ... try { ... } catch (IOException e) { throwWrapped(e); } ... })
...}catch (WrappedException w) {
throw (IOException) w.cause;}添加回答
舉報
0/150
提交
取消