LongStream findAny（）及其示例-yiteyi-C++库

LongStream findAny（） 返回一个 可选长度 （可能包含也可能不包含非空值的容器对象）描述流的某个元素，如果流为空，则为空OptionalLong。

null

语法：

OptionalLong findAny()

参数：

可选长度： 一个容器对象，它可能包含也可能不包含非空值。

返回值： 函数返回一个OptionalLong来描述该流的某些元素，如果流为空，则返回一个空OptionalLong。

注： findAny（）是一个 终端短路 流接口的操作。此方法返回满足中间操作的任何第一个元素。这是一个短路操作，因为它只需要 “任何” 返回的第一个元素，并终止迭代的其余部分。

例1： 长流上的findAny（）方法。

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

输出：

注： LongStream findAny（）操作的行为是显式的 不确定性 i、它可以自由选择流中的任何元素。对同一源的多次调用可能不会返回相同的结果。

例2： findAny（）方法以非确定性方式返回可被4整除的元素。

                     // Java code for LongStream findAny()                   
                     // which returns an OptionalLong describing                   
                     // some element of the stream, or an                   
                     // empty OptionalLong if the stream is empty.                   
                     import                               java.util.OptionalLong;                   
                     import                               java.util.stream.LongStream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // Creating an LongStream                   
                                         LongStream stream = LongStream.of(4L, 5L, 8L, 10L, 12L, 16L)                   
                                         .parallel();                   
                             
                                         // Using LongStream findAny().                   
                                         // Executing the source code multiple times                   
                                         // may not return the same result.                   
                                         // Every time you may get a different                   
                                         // value which is divisible by 4.                   
                                         stream = stream.filter(num -> num %                               4                               ==                               0                               );                   
                             
                                         OptionalLong answer = stream.findAny();                   
                                         if                               (answer.isPresent()) {                   
                                         System.out.println(answer.getAsLong());                   
                                         }                   
                                         }                   
                     }                   

输出：

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

THE END

Java