\n4. Lambda expressions

After all these traditional approaches it’s time to move on to the lambda expressions, which have been introduced into Java 8.

",{"_178":179,"_43":44,"_47":48,"_45":46,"_65":66,"_180":181,"_204":176},"previewContent","

\n Preliminary note\n
\n Cover image\n
\n Acknowledgements\n
\n About the Author\n
\n About this book\n
- \n Conventions\n
- \n Links\n
- \n Errors and typos\n
- \n Copyright\n
\n
\n 1. Inroduction\n
- \n 1.1 Lambdas and (Parallel) Streams\n
- \n 1.2 The challenge\n
- \n 1.3 The solution\n
- \n 1.4 A first explanation\n
\n
\n 2. The data\n
\n 3. First analysis - from naive to flexible\n
- \n 3.1 Fix filter\n
- \n 3.2 Simple parameterization\n
- \n 3.3 Behavior parameterization\n
- \n 3.4 Anonymous classes\n
\n
\n 4. Lambda expressions\n
\n 5. Additional chapters\n

Preliminary note

\n\n

Whenever I have spoken about Java Lambdas and Streams at conferences and round table events there has been strong interest and lively discussions with the attendees.\nTypically the unfamiliar syntax forms a significant hurdle even (or especially?) for experienced programmers. \nHowever, once a developer masters the syntax, he / she usually doesn’t want to revert to the pre-lambda style.

\n\n

Realising that the new syntax is an impediment for many developers I decided to share my experience and insights in a format that can be used as a reference. \nThe aim of this concise book is to help you to overcome the learning curve and to master the new world of Lambdas and Streams.

\n\n

Following Leanpub’s motto “Publish early, publish often” I published this first edition in an early but complete state. \nPurchasers may look forward to downloading all updates or supplements that may become available in the future.

\n\n

I hope that you enjoy reading it and achieve sustained success with Java Lambdas and Parallel Streams.

\n\n

Michael Müller

\n\n

Brühl, Germany, December 2015

\n\n

Cover image

\n\n

Every line of red elements represents a stream of objects.\nThe multitude of lines stands for the parallelizm of these streams.

\n\n

In this respect, the title page symbolizes a central topic of this book: \nThe parallel processing using streams. And without lambda statements, this is unimaginable.

\n\n

Acknowledgements

\n\n

To my wife Claudia and my kids:

\n\n

Thank you for your patience during night-writing and other long sessions.

\n\n

I love you.

\n\n

To the may people I conversed at conferences as well as attendees of my talks:

\n\n

Thank you for the informative and interesting conversations.\nThereby I recognized, how important the matter of Java Lambdas and Streams is for you and how much information demand exists.\nWithout you, this book would not be written.

\n\n

To you, my dear reader:

\n\n

Thank you for interest in this book.\nI hope, I could write an understandable and valuable book, which helps you to success.

\n\n

About the Author

\n\n

Michael Müller is an IT professional with more than 30 years of experience including about 25 years in the healthcare sector. \nDuring this time, he has worked in different areas, especially project and product management, consulting, and software development. \nDuring a couple of Software development project, he also could gain intensive international experience.

\n\n\n

Currently, he is the head of software development at the German DRG institute inek.org. \nIn this role, he is responsible for Web applications as well as other Java and .NET projects.\nWeb projects are preferably built with Java technologies such as JSF with the help of supporting languages like JavaScript.

\n\n

