Jim Cheung

Java 8

(notes on Java 8 Tutorial )

Default Methods for Interfaces

a non-abstract method to interface, by utilizing the default keyword. also known as Extension Methods

interface Formula {
    double calculate(int a);
    default double sqrt(int a) {
        return Math.sqrt(a);
// usage (anonymous object)
Formula formula = new Formula() {
    public doble calculate(int a) {
        return sqrt(a * 100);
formula.calculate(100); // 100.0
formula.sqrt(16); // 4.0

Lambda expresssions

before Java 8:

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collection.sort(names, new Comparator<String>() {
    public int compare(String a, String b) {
        return b.compareTo(a);

with Java 8 lambda:

Collection.sort(names, (String a, String b) -> {
    return b.compareTo(a);
// one line method body you can skip {}
Collection.sort(names, (String a, String b) -> return b.compareTo(a));
// you can skip parameter types too, java will get it from the context
Collection.sort(names, (a, b) -> return b.compareTo(a));

Function Interfaces

each lambda corresponds to a given type, specified by an interface - functional interface

the interface must contain exactly one abstract method declaration.

since default methods (mentioned above) are not abstract, you can add default methods to your functional interface.

@FunctionalInterface annotation allows compiler check your interface meets the requirements.


interface Converter<F, T> {
    T convert(F from);
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123"); // 123

Method and Constructor References

the above example can be further simplified by utilizing static method reference:

Converter<String, Integer> converter = Integer::valueOf;

Java 8 enables you to pass references of methods or constructors via the :: keyword.

// can also reference non-static methods
class Something {
    String startsWith(String s) {
        return String.valueOf(s.charAt(0));
Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java"); // "J"

how :: keyword works for constructors:

class Person {
    String firstName;
    String lastName;
    Person() {}
    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

Java autometically choose the right constructor by matching the signature of PersonFactory.create for the reference Person::new

Lambda Scopes

similar to anonymous objects, you can access final variables from the local outer scope, instance fields, and static variables.

read local variables

final int num = 1;
Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3

different to anonymous object, non-final varables also available in lambda:

int num = 1;
Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3

however, num must be implicitly final

// does not compile
int num = 1;
Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num);
num = 3;

writing to num from within the lambda expresssion is also prohibited.

Accessing fields and static variables

we have both read and write access to instance fields and static variables from within lambda expresssions (just like anonymous objecs)

class Lambda4 {
    static int outerStaticNum;
    int outerNum;
    void testScope() {
        Converter<Integer, String> stringConverter1 = (from) -> {
            outerNum = 23;
            return String.valueOf(from);
        Converter<Integer, String> stringConverter2 = (from) -> {
            outerStaticNum = 72;
            return String.valueOf(from);

Accessing default interface methods

Default methods cannot be accessed from within lambda expresssions.

// will not compile:
Formula formula = (a) -> sqrt( a * 100 );

Build-in Functional Interfaces

Existing interfaces are extended to enable lambda support via the @FunctionalInterface annotation, like Comparator and Runnable.

New functional interfaces:


Predicate<T>: take a T as input, return a boolean as output

Predicates are boolean-valued functions of one argument. The interface contains various default methods for composing predicates to complex logical terms (and, or, negate)

Predicate<String> predicate = (s) -> s.length() > 0;
predicate.test("foo"); // true
predicate.negate().test("foo"); // false
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();


Function<T,R>: take a T as input, return an R as output

Functions accept one argument and produce a result. Default methods can be used to chain multiple functions together (compose, andThen)

Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"


Supplier<T>: with nothing as input, return a T

Suppliers produce a result of a given generic type. Unlike Functions, Suppliers don't accept arguments.

Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person


Consumer<T>: take a T as input, return nothing

Consumers represents operations to be performed on a single input argument.

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));


Java 8 addes various default methods to the interface.

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0 


Optionals are not functional interface, it's a nifty utility to prevent NullPointerException.

Optional is a simple container for a value which maybe null or no-null.

for a method which may return nothing, instead of returning null you return an Optional in Java 8.

Optional<String> optional = Optional.of("bam");
optional.isPresent(); // true
optional.get(); // "bam"
optional.orElse("fallback"); // "bam"
optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"


A java.util.Stream represents a sequence of elements on which one or more operations can be performed.

Stream operations are either intermediate (return stream itself) or terminal (return result).

Stream operations can either be executed sequential or parallel.

Streams are created on a source (e.g. a java.util.Collection like lists or sets [maps are not supported])

List<String> stringCollection = new ArrayList<>();
// ...

Collections in Java 8 are extended, you can create streams either by Collection.stream() or Collection.parallelStream()


intermediate operation

    .filter((s) -> s.startsWith("a"))

forEach is a terminal operation.


intermediate operation

sorted in natural order unless you pass a custom Comparator

    .filter((s) -> s.startsWith("a"))

sorted() only creates a sorted view of the stream, the ordering of stringCollection is untouched.


intermediate operation

you can use map to transform each object into another type. the generic type of the resulting stream depends on the generic type of the function you pass to map.

    .sorted((a, b) -> b.compareTo(a))


terminal operations and return a boolean result.

boolean anyStartsWithA =
        .anyMatch((s) -> s.startsWith("a"));
System.out.println(anyStartsWithA); // true
boolean allStartsWithA =
        .allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA); // false
boolean noneStartsWithZ =
        .noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // true


terminal operation and returns the number of elements in the stream as a long.

long startsWithB =
        .filter((s) -> s.startsWith("b"))


terminal operation and returns an Optional holding the reduced value.

Optional<String> reduced =
        .reduce((s1, s2) -> s1 + "#" + s2);

Parallel Streams

int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
    UUID uuid = UUID.randomUUID();
// sequential sort
long t0 = System.nanoTime();
long count = value.stream().sorted().count();
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis));
// parallel sort
long count = value.parallelStream().sorted().count();


As already mentioned maps don't support streams. Instead maps now support various new and useful methods for doing common tasks.

Map<Integer, String> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
    map.putIfAbsent(i, "val" + i);
map.forEach(id, val) -> System.out.println(val));
map.computeIfPresent(3, (num, val) -> val + num);
map.get(3); // val33
// utilizing functions
map.computeIfPresent(9, (num, val) -> null);
map.containKey(9); // false
map.computeIfAbsent(23, num -> "val" + num);
map.containKey(23); // true
map.computeIfAbsent(3, num -> "bam");
map.get(3); // val33
// remove
map.remove(3, "val3");
map.get(3); // val33
map.remove(3, "val33");
map.get(3); // null
// another helpful method
map.getOrDefault(42, "not found"); // not found
// merging
map.merge(9, "val9", (value, newValue) -> vale.concat(newValue));
map.get(9); // val9
map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9); // val9concat

merge either put the key/value into the map if no entry for the key exists, or the merging function will be called to change the existing value.

Date API

the new Date API is not the same as Joda-Time library.


Clock provides access to the current date and time.

Clocks are aware of a timezone.

Instant class can be used to create legacy java.util.Date objects.

Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();
Instant instant = clock.instant();
Date legacyDate = Date.from(instant); // legacy java.util.Date


Timezones are represented as a ZoneId

// prints all available timezone ids
ZoneId zone1 = ZoneId.of("Europe/Berlin");
ZoneId zone2 = ZoneId.of("Brazil/East");


LocalTime represents a time without a timezone.

LocalTime now1 = LocalTime.now(zone1);
LocalTime now2 = LocalTime.now(zone2);
System.out.println(now1.isBefore(now2)); // false
long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
long minutesBetween = ChronoUnit.MINUTES.between(now1, now2));
System.out.println(hoursBetween); // -3
System.out.println(minutesBetween); // -239

LocalTime comes with various factory method to simplify the creation of new instances.

LocalTime late = LocalTime.of(23, 59, 59);
System.out.println(late); // 23:59:59
DateTimeFormatter germanFormatter = 
LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
System.out.println(leetTime); // 13:37


LocalDate represents a distinct date, e.g. 2014-03-11.

it's immutable.

LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
LocalDate yesterday = tomorrow.minusDays(2);
LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
DateOfWeek dayOfWeek = independenceDay.getDayOfWeek();
System.out.println(dayOfWeek); // FRIDAY

parsing a LocalDate from string is just like parsing a LocalTime

DateTimeFormatter germanFormatter = 
LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
System.out.println(xmas); // 2014-12-24


LocalDateTime represents a date-time. immutable.

LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
System.out.println(dayOfWeek);      // WEDNESDAY

Month month = sylvester.getMonth();
System.out.println(month);          // DECEMBER

long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
System.out.println(minuteOfDay);    // 1439
// convert to instant
Instant instant = sylvester
Date legacyDate = Date.from(instant);
System.out.println(legacyDate);     // Wed Dec 31 23:59:59 CET 2014
// formatting
DateTimeFormatter formatter =
        .ofPattern("MMM dd, yyyy - HH:mm");
LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
String string = formatter.format(parsed);
System.out.println(string);     // Nov 03, 2014 - 07:13

Unlike java.text.NumberFormat the new DateTimeFormatter is immutable and thread-safe.