Hi, dear readers! Welcome to my blog. On this post, the second on the series, we talk about streams, a new way to manipulate collections.
So, without further delay, let’s begin our journey through this feature!
Streams
Streams was introduced on Java 8 as a way to create a new form of manipulating Collections. Normally, when we use a Collection, we prepare a list of items, make several operations by this collection, like filtering, sums, etc and finally we use a final result, which could be evaluated as a single operation. That is exactly the goal of the streams API: allow us to program our Collection’s logic like a single operation, using the functional programming paradigm.
So, let’s get started with the preparations for the examples.
First, we create a Client class, which we will use as the POJO for our examples:
public class Client {
private String name;
private Long phone;
private String sex;
private List<Order> orders;
public List<Order> getOrders() {
return orders;
}
public void setOrders(List<Order> orders) {
this.orders = orders;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Long getPhone() {
return phone;
}
public void setPhone(Long phone) {
this.phone = phone;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void markClientSpecial() {
System.out.println("The client " + getName() + " is special! ");
}
}
Our Client class this time has a reference to another POJO, the Order class, which we will use to enrich our examples:
public class Order {
private Long id;
private String description;
private Double total;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Double getTotal() {
return total;
}
public void setTotal(Double total) {
this.total = total;
}
}
Finally, for all the examples, we will use a single Collection’s data, so we create a Utility class to populate our data:
public class CollectionUtils {
public static List<Client> getData() {
List<Client> list = new ArrayList<>();
List<Order> orders;
Order order;
Client clientData = new Client();
clientData.setName("Alexandre Eleuterio Santos Lourenco");
clientData.setPhone(33455676l);
clientData.setSex("M");
list.add(clientData);
orders = new ArrayList<>();
order = new Order();
order.setDescription("description 1");
order.setId(1l);
order.setTotal(32.33);
orders.add(order);
order = new Order();
order.setDescription("description 2");
order.setId(2l);
order.setTotal(42.33);
orders.add(order);
order = new Order();
order.setDescription("description 3");
order.setId(3l);
order.setTotal(72.54);
orders.add(order);
clientData.setOrders(orders);
clientData = new Client();
clientData.setName("Lucebiane Santos Lourenco");
clientData.setPhone(456782387l);
clientData.setSex("F");
list.add(clientData);
orders = new ArrayList<>();
order = new Order();
order.setDescription("description 4");
order.setId(4l);
order.setTotal(52.33);
orders.add(order);
order = new Order();
order.setDescription("description 2");
order.setId(5l);
order.setTotal(102.33);
orders.add(order);
order = new Order();
order.setDescription("description 5");
order.setId(6l);
order.setTotal(12.54);
orders.add(order);
clientData.setOrders(orders);
clientData = new Client();
clientData.setName("Ana Carolina Fernandes do Sim");
clientData.setPhone(345622189l);
clientData.setSex("F");
list.add(clientData);
orders = new ArrayList<>();
order = new Order();
order.setDescription("description 6");
order.setId(7l);
order.setTotal(12.43);
orders.add(order);
order = new Order();
order.setDescription("description 7");
order.setId(8l);
order.setTotal(98.11);
orders.add(order);
order = new Order();
order.setDescription("description 8");
order.setId(9l);
order.setTotal(130.22);
orders.add(order);
clientData.setOrders(orders);
return list;
}
}
So, let’s begin with the examples!
To use the stream API, all we have to to is use the stream() mehod on the Collection’s APIs to get a stream already prepared for our use. The Stream interface use the default methods feature, so we don’t need to implement the interface methods. Another good point on this approach is that consequently all Collections already has support for the Streams feature, so if the reader has that favorite framework for collections (like the commons one from Apache), all you have to do is upgrading the JVM of your projects and the support is added!
The first thing to notice about streams is that they don’t change the Collection. That means that if we do something like this:
public class StreamsExample {
public static void main(String[] args) {
List<Client> clients = CollectionUtils.getData();
clients.stream().filter(
c -> c.getName().equals("Alexandre Eleuterio Santos Lourenco"));
clients.forEach(c -> System.out.println(c.getName()));
}
}
And run the code, we will see that the Collection will still print the 3 clients from our Collection’s test data, not just the one we filtered on our stream! This is a important concept to keep it in mind, since it means we don’t have to populate multiple collections with different data to execute different logic.
So, how we could print the result of our previous filter? All we have to do is link the methods, like this:
. . . clients.stream() .filter(c -> c.getName().equals( "Alexandre Eleuterio Santos Lourenco")) .forEach(c -> System.out.println(c.getName()));
if we run our code again, we will see that now the code only prints the elements we filtered. On this example, as said before, we didn’t received the list we filtered. If we needed to retrieve the Collection formed by the transformations we made on our Streams, we can use the collect method. This method receives 3 functional interfaces as the parameters, but fortunately Java 8 already comes with another interface, called Collectors, that supply common implementations for the interfaces we need to supply to the collect method. Using this features, we could retrieve the Collection coding like this:
. . . List<Client> filteredList = clients .stream() .filter(c -> c.getName().equals( "Alexandre Eleuterio Santos Lourenco")) .collect(Collectors.toList()); filteredList.forEach(c -> System.out.println(c.getName()));
On our previous examples, we retrieved the whole Client objects on our filtering. But and if we wanted to retrieve a List with the names of the Clients that has orders with total > 90 and print on the console? We could do this:
.
.
.
System.out.println("USING THE MAP METHOD!");
clients.stream()
.filter(c -> c.getOrders().stream()
.anyMatch(o -> o.getTotal() > 90))
.map(Client::getName)
.forEach(System.out::println);
The code above could seen a little strange at first, but if we imagine the size of the code we would do to make the same with traditional Java code – iterating by multiple Collections, creating another collection with just the names and iterating again for the prints – we can see that the new features really help to make a more simple and cleaner code. We also see the use of the anyMatch method, which receives a predicate as parameter and returns true or false if any of the elements on the stream succeeds on the predicate.
Besides the all-purpose map method, there’s also another implementations specific for integers, longs and doubles. The reason for this is to prevent the called “boxing effect” where the primitive values would be wrapped and unwrapped on the operations, which will cause a performance overhead, and since we already informed the type of value we are working with, this implementations provide some interesting methods that return things like the average or the max value of our mapping. Let’s see a example. Imagine that we want to retrieve the max total from the orders on each client and print the name and the total on the console. We could do like this:
.
.
.
clients.stream().forEach(
c -> System.out.println("Name: "
+ c.getName()
+ " Highest Order Total: "
+ c.getOrders().stream().mapToDouble(Order::getTotal)
.max().getAsDouble()));
The reader may notice that the max method’s return is not the primitive itself, but a Object. This object is a OptionalDouble, that together with other classes like the java.util.Optional, it supplies a implementation that allow us to provide a default behavior for the cases in which the operation been used with the Optional – in our case, the max() method – has some null element among the values. For example, if we want in our previous operation that the max returns 0 in case any of the elements was null, we could modify the code as follows:
.
.
.
clients.stream().forEach(
c -> System.out.println("Name: "
+ c.getName()
+ " Highest Order Total: "
+ c.getOrders().stream().mapToDouble(Order::getTotal)
.max().orElse(0)));
One interesting behavior of the streams is their lazy behavior. That means that when we create a flow – also called a pipe – of streams operations, the operations will always execute only at the time they are really needed to produce the final result. We can see this behavior using one method called peek(). Let’s see a example that clearly shows this behavior:
.
.
.
clients.stream()
.filter(c -> c.getName().equals(
"Alexandre Eleuterio Santos Lourenco"))
.peek(System.out::println);
System.out.println("*********** SECOND PEEK TEST ******************");
clients.stream()
.filter(c -> c.getName().equals(
"Alexandre Eleuterio Santos Lourenco"))
.peek(System.out::println)
.forEach(c -> System.out.println(c.getName()));
If we run the example above, we can see that on the first stream the peek method doesn’t print anything. That’s because the filter operation it was not executed, since we didn’t do anything with the stream after the filtering. On the second stream, we used the foreach operation afterwards, so the peek method will print a toString() of all the objects inside the filtered stream.
On our previous examples, we see the max method, which returns the max value from a stream of numbers. That type of operation, that returns a single result from a stream, is called a reduce operation. We can make our own reduce operations, just providing a initial value and the operation itself, using the reduce method. For example, if we wanted to subtract the values from the stream:
.
.
.
clients.stream().forEach(
c -> System.out.println("Name: "
+ c.getName()
+ " TOTAL SUBTRACTED: "
+ c.getOrders().stream().mapToDouble(Order::getTotal)
.reduce(0, (a, b) -> a - b)));
This is a really useful feature to keep in mind when the default arithmetic operations don’t suffice.
Parallel Streams
At last, let’s talk about the last subject on our streams’s journey: parallel streams. When using parallel streams, we run all the operations we see previously with parallel processing mode, instead of just the main thread as usual. The jdk will choose the number of threads, how to break the segments of processing and how to join the parts to the final result. The reader may be asking “what do I have to pass to help the jdk on this settings?” the answer is: nothing! That’s right, all we have to do to use parallel streams is change the beginning of our commands, like the example bellow:
. . . clients.parallelStream() .filter(c -> c.getOrders().stream() .anyMatch(o -> o.getTotal() > 90)).map(Client::getName) .forEach(System.out::println);
As we can see, all we have to do is change from stream() to parallelStream(). One important thing to keep in mind is when to use parallel streams. Since there is a payload of preparing the thread pool and managing the segmentation and joining of the results, unless we have a really big volume of data to use or a really heavy operation to do with the data, we normally will use single thread streams.
Other features
Of course, there is more features we could talk on this post, like the sort method, that as the name implies, make sorting of the items on our streams. Another really powerful feature is on the Collectors’s methods, which has impressive transformation options such as grouping, partitioning, joining and so on. However, with this post we made a very good start with the usage of the feature, sowing the way for his adoption.
Conclusion
And so we conclude another part of our series. As we can easily see, streams is a very powerful tool, which can help us a lot on keeping a really short code when processing our collections. That is one of the keys – or maybe the master key – of the Java 8 philosophy. For years, the Java scenario was plagued with “accusations” of not being a simple language, since it is so verbose, specially with the appearance of languages like Python or Ruby, for example. With this new features, maybe the burden of “being complex” for Java will finally begone. I thank the reader for following me on another post and invite you to please return to the last part of our series, when we will talk about the last of our pillars, the new Date API. Until next time.
Technology explained 