Java中的LongStream limit（）-yiteyi-C++库

长流限制（长最大大小） 返回一个由该流的元素组成的流，其长度被截断为不超过maxSize。

null

注： LongStream limit（）是一个 短路状态中间操作 i、 e，当处理无限输入时，可能会产生有限的流，而不处理整个输入。

语法：

LongStream limit(long maxSize)

参数：

长流： 原始长值元素的序列。这是人类长期以来的原始特化流动 .
最大尺寸： 流中的元素数量应受到限制。

返回值： 该函数返回一个由该流的元素组成的流，其长度被截断为不超过maxSize。

例外情况： 函数抛出 非法数据异常 如果maxSize为负。

例1：

                     // Java code for LongStream limit                   
                     // (long maxSize)                   
                     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(2L, 4L, 6L, 8L, 10L);                   
                             
                                         // Using LongStream limit(long maxSize) to                   
                                         // get a stream consisting of the elements of                   
                                         // this stream, truncated to be no longer                   
                                         // than maxSize in length.                   
                                         stream.limit(                               3                               ).forEach(System.out::println);                   
                                         }                   
                     }                   

输出：

2
4
6

例2：

                     // Java code for LongStream limit                   
                     // (long maxSize)                   
                     import                               java.util.*;                   
                     import                               java.util.stream.LongStream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // Creating an LongStream of numbers [5, 6, .. 11]                   
                                         LongStream stream = LongStream.range(                               5                               ,                               12                               );                   
                             
                                         // Using LongStream limit(long maxSize) to                   
                                         // get a stream consisting of the elements of                   
                                         // this stream, truncated to be no longer                   
                                         // than maxSize in length.                   
                                         stream.limit(                               4                               ).forEach(System.out::println);                   
                                         }                   
                     }                   

输出：

例3：

                     // Java code for LongStream limit                   
                     // (long maxSize)                   
                     import                               java.util.*;                   
                     import                               java.util.stream.LongStream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // Creating an LongStream                   
                                         LongStream stream = LongStream.iterate(4L, num -> num +                               2                               );                   
                             
                                         // Using LongStream limit(long maxSize) to                   
                                         // get a stream consisting of the elements of                   
                                         // this stream, truncated to be no longer                   
                                         // than maxSize in length.                   
                                         stream.limit(                               4                               ).forEach(System.out::println);                   
                                         }                   
                     }                   

输出：

LongStream limit（）和 LongStream skip（） :

limit（）方法返回减少的第一个maxSize元素流，但skip（）方法在跳过第一个maxSize元素后返回剩余元素流。
limit（）是一种短路有状态的中间操作，即当使用无限输入进行处理时，它可能会产生一个有限的流作为结果，而不处理整个输入，但是skip（）是一种有状态的中间操作，即，它可能需要在产生结果之前处理整个输入。

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

THE END

Java