Checked exceptions etc. for CFs and Streams

Bruce Eckel · Bruce Eckel · commit 52ac9f6dff71 · 2017-01-06T15:03:36.000-08:00
diff --git a/concurrent/Breakable.java b/concurrent/Breakable.java
@@ -17,9 +17,12 @@ public String toString() {
       " [" + failcount + "]";
   }
   public static Breakable work(Breakable b) {
-    if(--b.failcount == 0)
+    if(--b.failcount == 0) {
+      System.out.println(
+        "Throwing Exception for " + b.id + "");
       throw new RuntimeException(
         "Breakable_" + b.id + " failed");
+    }
     System.out.println(b);
     return b;
   }
diff --git a/concurrent/CompletableExceptions.java b/concurrent/CompletableExceptions.java
@@ -48,21 +48,28 @@ public static void main(String[] args) {
   }
 }
 /* Output:
+Throwing Exception for A
 Breakable_B [1]
+Throwing Exception for B
 Breakable_C [2]
 Breakable_C [1]
+Throwing Exception for C
 Breakable_D [3]
 Breakable_D [2]
 Breakable_D [1]
+Throwing Exception for D
 Breakable_E [4]
 Breakable_E [3]
 Breakable_E [2]
 Breakable_E [1]
 Breakable_F [1]
+Throwing Exception for F
 java.lang.RuntimeException: Breakable_F failed
 Breakable_G [1]
+Throwing Exception for G
 true
 Breakable_H [1]
+Throwing Exception for H
 true
 done? false
 java.lang.RuntimeException: forced
diff --git a/concurrent/StreamExceptions.java b/concurrent/StreamExceptions.java
@@ -0,0 +1,41 @@
+// concurrent/StreamExceptions.java
+// (c)2017 MindView LLC: see Copyright.txt
+// We make no guarantees that this code is fit for any purpose.
+// Visit http://OnJava8.com for more book information.
+import java.util.concurrent.*;
+import java.util.stream.*;
+import onjava.Nap;
+
+public class StreamExceptions {
+  static Stream<Breakable>
+  test(String id, int failcount) {
+    return
+      Stream.of(new Breakable(id, failcount))
+        .map(Breakable::work)
+        .map(Breakable::work)
+        .map(Breakable::work)
+        .map(Breakable::work);
+  }
+  public static void main(String[] args) {
+    // No operations are even applied ...
+    test("A", 1);
+    test("B", 2);
+    Stream<Breakable> c = test("C", 3);
+    test("D", 4);
+    test("E", 5);
+    // ... until there's a terminal operation:
+    System.out.println("Entering try");
+    try {
+      c.forEach(System.out::println);   // [1]
+    } catch(Exception e) {
+      System.out.println(e.getMessage());
+    }
+  }
+}
+/* Output:
+Entering try
+Breakable_C [2]
+Breakable_C [1]
+Throwing Exception for C
+Breakable_C failed
+*/
diff --git a/concurrent/ThrowsChecked.java b/concurrent/ThrowsChecked.java
@@ -0,0 +1,42 @@
+// concurrent/ThrowsChecked.java
+// (c)2017 MindView LLC: see Copyright.txt
+// We make no guarantees that this code is fit for any purpose.
+// Visit http://OnJava8.com for more book information.
+import java.util.stream.*;
+import java.util.concurrent.*;
+
+public class ThrowsChecked {
+  class Checked extends Exception {}
+  static ThrowsChecked nochecked(ThrowsChecked tc) {
+    return tc;
+  }
+  static ThrowsChecked
+  withchecked(ThrowsChecked tc) throws Checked {
+    return tc;
+  }
+  static void testStream() {
+    Stream.of(new ThrowsChecked())
+      .map(ThrowsChecked::nochecked)
+      // .map(ThrowsChecked::withchecked); // [1]
+      .map(tc -> {
+        try {
+          return withchecked(tc);
+        } catch(Checked e) {
+          throw new RuntimeException(e);
+        }
+      });
+  }
+  static void testCompletableFuture() {
+    CompletableFuture
+      .completedFuture(new ThrowsChecked())
+      .thenApply(ThrowsChecked::nochecked)
+      // .thenApply(ThrowsChecked::withchecked); // [2]
+      .thenApply(tc -> {
+        try {
+          return withchecked(tc);
+        } catch(Checked e) {
+          throw new RuntimeException(e);
+        }
+      });
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -17,9 +17,12 @@ public String toString() {`
`17`	`17`	`" [" + failcount + "]";`
`18`	`18`	`}`
`19`	`19`	`public static Breakable work(Breakable b) {`
`20`		`- if(--b.failcount == 0)`
	`20`	`+ if(--b.failcount == 0) {`
	`21`	`+ System.out.println(`
	`22`	`+ "Throwing Exception for " + b.id + "");`
`21`	`23`	`throw new RuntimeException(`
`22`	`24`	`"Breakable_" + b.id + " failed");`
	`25`	`+ }`
`23`	`26`	`System.out.println(b);`
`24`	`27`	`return b;`
`25`	`28`	`}`