Java 8

Outline
➢ Default Methods (Defender methods)
➢ Lambda expressions
➢ Method references
➢ Functional Interfaces
➢ Stream API (Parallel operations)
➢ Other new features

Functional Interfaces
Interfaces with only one abstract method.
With only one abstract method, these interfaces can be
easily represented with lambda expressions
Example
@FunctionalInterface
public interface SimpleFuncInterface {
public void doWork();
}

Default Methods
In Context of Support For Streams
Java 8 needed to add functionality to existing
Collection interfaces to support Streams (stream(),
forEach())

Default Methods
➢ Pre-Java 8 interfaces couldn’t have method bodies.
➢ The only way to add functionality to Interfaces was to
declare additional methods which would be
implemented in classes that implement the interface.
➢ It is impossible to add methods to an interface without
breaking the existing implementation.
Problem

Default Methods
➢ Default Methods!
➢ Java 8 allows default methods to be added to interfaces
with their full implementation
➢ Classes which implement the interface don’t have to
have implementations of the default method
➢ Allows the addition of functionality to interfaces while
preserving backward compatibility
Solution

Default Methods
public interface A {
default void foo(){
System.out.println("Calling A.foo()");
}
public class Clazz implements A {}
Clazz clazz = new Clazz();
clazz.foo(); // Calling A.foo()
Example

Lambda Expressions
The biggest new feature of Java 8 is language level support for
lambda expressions (Project Lambda).
Java lambda expressions are Java's first step into functional
programming. A Java lambda expression is thus a function
which can be created without belonging to any class.
A lambda expression can be passed around as if it was an
object and executed on demand.

Lambda Expressions
Following are the important characteristics of a lambda
expression
➢ Optional type declaration.
➢ Optional parenthesis around parameter.
➢ Optional curly braces.
➢ Optional return keyword.

Lambda Expressions
➢ With type declaration, MathOperation addition = (int a, int
b) -> a + b;
➢ Without type declaration, MathOperation subtraction = (a,
b) -> a - b;
➢ With return statement along with curly braces,
MathOperation multiplication = (int a, int b) -> { return a * b;
};
➢ Without return statement and without curly braces,
MathOperation division = (int a, int b) -> a / b;
interface MathOperation {
int operation(int a, int b);
}

Lambda Expressions
Example
Runnable task = new Runnable() {
@Override
public void run() {
System.out.println("I am a runnable task");
}
};
task.run();
// Removed boiler plate code using lambda expression
Runnable task = () -> { System.out.println("I am a runnable task");
};
task.run();

Internal vs External
Iteration
// External iteration
List<Integer> numbers = Arrays.asList(20, 40, 50, 100,
4, 3, 2, 6, 8);
for (Integer number : numbers) {
System.out.println(number);
}
// Internal iteration
numbers.forEach(number -> System.out.println(number));

➢ Predicate<T> -> test a property of the object passed as
argument
➢ Consumer<T> -> execute an action on the object
passed as argument
➢ Function<T, U> -> transform a T to a U
➢ BiFunction<T, U, V> -> transform a (T, U) to a V
➢ Supplier<T> -> provide an instance of a T (such as a
factory)
➢ UnaryOperator<T> -> a unary operator from T -> T
➢ BinaryOperator<T> -> a binary operator from (T, T) -> T
Give a look at java.util.function.*
Common JDK8
@FunctionalInterfaces

➢ You use lambda expressions to create anonymous
methods. Method references help to point to methods
by their names. A method reference is described
using :: (double colon) symbol.
➢ You can use replace Lambda Expressions with
Method References where Lambda is invoking
already defined methods.
➢ You can’t pass arguments to methods Reference.
Method references

➢ Reference to a static method
List<Integer> numbers =
Arrays.asList(1,2,3,4,5,6,7,8,9);
numbers .forEach(System .out::println);
➢ Reference to an Instance Method of a Particular Object
class Printer {
void print(Object message) {
System.out.println(message);
}
}
Printer printer = new Printer();
List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9);
numbers.forEach(printer ::print);
Method references

➢ Reference to an Instance Method of an Arbitrary Object of
a Particular Type
Integer[] numbers = {5,9,3,4,2,6,1,8,9};
Arrays.sort(numbers, Integer ::compareTo);
➢ Reference to a Constructor
interface StringToChar {
String charToString(char[] values);
}
StringtoChar strChar = String::new;
char[] values = {'J','A','V','A','8'};
System.out.println(strChar .chatToString(values));
Method references

Characteristics of Streams
➢ Streams are not related to InputStreams,
OutputStreams, etc.
➢ Streams are NOT data structures but are wrappers
around Collection that carry values from a source
through a pipeline of operations.
➢ Streams are more powerful, faster and more memory
efficient than Lists
➢ Streams are designed for lambdas
➢ Streams can easily be output as arrays or lists
➢ Streams employ lazy evaluation
➢ Streams are parallelization
➢ Streams can be “on-the-fly”

Creating Streams
➢ From individual values
Stream.of(val1, val2, …)
➢ From array
Stream.of(someArray)
Arrays.stream(someArray)
➢ From List (and other Collections)
someList.stream()
someOtherCollection.stream()

Stream Operations Pipelining
Example
List<Integer> numbers = Arrays.asList(20, 8,
200, 5, 9, 77, 67, 54, 23, 9);
numbers
.stream()
.filter(n -> n % 5 == 0)
.map(n -> n * 2)
.sorted()
.forEach(System .out::println);

Stream laziness
Intermediate & Terminal Operations

Streams – Parallelism for free

Other new features
➢ Nashorn, the new JavaScript engine
➢ Date/Time changes (java.time)
➢ Type Annotations (@Nullable, @NonEmpty,
@Readonly etc)
➢ String abc= String.join(" ", "Java", "8");

Java 8

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Java 8 (20)

Recently uploaded (20)

Java 8