DevOps Zone is brought to you in partnership with:

I'm a software engineer with approaching 20 years experience in the industry with a background in C/C++/Java and Perl and have picked up Scala recently. I'm currently contracting to Morgan Stanley in the Securitized Products Group. Current interest is Java 8's functional programming support which I'm writing a blog on. David is a DZone MVB and is not an employee of DZone and has posted 8 posts at DZone. You can read more from them at their website. View Full User Profile

Introduction to Functional Programming in Java 8 – Part Two

07.18.2014
| 4680 views |
  • submit to reddit

Welcome to Part Two! To begin this session, let’s start with a return to our HelloWorld example from the last article.

public class HelloWorldConcise
{
        private void doPrint(String str)
        {
                System.out.println(str);
        }
 
        private String greet(String country)
        {
                return "Hello " + country + "!";
        }
 
        public void greetCountries()
        {
                List<String> countries = Arrays.asList("France", "India",
                "China", "USA", "Germany");
 
                countries.stream().map(this::greet)
                                  .forEach(this::doPrint);
        }
 
        public static void main(String[] args)
        {
                new HelloWorldConcise().greetCountries();
        }
}

Let’s make one more change to the pipeline – how about we get rid of countries that contain a G:

countries.stream().filter(country -> country.indexOf('G') == -1)
                  .map(this::greet).forEach(this::doPrint);

Now it only greets 4 countries. The filter operation keeps items where the filter’s expression evaluates to true, and discards the others. In this case we have another lambda expression which taking the item to be called country checks that it doesn’t contain a G.

This is very useful as we don’t have to alter the original list, or stop work half way to manually remove some items. Note that it’s also very easy to add another element to our pipeline, and still quite readable what’s going on.

As we’ve done before, let’s look at the under the hood at filter. In this case the lambda expression is actually a Predicate. Predicate has a function ‘test’ which we override to perform our check. Here is an inner-class with the filter’s test explicitly written out:

private static class DoesntContainG implements Predicate<String>
{
    @Override
    public boolean test(String str)
    {
        return str.indexOf('G') == -1;
    }
}

We can change the pipeline as follows to use this class:

countries.stream().filter(new DoesntContainG())
          .map(this::greet).forEach(this::doPrint);

Instead of the inner class we could add a new function and pass that as we’ve done before:

private boolean doesntContainG(String str)
{
    return str.indexOf('G') == -1;
}

and then change the pipeline to the very concise:

countries.stream().filter(this::doesntContainG)
          .map(this::greet).forEach(this::doPrint);

How readable is that? Take countries, stream them, filter leaving those that do not contain G, map them to a greeting and print them.

Now suppose we need to use a value part of the way along the pipeline. One obvious application is debugging. If we wanted to print the values so far, we couldn’t use a forEach. forEach is a terminal operation, it consumes all the items and so no operation can follow it. Instead the operation peek is what we need.

Let’s see Germany being removed. We’ll add the following function:

private void check(String country)
{
    System.out.println("Found " + country);
}

and change the pipeline as follows:

countries.stream().peek(this::check).filter(this::doesntContainG)
          .peek(this::check).map(this::greet)
          .forEach(this::doPrint);

This will print the countries before and after the filter. Note that Germany is only found once (before the filter), where as all the others are found after as well, so we can conclude that the filter is indeed removing it.

For a preview of what will be covered in a future article, try changing stream() to parallelStream() in the example and see what happens.

So that’s the basic operations we’ve covered so far in the blog. We can take a container make a stream, transform items, filter items, peek at them and do something with them.

Published at DZone with permission of David Flynn, author and DZone MVB. (source)

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)