Java中并行流的反向元素

给定Java中的 Parallel Stream，任务是反转其元素。

例子：

Input: Parallel Stream = {11, 22, 33, 44}
Output: {44, 33, 22, 11}

Input: Parallel Stream = {a, b, c, d}
Output: {d, c, b, a}

以下是执行此操作的各种方法：

1. 使用 Collectors 类：由于Java中的 Streams 不存储任何元素，因此，中间集合用于在 Collectors 类的帮助下创建新流。
   算法：
   1. 获取并行流。
   2. 使用 Collectors.toList() 方法将流转换为列表。
   3. 对于此列表，使用 Collections.reverse() 方法反转其元素。
   4. 使用 List.stream() 方法将此反向列表转换为流。
   5. 返回/打印此流，元素反转。

   下面是上述方法的实现：

   程序：

   // Java program to reverse elements
   // of a parallel Stream
     
   import java.util.*;
   import java.util.stream.*;
     
   class GFG {
     
       // Generic function to reverse
       // the elements of the parallel stream
       public static  Collector > reverseStream()
       {
           return Collectors
               .collectingAndThen(Collectors.toList(),
                                  list -> {
                                      Collections.reverse(list);
                                      return list.stream();
                                  });
       }
     
       // Driver code
       public static void main(String[] args)
       {
     
           // Get the parallel stream
           List lists = Arrays.asList(11, 22, 33, 44);
           Stream stream = lists.parallelStream();
     
           // Reverse and print the elements
           stream.collect(reverseStream())
               .forEach(System.out::println);
       }
   }
   

   输出：

   44
   33
   22
   11
   

2. 使用 LinkedList 类： LinkedList 类实现了 List 接口，并具有一个称为 Stack 的功能。所以 LinkedList 支持在前面插入。利用这一点，可以从指定流的元素创建 LinkedList 并将降序迭代器返回给它。这将反转并行流的元素。

   算法：

   1. 获取并行流。
   2. 使用 Collectors.toCollection() 方法将流转换为 LinkedList。
   3. 对于此 LinkedList，使用 descendingIterator() 方法返回降序迭代器。
   4. 返回/打印此迭代器，元素反转。

   下面是上述方法的实现：

   程序：

   // Java program to reverse elements
   // of a parallel Stream
     
   import java.util.*;
   import java.util.stream.*;
     
   class GFG {
     
       // Generic function to reverse
       // the elements of the parallel stream
       public static  Iterator reverseStream(Stream stream)
       {
           return stream
               .collect(Collectors
                            .toCollection(LinkedList::new))
               .descendingIterator();
       }
     
       // Driver code
       public static void main(String[] args)
       {
     
           // Get the parallel stream
           List lists = Arrays.asList(11, 22, 33, 44);
           Stream stream = lists.parallelStream();
     
           // Reverse and print the elements
           Iterator reverse = reverseStream(stream);
           reverse.forEachRemaining(System.out::println);
       }
   }
   

   输出：

   44
   33
   22
   11
   

3. Collector.of() ：想法是创建一个收集器，将指定 Stream 的元素以相反的顺序累积到 ArrayDeque 或 ArrayList 中

   算法：

   1. 获取并行流。
   2. 使用 Collectors.of() 方法将流转换为 Collection。
   3. 在这个集合中，以相反的顺序添加元素
   4. 使用 Collection.stream() 方法将此反向集合转换为流。
   5. 返回/打印此流，元素反转。

   下面是上述方法的实现：

   程序：

   // Java program to reverse elements
   // of a parallel Stream
     
   import java.util.*;
   import java.util.stream.*;
     
   class GFG {
     
       // Generic function to reverse
       // the elements of the parallel stream
       public static  Stream reverseStream(Stream stream)
       {
           return stream
               .collect(
                   Collector.of(
                       () -> new ArrayDeque(), ArrayDeque::addFirst, (a, b) -> {
                           b.addAll(a);
                           return b;
                       }))
               .stream();
       }
     
       // Driver code
       public static void main(String[] args)
       {
     
           // Get the parallel stream
           List lists = Arrays.asList(11, 22, 33, 44);
           Stream stream = lists.parallelStream();
     
           // Reverse and print the elements
           reverseStream(stream)
               .forEach(System.out::println);
       }
   }
   

   输出：

   44
   33
   22
   11