Introduction
Recently, I had the chance to do some work with Java 8. Since until then, I had experience with Java until version 7, I had to learn some new concepts. In this tip, I would like to describe what I have learned in Java 8 and share it with you.
In Java 8, some elements of functional programming were added to the language. The main purpose for that is to better support multicore programming.
Multicore programming is a very current topic. Nowadays, the increase of power computation is mainly achieved by increasing the number of CPUs on a single board. The increase of CPU clock frequency was common in the past and continued until the early 2000s, when it stopped because of technological limitations.
Functional programming is a programming paradigm that is particularly suited for multicore programming. Functional programming is based on evaluating functions. Examples of functions are x==2 or x+3, where x is an input parameter. When x is 2 then x+3 evaluates 5.
It is very important to point out that these functions do not modify the input parameters nor variables. In other words, these functions do not change the variables of a program. As a result, these functions can be easily parallelized since there is no risk that function1
and function2
will modify variable1
at the same time. This is a core concept of functional programming.
Java 8 is an object oriented language with support for functional programming. Functional programming in Java 8 involves working with objects, methods but also with functions.
The functions used in Java 8 are special kind of functions called lambda expressions.
Lambda Expressions
A Lambda expression is essentially a function without name and is represented as follows:
(params) -> function body
A Lambda expression consists of three parts:
- List of parameters (left of arrow)
- Arrow
- Function body
Some examples of Lambda expressions are:
(1) (2) (3)
x -> x + 2
(1) (2) (3)
(y,z) -> y * z * 2
Lambda expressions can be used in general when you want to pass a piece of code as parameter.
Although the main purpose of functional programming in Java 8 is to simplify the multicore programming, any type of program can benefit from using lambda expressions.
In Java 8, there are two main uses for lambda expressions:
- Use lambda expressions instead of anonymous classes
- Write operations on collections that can be easily parallelized
Use of Lambda Expressions Instead of Anonymous Classes
You can replace any anonymous class with a lambda expression when the anonymous class has just one method. Anonymous classes are also an attempt to pass a piece of code as parameter.
For example, you can pass a piece of code to be executed to a button when it is clicked in two ways, with anonymous classes and with lambda expressions:
button.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent event) {
System.out.println("button clicked");
}
});
button.addActionListener(event -> System.out.println("button clicked"));
The code with Lambda expression is much more compact.
Use Lambda Expressions to Write Operations on Collections That Can Be Easily Parallelized
Lambda expression can be used on collections by the Stream
API.
The Stream
API is a new interface introduced in Java 8 that makes it possible to write functional code on collections with lambda expressions. You can think of the Stream
as a disguised iterator that allows you to examine all the elements of the collection.
Let's see an example: given a collection of Integers, you want to find the number of values larger than 5
.
Without Lambda expressions and Stream
API, you would write a piece of code such as:
int counter = 0;
for (int val : myIntList) {
if(val > 5)
counter++;
}
The code with lambda expressions looks like:
int counter = myIntList.stream().filter(n -> n>5).count();
With the stream
API, you can call the filter
method and pass that lambda expression. You can read the code as follows "give me all values from the collection that satisfy the condition n>5
and count them".
The code with lambda expression has a functional flavor because you pass the Lambda expression n-> n>5
as parameter to the filter
function.
Notice that with the lambda expressions, you focus more on what result you want (all values > 5) and not how you get it (this is a matter of the compiler).
When a stream
function returns another stream
, you can create chains of stream
oerations. In the example stream()
and filter()
return a stream
, so they can be followed by another operation. By contrast, count()
returns an int
so it cannot be followed by another stream
operation.
If you want to parallelize the code on the collection, you can just replace stream
with parallelStream
.
<code>
int counter1 = myIntList.parallelStream().filter(n -> n>5).count();
</code>
When to use stream
or parallelStream
is not a trivial task and beyond the purposes of this tip. Among other things, this will depend on the size of the collection, the number of the available CPUs. In the end, you will need to make comparative tests.
Points of Interest
This tip is an introduction to Java 8 functional features. Functional programming in Java 8 is based on Lambda expressions.
Although the main benefit of Lambda expression is working with large collections of data, I have shown some examples of how Lambda expressions can be useful in common scenarios.
History
- 27th February, 2016: First version