Java 反转平行流的元素

给定一个Java中的平行流，任务是反转其元素。

例子。
输入: Parallel Stream = {11, 22, 33, 44}
输出: {44, 33, 22, 11}

输入: Parallel Stream = {a, b, c, d}
输出: {d, c, b, a}

以下是各种方法。

1. 使用收集器类：由于Java中的流不存储任何元素，因此，在收集器类的帮助下，使用一个中间集合来创建一个新的流。
   算法。
   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 <T> Collector<T, ?, Stream<T> > 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<Integer> lists = Arrays.asList(11, 22, 33, 44);
        Stream<Integer> 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 <T> Iterator<T> reverseStream(Stream<T> stream)
        {
            return stream
                .collect(Collectors
                             .toCollection(LinkedList::new))
                .descendingIterator();
        }
      
        // Driver code
        public static void main(String[] args)
        {
      
            // Get the parallel stream
            List<Integer> lists = Arrays.asList(11, 22, 33, 44);
            Stream<Integer> stream = lists.parallelStream();
      
            // Reverse and print the elements
            Iterator<Integer> reverse = reverseStream(stream);
            reverse.forEachRemaining(System.out::println);
        }
    }

输出:

44
33
22
11

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

步骤:

1. 获取平行流。
2. 使用Collectors.of()方法将流转换为集合。
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 <T> Stream<T> reverseStream(Stream<T> stream)
    {
        return stream
            .collect(
                Collector.of(
                    () -> new ArrayDeque<T>(), ArrayDeque::addFirst, (a, b) -> {
                        b.addAll(a);
                        return b;
                    }))
            .stream();
    }
  
    // Driver code
    public static void main(String[] args)
    {
  
        // Get the parallel stream
        List<Integer> lists = Arrays.asList(11, 22, 33, 44);
        Stream<Integer> stream = lists.parallelStream();
  
        // Reverse and print the elements
        reverseStream(stream)
            .forEach(System.out::println);
    }
}

输出:

44
33
22
11