Lambdas are the biggest addition to JAVA in not just release 8 but several releases. But when you look at the cryptic lambda syntax, like most regular programmers, you are left wondering why one should write code this way. 6. The purpose of this tutorial is to introduce lambdas, so that you can start using them in real code.
Overview
Lambdas facilitate defining, storing and passing as parameters blocks of code. They may be stored in variables for later use or passed as parameters to methods who may invoke the code. This style of programming is known as functional programming.
You might argue that JAVA already supported functional programming using anonymous classes. But that approach is considered verbose.
Example
Listing 1 shows the old way to pass executable code to a thread.
public void Listing1_oldWayRunnable() {
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("Hello Anonymous") ;
}
} ;
Thread t = new Thread(r) ;
t.start() ;
}
Listing 2 shows the new way using lambdas.
public void Listing2() {
Thread t = new Thread(()->System.out.println("Hello Lambdas")) ;
t.start() ;
}
Listing 2 has no anonymous class. It is much more compact.
()->System.out.println is the lambda.
Syntax
The syntax is
(type)->statement
Where type is the parameter passed in. In our example, there was no parameter. Hence the syntax was ()->statement
If you had multiple parameters, the syntax would be
(type1,type2)->statement
If you had multiple statements, the syntax would be a
(type) ->{statement1; statement2} ;
Storing in a variable
The lambda expression can also be stored in variable and passed around as shown in listing 3.
public void Listing3() {
Runnable r = ()->System.out.println("Hello functional interface") ;
Thread t = new Thread(r) ;
t.start() ;
}
Functional interface
JAVA 8 introduces a new term functional interface. It is an interface with just one abstract method that needs to be implemented. The lambda expression provides the implementation for the method. For that reason, lambda expressions can be assigned to variables that are functional interfaces. In the example above Runnable is the functional interface.
You can create new functional interfaces. They are ordinary interfaces but with only one abstract method. @FunctionalInterface is an annotation that may be used to document the fact that an interface is functional.
Listing 5 show the definition and usage of a functional interface.
@FunctionalInterface
public interface Greeting {
public void sayGreeting() ;
}
public static void greet(Greeting s) {
s.sayGreeting();
}
@Test
public void Listing5() {
// old way
greet(new Greeting() {
@Override
public void sayGreeting() {
System.out.println("Hello old way") ;
}
}) ;
// lambda new way
greet(()->System.out.println("Hello lambdas")) ;
}
}
Once again you can see that the code with lambdas is much more compact. Within an anonymous class, the "this" variable resolves to the anonymous class. But within a lambda, the this variable resolves to the enclosing class.
java.util.Function
The java.util.Function package in JDK 8 has several starter ready to use functional interfaces. For example the Consumer interface takes a single argument and returns no result. This is widely used in new methods in the java.util.collections package. Listing 6 shows one such use with the foreach method added to Iterable interface, that can be used to process all elements in a collection.
@Test
public void Listing6() {
List l = Arrays.asList(1,2,3,4,5,6,7,8,9) ;
l.forEach((i)->System.out.println(i*i)) ;
}
In summary, Java 8 lambdas introduce a new programming style to java. It attempts to bring JAVA up to par with other languages that claim to be superior because they support functional programming. It is not all just programming style. Lambdas do provide some performance advantages. I will examine them more in future blogs.
Overview
Lambdas facilitate defining, storing and passing as parameters blocks of code. They may be stored in variables for later use or passed as parameters to methods who may invoke the code. This style of programming is known as functional programming.
You might argue that JAVA already supported functional programming using anonymous classes. But that approach is considered verbose.
Example
Listing 1 shows the old way to pass executable code to a thread.
public void Listing1_oldWayRunnable() {
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("Hello Anonymous") ;
}
} ;
Thread t = new Thread(r) ;
t.start() ;
}
Listing 2 shows the new way using lambdas.
public void Listing2() {
Thread t = new Thread(()->System.out.println("Hello Lambdas")) ;
t.start() ;
}
Listing 2 has no anonymous class. It is much more compact.
()->System.out.println is the lambda.
Syntax
The syntax is
(type)->statement
Where type is the parameter passed in. In our example, there was no parameter. Hence the syntax was ()->statement
If you had multiple parameters, the syntax would be
(type1,type2)->statement
If you had multiple statements, the syntax would be a
(type) ->{statement1; statement2} ;
Storing in a variable
The lambda expression can also be stored in variable and passed around as shown in listing 3.
public void Listing3() {
Runnable r = ()->System.out.println("Hello functional interface") ;
Thread t = new Thread(r) ;
t.start() ;
}
Functional interface
JAVA 8 introduces a new term functional interface. It is an interface with just one abstract method that needs to be implemented. The lambda expression provides the implementation for the method. For that reason, lambda expressions can be assigned to variables that are functional interfaces. In the example above Runnable is the functional interface.
You can create new functional interfaces. They are ordinary interfaces but with only one abstract method. @FunctionalInterface is an annotation that may be used to document the fact that an interface is functional.
Listing 5 show the definition and usage of a functional interface.
@FunctionalInterface
public interface Greeting {
public void sayGreeting() ;
}
public static void greet(Greeting s) {
s.sayGreeting();
}
@Test
public void Listing5() {
// old way
greet(new Greeting() {
@Override
public void sayGreeting() {
System.out.println("Hello old way") ;
}
}) ;
// lambda new way
greet(()->System.out.println("Hello lambdas")) ;
}
}
Once again you can see that the code with lambdas is much more compact. Within an anonymous class, the "this" variable resolves to the anonymous class. But within a lambda, the this variable resolves to the enclosing class.
java.util.Function
The java.util.Function package in JDK 8 has several starter ready to use functional interfaces. For example the Consumer interface takes a single argument and returns no result. This is widely used in new methods in the java.util.collections package. Listing 6 shows one such use with the foreach method added to Iterable interface, that can be used to process all elements in a collection.
@Test
public void Listing6() {
List
l.forEach((i)->System.out.println(i*i)) ;
}
In summary, Java 8 lambdas introduce a new programming style to java. It attempts to bring JAVA up to par with other languages that claim to be superior because they support functional programming. It is not all just programming style. Lambdas do provide some performance advantages. I will examine them more in future blogs.
