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

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