Michael has a strong experience using lambda statements the .Net environment (LINQ with C#). \nBeginning with Java 8, he finally can use similar powerful features with Java.

\n\n

Michael is a JSF professional user and a member of the JSR 344 and JSR 372 (JSF) expert groups. \nHis first book Web Development with Java and JSF consequential deals with this Java web technology.

\n\n

He frequently reads books and writes reviews as well as technical papers, which are mostly published in German-printed magazines and on his website at it-rezension.de. \nBesides that, he irregular blogs about software development at blog.mueller-bruehl.de.

\n\n

About this book

\n\n

Lambdas and Streams are language elements that have been found their way into the Java world with version 8.\nThis book wants to introduce in their concepts in a concise form.

\n\n

For this purpose it is necessary to introduce a couple of new supporting features like functional interfaces, default methods and more.\nOnce introduced, streams can be parallelized in a very simple way - within certain limits, no knowledge about the thread management is needed. \nThis will be handled transparently behind the scenes.\nNevertheless, some basic things in the context of parallelism need to be considered.\nHere, the book provides a variety of information from practice.

\n\n

The aim of the book is therefore, to provide all relevant information around the topic Java Lambdas and (parallel) Streams.\nWith this book, you should be able to use this technology in your own projects.\nYou are invited to report how well this has been possible and to send feedback to the author!

\n\n

Conventions

\n\n\n\n\n\n\n\n

\n\n

Links

\n\n

During this book you’ll find a lot of useful links, pointing to further or additional information.\nAll these links have been checked by the author at the time of writing.\nSince these links point to external resources that might be changed at any time by the appropriate content owner, a link might not be valid any more or does not point to the expected information.\nIf you discover such an invalid link, please contact the author of this book to enable a correction.

\n\n

Errors and typos

\n\n

All information for this book have been faithful researched or developed.\nHowever, there can’t be any guarantee of being be error-free. \nIf you discover errors or typos, please inform the author.

\n\n

Copyright

\n\n

This book is written by Michael Müller and protected by copyright.

\n\n

For your private, non-commercial usage, feel free to use your copy of this book and the downloadable source code.

\n\n

For commercial or educational usage, please contact the author.

\n\n\n

\n1. Inroduction

\n\n

\n1.1 Lambdas and (Parallel) Streams

\n\n

Some of the new features introduced in Java 8, like the new Date and Time API, feel quite familiar and can be used immediately by an experienced Java developer. \nBut some of the most important enhancements, including Lambdas and Streams, require the developer to learn some new concepts.\nLambda statements in particular introduce a syntax which is quite unusual for object oriented programmers. \nThese language constructs are known only to developers who used functional programming languages or enhancements like Microsoft’s Linq. \nThis special syntax takes some getting used to and some developers may even be a little frightened at first glance. \nHowever, these enhancements are extremely powerful and it is certainly worth taking the time to understand how they can help you to write code that is not only concise, but also faster to write and more re-usable.

\n\n

This book starts with an explanation of Lambda expressions, shows how they can be used with Streams and finally discusses how both Lambdas and Streams can be combined to implement effective parallel processing.

\n\n

The following task will run like a golden thread through the book:

\n\n

\n1.2 The challenge

\n\n

Analyze a bigger amount of data according to varying criteria
Parallelize this task without explicit use of thread management, synchronization, Excecutor or ForkJoin

\n\n

\n1.3 The solution

\n\n

Use parallelStream() instead of stream()!

\n\n

\n1.4 A first explanation

\n\n

You may well ask “what the hell are the stream() and parallelStream() methods?” \nHere is the quick overview; a more detailed description is given in later chapters.

\n\n

You may imagine a Stream as a continuous flow of data, comparable to something like an InputStream. \nThe data might be emitted by different sources, like a collection, a file, a generator, or some other source. \nHowever, the content of this stream is not simply bytes or characters; instead the stream emits arbitrary objects.

\n\n

\n\n\n

\"Stream — Stream (Quelle is German for source)

\n\n\n

\n\n

On their journey from source to target, the objects may be filtered, changed, transformed, collected or processed in some other way. \nHow and with whichever means this happen will be described later on.

\n\n

A ParallelStream can be imagined as a parallel stream of objects of the same type. \nThe objects are split into different streams at their source.\nLater on, we will discuss the details of this splitting task.

\n\n

\n\n\n

\n\n\n

\n\n

To implement solutions to our challenge we will use some of Java’s new language features including:

\n\n

Lambda statements
Functional Interfaces
Default methods
Optionals
Streams
Operations on streams

\n\n

\n2. The data

\n\n

Back to the challenge.

\n\n

Data about a large number of persons who buy and sell diverse products shall be analyzed. \nThe data structure for this task has a simple design: \nA person has a given name, surame, age and gender. \nA buyer might also be a vendor. \nSales and purchases are stored in lists. \nEach element in this list represents a product by it’s article number, the quantity sold and the unit price. \nThe unit price may change per transaction due to various discounts. \nThe following diagram visualizes the class Person.

\n\n

\n\n\n

\n\n\n

\n\n

In the appendix you’ll find a simple program to create sample data.

\n\n

\n3. First analysis - from naive to flexible

\n\n

In this section we will develop traditional solutions to various filtering requirements. \nWe avoid using Lambdas or Streams so that the techniques illustrated here can be compared with the solutions developed in Chapter 4.

\n\n

\n3.1 Fix filter

\n\n

The first task is to list all customers who are less than 20 years old. \nThis can be done very easily; \nall we need is a loop with a filter condition to select young customers and a target list to collect them.

\n\n

Simple implementation to select and collect persons younger then 20 years

\n\n

private List<Person> getPersonsLessThan20Years(List<Person> persons){\n  List<Person> result = new ArrayList<>();\n  for (Person person : persons) {\n    if (person.getAge() < 20) {\n      result.add(person);\n    }\n  }\n  return result;\n}\n

\n\n\n\n

\n3.2 Simple parameterization

\n\n

The next requirement is to collect the group of people between 30 and 40 years old. \nOf course, we realize that in the future we may need to query different age groups and so it would be better to parameterize the method rather than hard coding the condition.

\n\n

Parameterized implementation to choose all persons of a specified age group

\n\n

private List<Person> getPersonsByAgeRange(\n                                    List<Person> persons, \n                                    int from, \n                                    int to) {\nList<Person> result = new ArrayList<>();\n  for (Person person : persons) {\n    if (person.getAge() >= from && person.getAge() <= to) {\n      result.add(person);\n    }\n  }\n  return result;\n}\n

\n\n\n\n

Here, the developer has introduced some flexibility. \nHowever, this method still does no more than select persons of a specified age group. \nIf additional criteria are needed, like querying the gender, this method doesn’t help. \nA novice programmer might try to solve the problem by adding extra parameters for gender, vendor status etc.

\n\n

overloading a method with (too) many parameters

\n\n

private List<Person> getPersonsByDiverseCriteria(\n                                  List<Person> persons, \n                                  int ageFrom, \n                                  int ageTo,\n                                  Gender gender,\n                                  boolean isCustomer,\n                                  boolean isVendor) {\n  [loop omitted]\n}\n

\n\n\n\n

Senior developers might shake their heads at such naive code; \ntheir experience tells them that one day you won’t be able to do your analysis because you will need at least one more parameter.

\n\n

\n3.3 Behavior parameterization

\n\n

The next evolutionary step towards a better solution is to create the condition or filter \nas a stand-alone object and to pass it to the now more general purpose method. \nThis allows the method to be parameterized with different behavior, \nor different algorithms, reminding us of the strategy pattern.

\n\n

For our task this behavior will implement an interface which contains a test to choose a person by a specified condition. \nLet’s call this interface Condition.

\n\n

Interface Condition

\n\n

public interface Condition<T> {\n  boolean test(T t);\n}\n

\n\n\n\n

Now our method (the loop) needs only two parameters, the list of persons and the condition.

\n\n

Flexible filtering due to injectable condition

\n\n

private List<Person> getPersonsByCondition(List<Person> persons,            \\\n                                                              \t\t\t\t\t\t\t\n                      Condition<Person> condition){\n  List<Person> result = new ArrayList<>();\n  for (Person person : persons) {\n    if (condition.test(person)) {\n      result.add(person);\n    }\n  }\n  return result;\n}\n

\n\n\n\n

The condition is swapped out and will be injected by a parameter. \nThus, there is no need to change the implementation of the method when we need a different filter. \nNow let’s refactor our first analysis to get everyone less than 20 years old.

\n\n

Implementation of the condition according to interface Condition

\n\n

class YoungerThanCondition implements Condition<Person>{\n  private final int _age;\n  YoungerThanCondition(int age){\n    _age = age;\n  }\n          \n  @Override\n  public boolean test(Person person) {\n    return person.getAge() < _age;\n  }\n}\n

\n\n\n\n

Now, the code to call our loop and to inject the filter looks more clean and concise.

\n\n

Call loop with filter

\n\n

persons = getPersonsByCondition(persons, new YoungerThanCondition(20));\n

\n\n\n\n

Following the object oriented paradigm we pass the condition to the method as an object. \nNow, if we need other filter criteria, \nwe simply create different filter classes as implementations of the Condition interface. \nThe loop to collect the persons of interest remains unchanged.

\n\n

\n3.4 Anonymous classes

\n\n

But creating a separate class for each different condition still seems to be a heavyweight approach. \nThe question is: “If we only need to use the condition in one place can we create the class just where we’ll need it?” \nThis is where anonymous classes come into play.

\n\n

Parameterize with anonymous class

\n\n

persons = getPersonsByCondition(persons, new Condition<Person>(){\n      @Override\n      public boolean test(Person person) {\n        return person.getAge() < 20;\n      }\n    });\n

\n\n\n\n

Since the anonymous class is just created where it is needed, we can’t re-use it. \nIt doesn’t make sense to pass the age as parameter, we simply write it directly into the condition.

\n\n

Compared with the fully-fledged filter classes, anonymous classes are much shorter. \nBut, instead of passing a short class name as parameter, we have to override the test method and to write a couple of lines. \nAnonymous classes are shorter than fully-fledged classes, but move the code into the parameter; \nthis may not seem ideal. \nAnd by the way - lots of programmers dislike anonymous classes.

\n\n

\n4. Lambda expressions

\n\n

After all these traditional approaches it’s time to move on to the lambda expressions, which have been introduced into Java 8.

\n\n

\n\n\n\n

\n5. Additional chapters

\n\n

Be pleased about additional topics in future editions - pardon, updates - of this book.\nGladly I like to respect your suggestions.

\n\n

Remember, this is a “living” book.\nOnce you purchased it, all future updates are available for download to you.

\n\n\n

\n\n","tocStructure",[182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203],{"_75":76,"_43":77,"_70":-5,"_78":79,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":76,"_43":85,"_70":-5,"_78":86,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":76,"_43":89,"_70":-5,"_78":90,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":76,"_43":93,"_70":-5,"_78":94,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":76,"_43":97,"_70":-5,"_78":98,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":102,"_70":-5,"_78":103,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":107,"_70":-5,"_78":108,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":110,"_70":-5,"_78":111,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":113,"_70":-5,"_78":114,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":76,"_43":116,"_70":-5,"_78":117,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":120,"_70":-5,"_78":121,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":123,"_70":-5,"_78":124,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":126,"_70":-5,"_78":127,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":129,"_70":-5,"_78":130,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":76,"_43":132,"_70":-5,"_78":133,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":76,"_43":136,"_70":-5,"_78":137,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":140,"_70":-5,"_78":141,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":143,"_70":-5,"_78":144,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":146,"_70":-5,"_78":147,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":101,"_43":149,"_70":-5,"_78":150,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":76,"_43":152,"_70":-5,"_78":153,"_71":80,"_104":-5,"_105":-5,"_83":-5},{"_75":76,"_43":156,"_70":-5,"_78":157,"_71":80,"_104":-5,"_105":-5,"_83":-5},"publicChapterContent","nextChapter","sections",[],"routes/_store+/_layout","routes/_store+/_readers+/_layout","actionData","errors"]

\n4. Lambda expressions

Table of Contents

Preliminary note

Cover image

Acknowledgements

About the Author

About this book

Conventions

Links

Errors and typos

Copyright

\n1. Inroduction

\n1.1 Lambdas and (Parallel) Streams

\n1.2 The challenge

\n1.3 The solution

\n1.4 A first explanation

\n2. The data

\n3. First analysis - from naive to flexible

\n3.1 Fix filter

\n3.2 Simple parameterization

\n3.3 Behavior parameterization

\n3.4 Anonymous classes

\n4. Lambda expressions

\n5. Additional chapters