Java 8 Resources

Java 8 Cheatsheet

// Lambda expressions

(parameters) -> expression e.g. (int x, int y) -> x + y

(parameters) -> statement e.g. () -> System.out.println("hi " + s)

(parameters) -> { statements } e.g. (String s) -> { int n = s.length(); return n; }

// Method references

Class::staticMethod e.g. Arrays.sort(items, Util::compareItems);

instance::instanceMethod e.g. items.forEach(System.out::print);

// Default methods

interface InterfaceName { e.g. interface Descriptive {

default ReturnType methodName() { default String describe() {

implementation return "fantastic";

} }

RESTful service one-liner with Java 8 and Rapidoid

Let's see why Java 8 is so great!

We can start an embedded Rapidoid web server and implement a simple RESTful service with 1 line of code (and Rapidoid):

On.get("/size").json((String msg) -> msg.length());

GET /size?msg=xyz

GET /size?msg=hello

Introduction to Java 8 Lambda expressions

Let's create and run some Runnable! With Java 8, instead of using anonymous classes, we can use lambda expressions.
The syntax (params) -> statement is used to create an instance of Runnable by implementing its run method.
This is possible only for interfaces that have only one abstract method, and such interfaces are called functional interfaces.
Wait, aren't all interface methods abstract? Not anymore. See Defender (Default) methods.

Runnable r = () -> System.out.println("Hello!");

r.run(); // prints "Hello!"

// Before Java 8, we had to write code like this:

Runnable r = new Runnable() {

@Override

public void run() {

System.out.println("Hello!");

}

};

Sorting a collection using Lambda comparator

class Person {

public String name;

public int age;

}

List<Person> persons = new ArrayList<>(); // TODO we should add some persons to this list

// Sorting the persons by name is easy: using lambda to implement the Comparator

Collections.sort(persons, (p1, p2) -> p1.name.compareTo(p2.name));

// Before Java 8, we had to write code like this:

Collections.sort(persons, new Comparator<Person>() {

public int compare(Person p1, Person p2) {

return p1.name.compareTo(p2.name);

}

});

Default (aka Defender) methods

Starting from Java 8, a method defined in an interface can have a default implementation:

interface Descriptive {

default String desc() {

return "fantastic";

}

class Item implements Descriptive {

// the method "desc" is not implemented here

}

Item item = new Item();

item.desc();"fantastic"

class Book implements Descriptive {

@Override

public String desc() {

return "Cool book!";

}

Book book = new Book();

book.desc();"Cool book!"

Effectively final variables

Effectively final variable is a variable that doesn't change its value (a constant).
Such variables can be referenced in lambdas without the need to explicitly mark them as "final":

// s is effectively final (not changed anywhere)

String s = "foo";

// s can be referenced in the lambda

Callable<String> callable = () -> s;

callable.call();"foo"

Filtering and counting elements using Java 8 Streams

List<String> strings = Arrays.asList("a", "", "b", "", "c");

// Count the non-empty strings

long nonEmptyCount = strings.stream()

.filter(x -> !x.isEmpty())

.count();3

// Count the empty strings

long emptyCount = strings.stream()

.filter(String::isEmpty) // same as .filter(x -> x.isEmpty())

.count();2

Map and join elements using Java 8 Streams

List<String> strings = Arrays.asList("A", "bbb", "CC", "dd");["A","bbb","CC","dd"]

// Map the strings to UPPERCASE and join them with the : separator

String joined = strings.stream()

.map(String::toUpperCase)

.collect(Collectors.joining(":"));"A:BBB:CC:DD"

Filtering distinct elements using Java 8 streams

List<String> words = Arrays.asList("hello", "cool", "Java8", "world!");["hello","cool","Java8","world!"]

List<Integer> lengths = words.stream()

.map(String::length)

.distinct()

.collect(Collectors.toList());[5,4,6]

Calculate statistics (count, min, max, sum, average)

List<Integer> numbers = Arrays.asList(10, 3, 2, 5, 9, 4);[10,3,2,5,9,4]

IntSummaryStatistics stats = numbers.stream().mapToInt(x -> x).summaryStatistics();

stats.getCount();6

stats.getMin();2

stats.getMax();10

stats.getSum();33

stats.getAverage();5.5

Java 8 Resources - This is NOT the official website of Java.