org.apache.commons.lang3

## Class Streams

- java.lang.Object
- - org.apache.commons.lang3.Streams

-     public class Streams
      extends Object

  Provides utility functions, and classes for working with the `java.util.stream` package, or more generally, with Java 8 lambdas. More specifically, it attempts to address the fact that lambdas are supposed not to throw Exceptions, at least not checked Exceptions, AKA instances of `Exception`. This enforces the use of constructs like

           Consumer<java.lang.reflect.Method> consumer = (m) -> {
               try {
                   m.invoke(o, args);
               } catch (Throwable t) {
                   throw Functions.rethrow(t);
               }
          };
          stream.forEach(consumer);

  Using a `Streams.FailableStream`, this can be rewritten as follows:

           Streams.failable(stream).forEach((m) -> m.invoke(o, args));

  Obviously, the second version is much more concise and the spirit of Lambda expressions is met better than in the first version.
  Since:
    3.10
  See Also:
    `Stream`, `Functions`

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `Streams.ArrayCollector<O>`
    `static class` | `Streams.FailableStream<O>` A reduced, and simplified version of a `Stream` with failable method signatures.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Streams()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <O> Streams.FailableStream<O>` | `stream(Collection<O> stream)` Converts the given `Collection` into a `Streams.FailableStream`.
    `static <O> Streams.FailableStream<O>` | `stream(Stream<O> stream)` Converts the given `stream` into a `Streams.FailableStream`.
    `static <O> Collector<O,?,O[]>` | `toArray(Class<O> pElementType)` Returns a `Collector` that accumulates the input elements into a new array.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### Streams

          public Streams()

  - ### Method Detail

    - #### stream

          public static <O> Streams.FailableStream<O> stream(Stream<O> stream)

      Converts the given `stream` into a `Streams.FailableStream`. This is basically a simplified, reduced version of the `Stream` class, with the same underlying element stream, except that failable objects, like `Functions.FailablePredicate`, `Functions.FailableFunction`, or `Functions.FailableConsumer` may be applied, instead of `Predicate`, `Function`, or `Consumer`. The idea is to rewrite a code snippet like this:

               final List<O> list;
               final Method m;
               final Function<O,String> mapper = (o) -> {
                   try {
                       return (String) m.invoke(o);
                   } catch (Throwable t) {
                       throw Functions.rethrow(t);
                   }
               };
               final List<String> strList = list.stream()
                   .map(mapper).collect(Collectors.toList());

      as follows:

               final List<O> list;
               final Method m;
               final List<String> strList = Functions.stream(list.stream())
                   .map((o) -> (String) m.invoke(o)).collect(Collectors.toList());

      While the second version may not be quite as efficient (because it depends on the creation of additional, intermediate objects, of type FailableStream), it is much more concise, and readable, and meets the spirit of Lambdas better than the first version.
      Type Parameters:
        `O` - The streams element type.
      Parameters:
        `stream` - The stream, which is being converted.
      Returns:
        The `Streams.FailableStream`, which has been created by converting the stream.

    - #### stream

          public static <O> Streams.FailableStream<O> stream(Collection<O> stream)

      Converts the given `Collection` into a `Streams.FailableStream`. This is basically a simplified, reduced version of the `Stream` class, with the same underlying element stream, except that failable objects, like `Functions.FailablePredicate`, `Functions.FailableFunction`, or `Functions.FailableConsumer` may be applied, instead of `Predicate`, `Function`, or `Consumer`. The idea is to rewrite a code snippet like this:

               final List<O> list;
               final Method m;
               final Function<O,String> mapper = (o) -> {
                   try {
                       return (String) m.invoke(o);
                   } catch (Throwable t) {
                       throw Functions.rethrow(t);
                   }
               };
               final List<String> strList = list.stream()
                   .map(mapper).collect(Collectors.toList());

      as follows:

               final List<O> list;
               final Method m;
               final List<String> strList = Functions.stream(list.stream())
                   .map((o) -> (String) m.invoke(o)).collect(Collectors.toList());

      While the second version may not be quite as efficient (because it depends on the creation of additional, intermediate objects, of type FailableStream), it is much more concise, and readable, and meets the spirit of Lambdas better than the first version.
      Type Parameters:
        `O` - The streams element type.
      Parameters:
        `stream` - The stream, which is being converted.
      Returns:
        The `Streams.FailableStream`, which has been created by converting the stream.

    - #### toArray

          public static <O> Collector<O,?,O[]> toArray(Class<O> pElementType)

      Returns a `Collector` that accumulates the input elements into a new array.
      Type Parameters:
        `O` - the type of the input elements
      Parameters:
        `pElementType` - Type of an element in the array.
      Returns:
        a `Collector` which collects all the input elements into an array, in encounter order

Copyright © 2001–2020 The Apache Software Foundation. All rights reserved.