Java中的DoubleStream mapToLong（）-yiteyi-C++库

DoubleStream mapToLong（） 返回一个长流，其中包含将给定函数应用于该流元素的结果。

null

注： DoubleStream mapToLong（）是一个 中间操作。 这些操作总是懒惰的。在流实例上调用中间操作，完成处理后，它们将流实例作为输出。 语法：

LongStream mapToLong(DoubleToLongFunction mapper)

参数：

双流： 一个原始的双值元素序列。这是人类的双重本原特化流动 .
制图员： 应用于每个元素的无状态函数。

返回值： 该函数返回一个长流，其中包含将给定函数应用于该流元素的结果。

例1：

                     // Java code for LongStream mapToLong                   
                     // (DoubleToLongFunction mapper)                   
                     import                               java.util.*;                   
                     import                               java.util.stream.LongStream;                   
                     import                               java.util.stream.DoubleStream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // Creating a DoubleStream                   
                                         DoubleStream stream = DoubleStream.of(                               3.3                               ,                               6.5                               ,                               16.4                               ,                   
                                         8.7                               ,                               10.4                               );                   
                             
                                         // Using LongStream mapToLong(DoubleToLongFunction mapper)                   
                                         // to return a LongStream consisting of the                   
                                         // results of applying the given function to                   
                                         // the elements of this stream.                   
                                         LongStream stream1 = stream.mapToLong(num -> (                               long                               )num);                   
                             
                                         // Displaying the elements in stream1                   
                                         stream1.forEach(System.out::println);                   
                                         }                   
                     }                   

输出：

例2：

                     // Java code for LongStream mapToLong                   
                     // (DoubleToLongFunction mapper)                   
                     import                               java.util.*;                   
                     import                               java.util.stream.LongStream;                   
                     import                               java.util.stream.DoubleStream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // Creating a DoubleStream                   
                                         DoubleStream stream = DoubleStream.of(                               3.3                               ,                               6.5                               ,                               16.4                               ,                   
                                         8.7                               ,                               10.4                               );                   
                             
                                         // Using LongStream mapToLong(DoubleToLongFunction mapper)                   
                                         // to return a LongStream consisting of the                   
                                         // results of applying the given function to                   
                                         // the elements of this stream.                   
                                         LongStream stream1 = stream.mapToLong(num -> (                               long                               )num -                               10                               );                   
                             
                                         // Displaying the elements in stream1                   
                                         stream1.forEach(System.out::println);                   
                                         }                   
                     }                   

输出：

-7
-4
6
-2
0

例3：

                     // Java code for LongStream mapToLong                   
                     // (DoubleToLongFunction mapper)                   
                     import                               java.util.*;                   
                     import                               java.util.stream.LongStream;                   
                     import                               java.util.stream.DoubleStream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // Creating a DoubleStream                   
                                         DoubleStream stream = DoubleStream.of(                               3.3                               ,                               6.5                               ,                               16.4                               ,                   
                                         8.7                               ,                               10.4                               );                   
                             
                                         // Using LongStream mapToLong(DoubleToLongFunction mapper)                   
                                         // to return a LongStream consisting of the                   
                                         // results of applying the given function to                   
                                         // the elements of this stream.                   
                                         LongStream stream1 = stream.mapToLong(num -> (                               long                               )(                               2                               * num * num));                   
                             
                                         // Displaying the elements in stream1                   
                                         stream1.forEach(System.out::println);                   
                                         }                   
                     }                   

输出：

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

THE END

Java