Java 8中引入了Stream API，用于处理对象的集合。流是支持各种方法的对象序列，可以将这些方法通过管道传输以产生所需的结果。
Java流的功能是：

• 流不是数据结构，而是从集合、数组或I/O通道获取输入。
• 流不更改原始数据结构，它们仅根据流水线方法提供结果。
• 每个中间操作都是延迟执行的，并因此返回一个流，因此可以对各种中间操作进行流水线处理。终端操作标记流的结尾并返回结果。

有3种方法来打印Java流元素：

1. forEach()
2. println()与collect()
3. peek()

以下是详细打印Stream的三种方法：

1. Stream forEach(Consumer action)：此方法对流的每个元素执行一个操作。Stream forEach(Consumer action)是一项终端操作，即，它可以遍历该流以产生结果或附属物。
   语法 ： 

   void forEach(Consumer action)
   Consumer是功能性接口
   T是stream的元素类型.
   

   以下是如何使用forEach()方法打印Stream的元素：
   程序1：

   // Java展示打印stream中的元素
   import java.util.stream.*;
   class GFG {
       public static void main(String[] args)
       {
           // 获取stream
           Stream stream = Stream.of("芒果", "For",
                                             "芒果", "A",
                                             "Computer", "Portal");
           // 打印stream
           stream.forEach(s -> System.out.println(s));
       }
   }

   输出：

   芒果
   For
   芒果
   A
   Computer
   Portal

   程序2：使用lambda表达式

   // Java展示打印Stream
   import java.util.stream.*;
   class GFG {
       public static void main(String[] args)
       {
           // 获取stream
           Stream stream = Stream.of("芒果", "For",
                                             "芒果", "A",
                                             "Computer", "Portal");
           // 打印stream
           stream.forEach(System.out::println);
       }
   }

   输出：

   芒果
   For
   芒果
   A
   Computer
   Portal

   程序3：这种方法消耗了流，并使其无法将来使用。因此，以下代码将引发错误，因为流已被使用。

   // Java展示打印Stream
   import java.util.stream.*;
   class GFG {
       public static void main(String[] args)
       {
           // 获取stream
           Stream stream = Stream.of("芒果", "For",
                                             "芒果", "A",
                                             "Computer", "Portal");
           // 打印stream
           stream.forEach(s -> System.out.println(s));
           // Since the stream has been already consumed
           // this will throw exception
           try {
               // 打印stream
               stream.forEach(s -> System.out.println(s));
           }
           catch (Exception e) {
               System.out.println("\n报错: " + e);
           }
       }
   }

   输出：

   芒果
   For
   芒果
   A
   Computer
   Portal
   报错: java.lang.IllegalStateException:
   stream has already been operated upon or closed
   

2. 将println()与collect()结合使用：此方法作为收集器实例(例如，作为List )收集流的元素。因此，使用println()方法可以轻松完成List的打印。语法：

   System.out.println(stream.collect(Collectors.toList()));

   程序1：

   // Java展示打印stream的元素
   import java.util.stream.*;
   class GFG {
       public static void main(String[] args)
       {
           // 获取stream
           Stream stream = Stream.of("芒果", "For",
                                             "芒果", "A",
                                             "Computer", "Portal");
           // 打印stream
           System.out.println(stream.collect(Collectors.toList()));
       }
   }

   输出：

   [芒果, For, 芒果, A, Computer, Portal]

   程序2：此方法还会消耗该流，并使其无法将来使用。因此，以下代码将引发错误，因为流已被使用。

   // Java展示打印stream的元素
   import java.util.stream.*;
   class GFG {
       public static void main(String[] args)
       {
           // 获取stream
           Stream stream = Stream.of("芒果", "For",
                                             "芒果", "A",
                                             "Computer", "Portal");
           // 打印stream
           System.out.println(stream.collect(Collectors.toList()));
           // Since the stream has been already consumed
           // this will throw exception
           try {
               // 打印stream
               System.out.println(stream.collect(Collectors.toList()));
           }
           catch (Exception e) {
               System.out.println("\n报错: " + e);
           }
       }
   }

   输出：

   [芒果, For, 芒果, A, Computer, Portal]
   报错: java.lang.IllegalStateException:
   stream has already been operated upon or closed

3. Stream peek(Consumer action)：此方法返回由该流的元素组成的流，并在从结果流中消耗元素时对每个元素另外执行提供操作。这是一个中间操作，即，它创建一个新的流，当遍历该流时，它将包含与给定谓词匹配的初始流的元素。语法 ：

   Stream
       peek(Consumer action)
   Stream是一个接口， T是流的元素数据类型
   action是非接口的操作
   用来在消耗的元素上进行操作
   这个函数返回新的流

   程序1：

   // Java展示打印流
   import java.util.stream.*;
   class GFG {
       public static void main(String[] args)
       {
           // 获取stream
           Stream stream = Stream.of("芒果", "For",
                                             "芒果", "A",
                                             "Computer", "Portal");
           // 打印stream，使用peek()
           // 提供count()
           stream.peek(s -> System.out.println(s)).count();
       }
   }

   输出：

   芒果
   For
   芒果
   A
   Computer
   Portal

   程序2：此方法不消耗流。因此，以下代码不会引发任何错误。

   // Java打印流的元素
   import java.util.stream.*;
   class GFG {
       public static void main(String[] args)
       {
           // 获取stream
           Stream stream = Stream.of("Geeks", "For",
                                             "GeeksForGeeks", "A",
                                             "Computer", "Portal");
   
           // 打印流
           stream.filter(s -> s.startsWith("G"))
               .peek(s -> System.out.println("过滤的值: " + s))
               .map(String::toUpperCase)
               .peek(s -> System.out.println("大写值 :" + s))
               .count();
       }
   }

   输出：

   Filtered value: Geeks
   Uppercase value :GEEKS
   Filtered value: GeeksForGeeks
   Uppercase value :GEEKSFORGEEKS