The functional-like possibilities introduced along with Java 8 have changed the language a lot. It made coding faster and more concise. We can briefly pour our ideas to the code with less lines of code (which is not always the desired thing, I know). Of course we had had JVM languages like Groovy or Scala earlier but it was Java 8 that had brought those functions to the “clean” Java syntax.
It not literally functional programming but it brings some elements of it. We don’t change the object states until we use terminal operations, we can shape the data flow as we wish.
This is a practical article so let’s go to some examples!
Iterating over list and executing some operations on its elements:
package app;
import java.util.Arrays;
import java.util.List;
public class StreamsExample {
public static void main(String[] args) {
List<String> words = Arrays.asList("one", "giraffe", "screwdriver", "scala", "java", "rocketzki", "general", "ant");
for (String word : words) {
System.out.println(word.length());
} //using 'classic' foreach loop
System.out.println("\nUsing streams:\n");
words.stream().map(String::length).forEach(System.out::println);
// using streams and method references.
}
}
Output:
3 7 11 5 4 9 7 3 Using streams: 3 7 11 5 4 9 7 3
So in the first example I have used regualr foreach loop, in the other one I’ve used streams and method references (you can read more about it on my other article).
I’m not going to analyze the regular foreach loop so let’s get to the second one.
Firstly I’ve called stream() method which has returned stream of strings (Stream<String>) and then I used Stream<R> map(Function<? super T, ? extends R> mapper) method on that stream. The map method tranforms one stream to another using a function passed as a parameter. In this example it takes a String and returns it’s length returning the product of the length() method. Then I call forEach(Consumer<? super T> action) method which under the hood works like the regular foreach loop with println() static reference – but in this case the syntax is more concise.
Other example of using map method:
package app;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamsExampleTwo {
public static void main(String[] args) {
// Notice that we can instantiate an ArrayList by passing a list to its constructor!
List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 34, 5, 66, 54, 5, 89, 4, 2, 22, 3567, 785, 34, 12));
// I assign the result of the collect method to the wordsAndNumbers variable.
List<String> wordsAndNumbers = numbers.stream()
.map(x -> "Number:\t" + x).collect(Collectors.toList());
// Let's see what we've got here after transformation:
wordsAndNumbers.forEach(System.out::println);
// I can also chain the map methods - I have transformed numbers back to Integer type using chained map methods.
List<Integer> numbersAgain = wordsAndNumbers.stream()
.map(word -> word.substring(0, 3) + ": " + word.substring(word.indexOf("\t")))
.map(secondWord -> Integer.valueOf(secondWord.substring(secondWord.indexOf("\t")).trim()))
.collect(Collectors.toList());
numbersAgain.forEach(System.out::println);
}
}
Output:
Number: 1 Number: 2 Number: 34 Number: 5 Number: 66 Number: 54 Number: 5 Number: 89 Number: 4 Number: 2 Number: 22 Number: 3567 Number: 785 Number: 34 Number: 12 Trimemd a little bit: Num: 1 Num: 2 Num: 34 Num: 5 Num: 66 Num: 54 Num: 5 Num: 89 Num: 4 Num: 2 Num: 22 Num: 3567 Num: 785 Num: 34 Num: 12 Integer again: 1 2 34 5 66 54 5 89 4 2 22 3567 785 34 12
Firstly, I created a list of strings called numbers – notice that I have passed a new list to the constructor of ArrayList class. That’s another way of instantiating lists.
Then I created new reference – wordsAndNumbers and assigned the result of mapping numbers list to it. The collect method is called a terminal operation. It gathers the stream and gives us it’s result using collector given as a parameter – Collestors.toList() in this case – method from the standard java.util package.
The third list stores a result of my next mapping operation (chain of operations actually). Let me explain what am I doing there: first mapper takes each element of wordsAndNumbers list and maps it to the substring(0,3) which gives us: Num: and the number.
In the fourth list I copy over the third mapper and add another map method – yes, we can chain stream operations and convert it back to integer using substring and parsing those numbers back to Integer type.
So these are the basics. Should you have any questions, comment or reach me via email!
Link to documentation:
https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html
Article featured image by:
“Picture 029” by Wendy Shaky Hands is licensed under CC BY-NC-SA 2.0
0
0