Java 8：ストリームで例外をスローするメソッドを使用するにはどうすればよいですか？

クラスとメソッドがあるとします

class A {
  void foo() throws Exception() {
    ...
  }
}

ここで、次のようなAストリームによって配信されるインスタンスごとにfooを呼び出します。

void bar() throws Exception {
  Stream<A> as = ...
  as.forEach(a -> a.foo());
}

質問：例外を適切に処理するにはどうすればよいですか？foo（）によってスローされる可能性のある例外を処理していないため、コードがマシンでコンパイルされません。のthrows Exceptionはbarここでは役に立たないようです。何故ですか？

チェックされた例外をスローしない別のメソッドにメソッド呼び出しをラップする必要があります。のサブクラスであるものはすべてスローできRuntimeExceptionます。

通常のラッピングイディオムは次のようなものです。

private void safeFoo(final A a) {
    try {
        a.foo();
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
}

（スーパータイプの例外Exceptionは例としてのみ使用されており、自分でキャッチしようとしないでください）

次に、次のように呼び出しますas.forEach(this::safeFoo)。

あなたが望むすべてを呼び出すことである場合foo、あなたは（ラッピングなし）であるとして、例外を伝播することを好む、あなたはまた、単にJavaの使用することができますfor（一部を反復処理可能にストリームを回した後、代わりにループを詐欺）：

for (A a : (Iterable<A>) as::iterator) {
   a.foo();
}

これは、少なくとも、JUnitテストで行うことです。チェックされた例外をラップするという問題を回避したくありません（実際には、ラップされていない元の例外をスローするようにテストを優先しています）。

この質問は少し古いかもしれませんが、ここでの「正しい」答えはいくつかの問題をコードの後半に隠してしまういくつかの問題につながる可能性がある唯一の方法だと思うので。少し論争があっても、理由のためにチェック例外が存在します。

私の意見では、最もエレガントな方法は、Mishaがここ で「未来」のアクションを実行するだけでJava 8ストリームの集約ランタイム例外を提供したことです。そのため、すべての機能部品を実行し、機能しない例外を1つにまとめることができます。それ以外の場合は、それらをすべてリストに収集し、後で処理することができます。

同様のアプローチは、Benji Weberによるものです。彼は、動作している部分と動作していない部分を収集するために独自のタイプを作成することを提案しています。

入力値と発生した出力値の間の単純なマッピングを実際に実現したいことに応じて、例外も機能する場合があります。

これらの方法が気に入らない場合は、（元の例外に応じて）少なくとも独自の例外を使用することを検討してください。

Google Guava Throwablesクラスを使用することをお勧めします

伝播（ Throwable throwable）

それがRuntimeExceptionまたはErrorのインスタンスである場合、または最後の手段として、スロー可能な現状のまま伝播し、RuntimeExceptionでラップしてから伝播します。**

void bar() {
    Stream<A> as = ...
    as.forEach(a -> {
        try {
            a.foo()
        } catch(Exception e) {
            throw Throwables.propagate(e);
        }
    });
}

更新：

今では非推奨の使用です：

void bar() {
    Stream<A> as = ...
    as.forEach(a -> {
        try {
            a.foo()
        } catch(Exception e) {
            Throwables.throwIfUnchecked(e);
            throw new RuntimeException(e);
        }
    });
}

この方法で例外をラップおよびアンラップできます。

class A {
    void foo() throws Exception {
        throw new Exception();
    }
};

interface Task {
    void run() throws Exception;
}

static class TaskException extends RuntimeException {
    private static final long serialVersionUID = 1L;
    public TaskException(Exception e) {
        super(e);
    }
}

void bar() throws Exception {
      Stream<A> as = Stream.generate(()->new A());
      try {
        as.forEach(a -> wrapException(() -> a.foo())); // or a::foo instead of () -> a.foo()
    } catch (TaskException e) {
        throw (Exception)e.getCause();
    }
}

static void wrapException(Task task) {
    try {
        task.run();
    } catch (Exception e) {
        throw new TaskException(e);
    }
}

次のいずれかを実行できます。

• チェックされた例外の伝播、
• それをラップしてチェックされていない例外を伝播する、または
• 例外をキャッチして伝播を停止します。

いくつかのライブラリでは、これを簡単に行うことができます。以下の例は、私のNoExceptionライブラリを使用して書かれています。

// Propagate checked exception
as.forEach(Exceptions.sneak().consumer(A::foo));

// Wrap and propagate unchecked exception
as.forEach(Exceptions.wrap().consumer(A::foo));
as.forEach(Exceptions.wrap(MyUncheckedException::new).consumer(A::foo));

// Catch the exception and stop propagation (using logging handler for example)
as.forEach(Exceptions.log().consumer(Exceptions.sneak().consumer(A::foo)));

より読みやすい方法：

class A {
  void foo() throws MyException() {
    ...
  }
}

それを通り抜けるためにそれをa RuntimeExceptionに隠すだけですforEach()

  void bar() throws MyException {
      Stream<A> as = ...
      try {
          as.forEach(a -> {
              try {
                  a.foo();
              } catch(MyException e) {
                  throw new RuntimeException(e);
              }
          });
      } catch(RuntimeException e) {
          throw (MyException) e.getCause();
      }
  }

この時点で、ストリームをスキップしてforループを使用するように言われたとしても、次の場合を除いて、私は誰かに対して抵抗しません。

• を使用してストリームを作成していません。Collection.stream()つまり、forループへの単純な変換ではありません。
• あなたが使おうとしている parallelstream()