Docs: Example on the as/fromJavaStream operators (#28745)

akka-docs/src/test/java/jdocs/stream/operators/converters/StreamConvertersToJava.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2020 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package jdocs.stream.operators.converters;
+
+import akka.NotUsed;
+import akka.actor.ActorSystem;
+// #import
+import akka.japi.function.Creator;
+import akka.stream.Materializer;
+import akka.stream.javadsl.Sink;
+import akka.stream.javadsl.StreamConverters;
+
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.stream.BaseStream;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+// #import
+import akka.testkit.javadsl.TestKit;
+import jdocs.AbstractJavaTest;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import akka.stream.javadsl.Source;
+
+import static org.junit.Assert.assertEquals;
+
+/** */
+public class StreamConvertersToJava extends AbstractJavaTest {
+
+  static ActorSystem system;
+
+  @BeforeClass
+  public static void setup() {
+    system = ActorSystem.create("StreamConvertersToJava");
+  }
+
+  @AfterClass
+  public static void tearDown() {
+    TestKit.shutdownActorSystem(system);
+    system = null;
+  }
+
+  @Test
+  public void demonstrateConverterToJava8Stream() {
+    // #asJavaStream
+
+    Source<Integer, NotUsed> source = Source.range(0, 9).filter(i -> i % 2 == 0);
+
+    Sink<Integer, java.util.stream.Stream<Integer>> sink = StreamConverters.<Integer>asJavaStream();
+
+    Stream<Integer> jStream = source.runWith(sink, system);
+
+    // #asJavaStream
+    assertEquals(5, jStream.count());
+  }
+
+  @Test
+  public void demonstrateCreatingASourceFromJava8Stream()
+      throws InterruptedException, ExecutionException, TimeoutException {
+    // #fromJavaStream
+
+    Creator<BaseStream<Integer, IntStream>> creator = () -> IntStream.rangeClosed(0, 9);
+    Source<Integer, NotUsed> source = StreamConverters.fromJavaStream(creator);
+
+    Sink<Integer, CompletionStage<Integer>> sink = Sink.last();
+
+    CompletionStage<Integer> integerCompletionStage = source.runWith(sink, system);
+    // #fromJavaStream
+    assertEquals(
+        9, integerCompletionStage.toCompletableFuture().get(5, TimeUnit.SECONDS).intValue());
+  }
+}

akka-docs/src/test/scala/docs/stream/operators/converters/StreamConvertersToJava.scala

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2020 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package docs.stream.operators.converters
+
+// #import
+import java.util.stream
+import java.util.stream.IntStream
+
+import akka.NotUsed
+import akka.stream.scaladsl.Keep
+import akka.stream.scaladsl.Sink
+import akka.stream.scaladsl.Source
+import akka.stream.scaladsl.StreamConverters
+// #import
+import akka.testkit.AkkaSpec
+import org.scalatest.concurrent.Futures
+
+import scala.collection.immutable
+import scala.concurrent.Future
+
+class StreamConvertersToJava extends AkkaSpec with Futures {
+
+  "demonstrate materialization to Java8 streams" in {
+    //#asJavaStream
+    val source: Source[Int, NotUsed] = Source(0 to 9).filter(_ % 2 == 0)
+
+    val sink: Sink[Int, stream.Stream[Int]] = StreamConverters.asJavaStream[Int]()
+
+    val jStream: java.util.stream.Stream[Int] = source.runWith(sink)
+    //#asJavaStream
+    jStream.count should be(5)
+  }
+
+  "demonstrate conversion from Java8 streams" in {
+    //#fromJavaStream
+    def factory(): IntStream = IntStream.rangeClosed(0, 9)
+    val source: Source[Int, NotUsed] = StreamConverters.fromJavaStream(factory).map(_.intValue())
+    val sink: Sink[Int, Future[immutable.Seq[Int]]] = Sink.seq[Int]
+
+    val futureInts: Future[immutable.Seq[Int]] = source.toMat(sink)(Keep.right).run
+
+    //#fromJavaStream
+    whenReady(futureInts) { ints =>
+      ints should be((0 to 9).toSeq)
+    }
+
+  }
+
+}