Skip to main content

Java 8 - Streams - Transformations - Flat Map


  • when a transformation on a stream results in a stream of stream, we use flatMap to flatten the result back to a stream.
  • There is also flatMapToInt, flatMapToDouble and flatMapToLong which yield IntStream, DoubleStream and LongStream respectively.

integer stream one to three
Stream<Integer> oneToThree = Stream.of(1, 2, 3);

integer stream one to two
Stream<Integer> oneToTwo = Stream.of(1, 2);

integer to stream function
Function<Integer, Stream> integerToStreamFunction = i -> IntStream.range(i, 5).boxed();

 integer to double stream function
Function<Integer, DoubleStream> integerToDoubleStreamFunction = i -> DoubleStream.of(i);



 USAGE

 log.info("verifying that flatMap operation flattens a stream of integer stream to an integer stream: ");

oneToThree.flatMap(number -> integerToStreamFunction.apply(number)).forEach(number -> log.info(number.toString()));


log.info("verifying that flatMapToDouble operation flattens a stream of integer stream to a double stream: ");

oneToTwo.flatMapToDouble(number -> integerToDoubleStreamFunction.apply(number)) .forEach(number -> log.info(""+number));


Labels:

Comments

Post a comment

Popular posts from this blog

Java 8 - Streams - Introduction

Streams provide extended  functionality  to collections.  All collection operations except operations on Map can be extended using streams. Streams can either be sequential or parallel . Operations on sequential streams are performed on a single thread. Operations on parallel streams are performed concurrently on multiple threads, and so are faster than sequential streams (although item order is affected). NOTE that parallel streams are CPU intensive and should be used with care as it can lead to starvation of other processes in your application. Operations on streams are grouped into intermediate ( transformations ) and terminal ( actions ). Stream processing is triggered only by terminal operations, while intermediate operations return a new stream. an empty stream Stream emptyStream = Stream.empty(); creating a stream from array Stream<Integer> streamFromArray = Stream.of(new Integer[]{1,2,3}); Stream<Integer> streamFromArray2 = Arrays.stream(new In
Post a comment
Read more

Java 8 - Streams - Parallel Stream

Operations on parallel streams are performed concurrently on multiple threads and so are faster than sequential streams (although item order is affected) However, operations on parallel streams can be ordered using ' stream.forEachOrdered ' parallel Integer Stream Stream<Integer> parallelIntegerStream = new ArrayList<>(Arrays.asList(1,2,3)).parallelStream(); another parallel Integer Stream Stream<Integer> parallelIntegerStream2 = IntStream.range(0, 10).parallel().boxed();  parallel String Stream Stream<String> parallelStringStream = Arrays.asList("ab","acd","db","dab","ea").parallelStream(); USAGE 1 Consumer<Stream> orderedParallelStreamConsumer = stream -> stream.forEachOrdered(item -> log.info(item.toString())); orderedParallelStreamConsumer.accept(parallelIntegerStream); orderedParallelStreamConsumer.accept(parallelIntegerStream2); USAGE 2 Consumer&
Post a comment
Read more

Java 8 - Streams - Actions - Reduce

reduce operation on stream provides a way to accumulate the result of an operation which traverses all items in the stream. The traversal starts from the leftmost item in the stream. There are three implementations of the reduce operation. The first implementation uses the first item in the stream as initial accumulator. The second implementation expects an initial accumulator input. The third implementation provides a way to return an accumulator which has a different type from the stream items. This is similar to foldLeft in other functional languages e.g. Scala. int stream one to three IntStream oneToThree = IntStream.of(1, 2, 3); int stream one to two IntStream oneToTwo = IntStream.of(1, 2); string stream Stream stringStream = Stream.of("a", "ab", "abc", "abcd"); USAGE log.info("first implementation - reducing oneToThree Integer stream by addition: " + oneToThree.reduce((acc, ite
Post a comment
Read more