Java中的IntStream findFirst（）-yiteyi-C++库

IntStream findFirst（） 返回一个 可选的 （可能包含也可能不包含非空值的容器对象）描述第一元素，如果流为空，则为空选项

null

语法：

OptionalInt findFirst()

Where, OptionalInt is a container object which
may or may not contain a non-null value 
and the function returns an OptionalInt describing the 
first element of this stream, or an empty OptionalInt
if the stream is empty.

注： findFirst（）是一个 终端短路 流接口的操作。此方法返回满足中间操作的任何第一个元素。

例1： 整数流上的findFirst（）方法。

                     // Java code for IntStream findFirst()                   
                     // which returns an OptionalInt describing                   
                     // first element of the stream, or an                   
                     // empty OptionalInt if the stream is empty.                   
                     import                               java.util.*;                   
                     import                               java.util.stream.IntStream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // Creating an IntStream                   
                                         IntStream stream = IntStream.of(                               6                               ,                               7                               ,                               8                               ,                               9                               );                   
                             
                                         // Using IntStream findFirst() to return                   
                                         // an OptionalInt describing first element                   
                                         // of the stream                   
                                         OptionalInt answer = stream.findFirst();                   
                             
                                         // if the stream is empty, an empty                   
                                         // OptionalInt is returned.                   
                                         if                               (answer.isPresent())                   
                                         System.out.println(answer.getAsInt());                   
                                         else                   
                                         System.out.println(                               "no value"                               );                   
                                         }                   
                     }                   

输出：

注：如果流没有遭遇顺序，那么可以返回任何元素。

例2： 方法返回可被4整除的第一个元素。

                     // Java code for IntStream findFirst()                   
                     // which returns an OptionalInt describing                   
                     // first element of the stream, or an                   
                     // empty OptionalInt if the stream is empty.                   
                     import                               java.util.OptionalInt;                   
                     import                               java.util.stream.IntStream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                             
                                         // Creating an IntStream                   
                                         IntStream stream = IntStream.of(                               4                               ,                               5                               ,                               8                               ,                               10                               ,                               12                               ,                               16                               )                   
                                         .parallel();                   
                             
                                         // Using IntStream findFirst().                   
                                         // Executing the source code multiple times                   
                                         // must return the same result.                   
                                         // Every time you will get the same                   
                                         // Integer which is divisible by 4.                   
                                         stream = stream.filter(num -> num %                               4                               ==                               0                               );                   
                             
                                         OptionalInt answer = stream.findFirst();                   
                                         if                               (answer.isPresent())                   
                                         System.out.println(answer.getAsInt());                   
                                         }                   
                     }                   

输出：

文章版权归作者所有，未经允许请勿转载。

THE END

Java