diff --git a/libraries/stdlib/jdk8/src/kotlin/streams/Streams.kt b/libraries/stdlib/jdk8/src/kotlin/streams/Streams.kt
index 4402d5f55a8..d5ddab2cdd7 100644
--- a/libraries/stdlib/jdk8/src/kotlin/streams/Streams.kt
+++ b/libraries/stdlib/jdk8/src/kotlin/streams/Streams.kt
@@ -24,30 +24,40 @@ import java.util.stream.*
 
 /**
  * Creates a [Sequence] instance that wraps the original stream iterating through its elements.
+ *
+ * @sample samples.streams.Streams.streamAsSequence
  */
 @SinceKotlin("1.2")
 public fun <T> Stream<T>.asSequence(): Sequence<T> = Sequence { iterator() }
 
 /**
  * Creates a [Sequence] instance that wraps the original stream iterating through its elements.
+ *
+ * @sample samples.streams.Streams.intStreamAsSequence
  */
 @SinceKotlin("1.2")
 public fun IntStream.asSequence(): Sequence<Int> = Sequence { iterator() }
 
 /**
  * Creates a [Sequence] instance that wraps the original stream iterating through its elements.
+ *
+ * @sample samples.streams.Streams.longStreamAsSequence
  */
 @SinceKotlin("1.2")
 public fun LongStream.asSequence(): Sequence<Long> = Sequence { iterator() }
 
 /**
  * Creates a [Sequence] instance that wraps the original stream iterating through its elements.
+ *
+ * @sample samples.streams.Streams.doubleStreamAsSequence
  */
 @SinceKotlin("1.2")
 public fun DoubleStream.asSequence(): Sequence<Double> = Sequence { iterator() }
 
 /**
  * Creates a sequential [Stream] instance that produces elements from the original sequence.
+ *
+ * @sample samples.streams.Streams.sequenceAsStream
  */
 @SinceKotlin("1.2")
 public fun <T> Sequence<T>.asStream(): Stream<T> =
@@ -55,24 +65,32 @@ public fun <T> Sequence<T>.asStream(): Stream<T> =
 
 /**
  * Returns a [List] containing all elements produced by this stream.
+ *
+ * @sample samples.streams.Streams.streamToList
  */
 @SinceKotlin("1.2")
 public fun <T> Stream<T>.toList(): List<T> = collect(Collectors.toList<T>())
 
 /**
  * Returns a [List] containing all elements produced by this stream.
+ *
+ * @sample samples.streams.Streams.intStreamToList
  */
 @SinceKotlin("1.2")
 public fun IntStream.toList(): List<Int> = toArray().asList()
 
 /**
  * Returns a [List] containing all elements produced by this stream.
+ *
+ * @sample samples.streams.Streams.longStreamToList
  */
 @SinceKotlin("1.2")
 public fun LongStream.toList(): List<Long> = toArray().asList()
 
 /**
  * Returns a [List] containing all elements produced by this stream.
+ *
+ * @sample samples.streams.Streams.doubleStreamToList
  */
 @SinceKotlin("1.2")
 public fun DoubleStream.toList(): List<Double> = toArray().asList()
diff --git a/libraries/stdlib/samples/test/samples/streams/streams.kt b/libraries/stdlib/samples/test/samples/streams/streams.kt
new file mode 100644
index 00000000000..ef3085bcfa0
--- /dev/null
+++ b/libraries/stdlib/samples/test/samples/streams/streams.kt
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package samples.streams
+
+import samples.*
+import java.util.stream.*
+import kotlin.streams.*
+
+class Streams {
+
+    @Sample
+    fun streamAsSequence() {
+        val stringStream: Stream<String> = Stream.of("Never", "gonna", "give", "you", "up")
+        val stringSequence: Sequence<String> = stringStream.asSequence()
+        assertPrints(stringSequence.joinToString(" "), "Never gonna give you up")
+    }
+
+    @Sample
+    fun intStreamAsSequence() {
+        val intStream: IntStream = IntStream.of(5, 6, 7)
+        val intSequence: Sequence<Int> = intStream.asSequence()
+        assertPrints(intSequence.joinToString(", "), "5, 6, 7")
+    }
+
+    @Sample
+    fun longStreamAsSequence() {
+        val longStream: LongStream = LongStream.of(5_000_000_000, 6_000_000_000, 7_000_000_000)
+        val longSequence: Sequence<Long> = longStream.asSequence()
+        assertPrints(longSequence.joinToString(", "), "5000000000, 6000000000, 7000000000")
+    }
+
+    @Sample
+    fun doubleStreamAsSequence() {
+        val doubleStream: DoubleStream = DoubleStream.of(1e2, 1e3, 1e4)
+        val doubleSequence: Sequence<Double> = doubleStream.asSequence()
+        assertPrints(doubleSequence.joinToString(", "), "100.0, 1000.0, 10000.0")
+    }
+
+    @Sample
+    fun sequenceAsStream() {
+        val evenNumbersSequence: Sequence<Int> = generateSequence(2, { it + 2 }).take(5)
+        val evenNumberStream: Stream<Int> = evenNumbersSequence.asStream()
+        assertPrints(evenNumberStream.toList(), "[2, 4, 6, 8, 10]")
+    }
+
+    @Sample
+    fun streamToList() {
+        val stringStream: Stream<String> = Stream.of("Lion", "Leopard", "Jaguar", "Tiger")
+        val stringList: List<String> = stringStream.toList()
+        assertPrints(stringList, "[Lion, Leopard, Jaguar, Tiger]")
+    }
+
+    @Sample
+    fun intStreamToList() {
+        val intStream: IntStream = IntStream.of(10, 20, 30)
+        val intList: List<Int> = intStream.toList()
+        assertPrints(intList, "[10, 20, 30]")
+    }
+
+    @Sample
+    fun longStreamToList() {
+        val longStream: LongStream = LongStream.of(3_000_000_000, 4_000_000_000, 5_000_000_000)
+        val longList: List<Long> = longStream.toList()
+        assertPrints(longList, "[3000000000, 4000000000, 5000000000]")
+    }
+
+    @Sample
+    fun doubleStreamToList() {
+        val doubleStream: DoubleStream = DoubleStream.of(1e2, 1e3, 1e4)
+        val doubleList: List<Double> = doubleStream.toList()
+        assertPrints(doubleList, "[100.0, 1000.0, 10000.0]")
+    }
+}
\ No newline at end of file