Java 8 Notes

Subscribe to my newsletter and never miss my upcoming articles

Java, originally evolved from the Oak language, was born in early 1996 with its major version as Java 1 or JDK 1.0. Java was initially designed and developed by James Gosling at Sun Microsystems. Java 8 or JDK 8.0 is one of the major releases of the Java programming language in 2014.

This article would walk you through new features were added in Java 8:

- Lambda Expressions: a new language feature allowing us to treat actions as objects.

- Method References: enable us to define Lambda Expressions by referring to methods directly using their names.

- Optional: special wrapper class used for expressing optionally

- Functional Interface: an interface with maximum one abstract method; implementation can be provided using a Lambda Expression

- Default methods: give us the ability to add full implementations in interfaces besides abstract methods

- Stream API: a special iterator class that allows us to process collections of objects in a functional manner

1. Lambda Expression

    parameter -> expression

    (param_1, param_2) -> expression

    (param_1, param_2) -> {code block}

VD:

import java.util.ArrayList;
import java.util.List;

public class Main {
  public static void main(String[] args) {
    List<Integer> numbers = new ArrayList<>();
    numbers.add(5);
    numbers.add(9);
    numbers.add(8);
    numbers.add(1);
    numbers.forEach( (n) -> System.out.println(n));
  }
}

2. Method References

  • reference a method, reduce the verbosity of some lambdas.

  • using double colons:

  • there are two reference types:

Refer to static method

List<String> messages = Arrays.asList("hello", "phamduyhieu.com", "readers!")

// lambda:
messages.forEach(word -> StringUtils.capitalize(word));

// method reference
messages.forEach(StringUtils::capitalize);

Refer to instance method

public class BicycleComparator implements Comparator<Bicycle> {

    @Override
    public int compare(Bicycle o1, Bicycle o2) {
        return o1.getFrameSize().compareTo(o2.getFrameSize());
    }
}

ArrayList<Bicycle> myList = new ArrayList<>();
myList.add(new Bicycle("hieu", 20));
myList.add(new Bicycle("hieu", 30));
myList.add(new Bicycle("hieu", 40));
myList.add(new Bicycle("hieu", 10));

BicycleComparator myComparator = new BicycleComparator();

// lambda
List<Bicycle> newList = myList.stream().
                sorted((a, b) -> myComparator.compare(a, b)).collect(Collectors.toList());

// with method reference
List<Bicycle> newList2 = myList.stream().sorted(myComparator::compare).collect(Collectors.toList());

3. Optional

  • was created to avoid any runtime NullPointerExceptions, eliminate many null checks. Also, we can develop clean and neat APIs.
// before Optional

if (name != null) {
    System.out.println(name.length());
}

// with Optional
// deal with nullable values explicitly with a shorter way

opt.ifPresent(n -> System.out.println(n.length()));

// orElse() is used to return the wrapped value if it is present, and its argument otherwise

String nullName = null;
String nameTest = Optional.ofNullable(nullName).orElse("Hieu");
System.out.println(nameTest);

4. Functional Interfaces

  • is an interface with one single abstract method, no more, no less
  • support the lambda expression in java 8

  • Before java 8, we would usually create a class for every case where we needed to encapsulate a single piece of functionality => a lot of unnecessary boilerplate code.

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("my runnable");
    }
});

If you look at the above code, the actual part that is of use is the code inside run() method. Rest all of the code is because of the way java programs are structured.

  • Java 8 Functional interfaces and Lambda Expressions help us in writing smaller and cleaner code by removing a lot of boilerplate code.
Thread thread2 = new Thread(() -> System.out.println("my runnable"));

5. Default Method

  • is a method with an implementation which can be found in an interface.

  • to add a new functionality to an interface, while maintaining backward compatibility with classes that are already implementing the interface:

public interface Vehicle {
    public void move();
    default void hoot() {
        System.out.println("peep!");
    }
}
  • For example, the Collection interface can have a default implementation of the forEach method without requiring the classes implementing this interface to implement the same.

6. Streams

  • represents a sequence of objects from a source such as a collection, which supports aggregate operations.
int sum = Arrays.stream(new int[]{1, 2, 3, 4, 5})
        .filter(i -> i >= 3)
        .map(i -> i * 3)
        .sum();
  • in simple terms, a stream is an iterator whose role is to accept a set of actions to apply on each of the elements it contains.

  • Difference between Map and flatMap:

    Both map and flatMap are intermediate stream operations that receive a function and apply this function to all the elements of a stream. But the difference is that for the map, this function returns a value, but for flatMap, this function returns a stream.

No Comments Yet