如何为泛型ThrowingIterator实现异常类型适配方法？

Java的类型擦除机制导致无法直接捕获泛型参数E类型的异常，这是你遇到的核心障碍。下面给出两种可行的解决方案，既规避了编译器限制，又保证类型安全：

方案一：捕获Throwable并安全转换 #

修改adaptException方法，利用原迭代器的throws E声明保证异常类型，结合unchecked转换实现异常映射：

default <X extends Throwable> ThrowingIterator<T, X> adaptException(Function<? super E, ? extends X> exceptionMapper) {
    // 保存外部迭代器引用，避免内部类this混淆导致递归
    ThrowingIterator<T, E> self = this;
    return new ThrowingIterator<T, X>() {
        @Override
        public boolean hasNext() throws X {
            try {
                return self.hasNext();
            } catch (Throwable t) {
                // 原方法声明throws E，因此t必然是E的实例，安全转换
                @SuppressWarnings("unchecked")
                E e = (E) t;
                throw exceptionMapper.apply(e);
            }
        }

        @Override
        public T next() throws X {
            try {
                return self.next();
            } catch (Throwable t) {
                @SuppressWarnings("unchecked")
                E e = (E) t;
                throw exceptionMapper.apply(e);
            }
        }

        @Override
        public void remove() throws X {
            try {
                self.remove();
            } catch (Throwable t) {
                @SuppressWarnings("unchecked")
                E e = (E) t;
                throw exceptionMapper.apply(e);
            }
        }
    };
}

关键说明 #

原ThrowingIterator的方法明确声明throws E，因此实际抛出的异常必然是E（或其子类），这里的unchecked转换是安全的，不会出现ClassCastException。编译器的unchecked警告可以安全抑制，因为我们有泛型边界E extends Throwable和方法抛出声明的双重保证。

方案二：封装异常处理逻辑简化代码 #

将重复的异常捕获逻辑抽成私有工具方法，减少代码冗余：

// 私有工具方法：封装异常捕获与映射逻辑
private <R, X extends Throwable> R wrapCall(Supplier<R> call, Function<? super E, ? extends X> mapper) throws X {
    try {
        return call.get();
    } catch (Throwable t) {
        @SuppressWarnings("unchecked")
        E e = (E) t;
        throw mapper.apply(e);
    }
}

default <X extends Throwable> ThrowingIterator<T, X> adaptException(Function<? super E, ? extends X> exceptionMapper) {
    ThrowingIterator<T, E> self = this;
    return new ThrowingIterator<T, X>() {
        @Override
        public boolean hasNext() throws X {
            return wrapCall(self::hasNext, exceptionMapper);
        }

        @Override
        public T next() throws X {
            return wrapCall(self::next, exceptionMapper);
        }

        @Override
        public void remove() throws X {
            wrapCall(() -> {
                self.remove();
                return null;
            }, exceptionMapper);
        }
    };
}

效果验证 #

你的示例用法可以正常工作：

ThrowingIterator<Integer, IOException> baseIterator = getIterator();
ThrowingIterator<Integer, ExecutionException> adaptedIterator = baseIterator.adaptException(ExecutionException::new);

当原迭代器抛出IOException时，会被自动映射为ExecutionException抛出，完全符合预期。

内容的提问来源于stack exchange，提问作者EarthTurtle