Java 8

Obecne przed Javą 8

• Adnotacje

• Klasy anonimowe

• Typy generyczne

Nowości w Javie 8

• Stream'y

• Optional'e

• Interfejsy funkcyjne

• Wyrażenia Lambda

• Referencje do metod

• Metoda forEach dostępna w kolekcjach

• Domyślne i statyczne metody w interfejsach

• MetaSpace (brak PERM)

• Data i Czas - nowy interfejs

Obecne przed Javą 8

Adnotacje służą do przekazywania meta danych, innymi słowy przekazują dane o danych (kodzie źródłowym).

Definicja adnotacji Override – adnotacja napisana z użyciem adnotacji:

@Target(ElementType.METHOD) - możliwość stosowania do np: TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE

@Retention(RetentionPolicy.SOURCE) - jak długo adnotacje mają być przechowywane: możliwe wartości: SOURCE, CLASS, RUNTIME.

public @interface Override {}

Informacje o "cyklu życia" adnotacji definiowane są przez adnotację @Retention:

• usuwane przez kompilator w trakcie kompilacji (RetentionPolicy.SOURCE)

• umieszczanie w skompilowanej klasie, ale nie dostępne w trakcie uruchomienia programu (RetentionPolicy.CLASS) – domyślna wartość

• dostępne w trakcie wykonywania programu (RetentionPolicy.RUNTIME)

Klasy anonimowe to klasy wewnętrzne, które mają dokładnie jedną instancję, bez deklaracji. Do wywołania konstruktora klasy anonimowej niezbędny jest interfejs (w związku z brakiem deklaracji a tym samym nazwy). W klasach wewnętrznych (również anonimowych) można używać stałych lub efektywnie stałych.

Typy generyczne to swojego rodzaju "szablony", dzięki którym możemy unikać niepotrzebnego rzutowania.

Deklaracja typu generycznego (możliwość parametryzowania jednym lub większą ilością obiektów)

public class FuncyBox <T,S> {
    private T first;
    private S second;

    public Pair(T first, S second) {
        this.first = first;
        this.second = second;
    }
}

Przypisanie wartości:

FancyBox<Orange, Integer> orangeBox = new BoxOnSteroids<>(new Orange(), 123);

Wildcard - metody przyjmujące jako argument obiekty generyczne (mogące rónież być ograniczone z góry (extends) lub z dołu (super)).

Klasa Figure rozszerzana jest przez klasę Rectangle, a ta rozszerzana jest przez klasę Square.

Deklaracja metody z użyciem typu generycznego:

private static <T> void method1(FancyBox<T> box) {

Deklaracja metody z użyciem wildcard:

private static <T> void method2(FancyBox<?> box) {

private static void method3(FancyBox<? extends Rectangle> box) {

private static void method4(FancyBox<? super Rectangle> box) {

private static void methodExtends(FancyBox<? extends Rectangle> box) {
    box.object = null;
    box.object = new Square(); // DNC
    box.object = new Rectangle(); // DNC
    box.object = new Figure(); // DNC
}

private static void methodSuper(FancyBox<? super Rectangle> box) {
    box.object = null;
    box.object = new Square();
    box.object = new Rectangle();
    box.object = new Figure(); // DNC
}

Nowości w javie 8

List<String> items = Arrays.asList("apple", "apple", "banana", "apple", "orange", "banana");

Map<String, Long> result = items.stream().collect(
    Collectors.groupingBy(
        Function.identity(),      // zwraca samgo siebie (w tym przypadku Stringa – element listy)
        Collectors.counting()     // zlicza ilość wystąpień
    )
);

result => {orange=1, banana=2, apple=3}

List<Item> fruits = Arrays.asList(
    new Item("apple", 10, new BigDecimal("9.99")),
    new Item("banana", 20, new BigDecimal("19.99")),
    new Item("orange", 10, new BigDecimal("29.99")),
    new Item("apple", 10, new BigDecimal("9.99")),
    new Item("banana", 10, new BigDecimal("19.99")),
    new Item("apple", 20, new BigDecimal("9.99")));

Map<String, Long> counting = fruits.stream().collect(
    Collectors.groupingBy(Item::getName, Collectors.counting()));

counting => {
    orange=1,
    banana=2,
    apple=3}

Collectors.counting()

Map<String, Integer> sum = fruits.stream().collect(
    Collectors.groupingBy(Item::getName,
    Collectors.summingInt(Item::getQty)));

sum => {
    orange=10,
    banana=30,
    apple=40}

Collectors.summingInt(Item::getQty)

Map<Integer, List<String>> result2 = fruits.stream().collect(
    Collectors.groupingBy(
        Item::getQty,
        Collectors.mapping(Item::getName, Collectors.toList())));

result2 => {
    20=[banana, apple],
    10=[apple, orange, apple, banana]}

Collectors.mapping(Item::getName, 
Collectors.toList())

Stream.empty() - zwraca pustego streama (np zamiast return null;)

Stream.builder() - zwraca Stream.Buildera np. Stream.Builder<Employee>

Do buildera dodajemy elementy za pomocą metody accept LUB add (która wywołuje accept() i zwraca this).

Stream.build() - tworzy Streama ze Stream.Builder'a

Stream.of(array) LUB Stream.of(obj1, obj2, obj3) - zwraca streama, zawierającego elementy tablicy lub poszczególne obiekty

@FunctionalInterface
public interface OwnConsumer {
    void consumeString(String str);
}

public class InterfaceExamples {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("raz", "i dwa");
        printList1(list, str -> System.out.println(str));
        printList2(list, str -> System.out.println(str));
    }
 
    public static void printList1(List<String> list, OwnConsumer consumer) {
        list.forEach(consumer::consumeString); // zamiast używać referencji do metody, równie dobrze można by to zrobić po "staremu" w pętli for
    }
 
    public static void printList2(List<String> list, Consumer<String> consumer) {
        list.forEach(consumer::accept); // zamiast używać referencji do metody, równie dobrze można by to zrobić po "staremu" w pętli for
    }
}

Dzięki takiemu wykorzystaniu interfejsów funkcyjnych, możemy do metody przekazać wyrażenie Lambda jako parametr.

Jeśli interfejs nie będzie oznaczony adnotacją @FunctionalInterface, powyższy kod będzie działał tak samo.

Składnia:

<lista parametrów> -> <ciało wyrażenia>

Podawanie typów parametrów jest opcjonalne. Kompilator jest w stanie poznać te parametry z kontekstu w którym znajduje się dane wyrażenie lambda.

Przykładowe wyrażenie lambda z podanymi typami parametrów:

>(Integer x, Long y) -> System.out.println(x * y)

Przykładowe wieloliniowe wyrażenie Lambda:

x -> {
    int y = x * x;
    return y;
}

Każde wyrażenie Lambda jest jest instancją dowolnego interfejsu funkcyjnego (posiadającego tylko jedną metodę abstrakcyjną).

Przykłady interfejsów funkcyjnych: UnaryOperator, Supplier, Consumer, BiConsumer, Function, Predicate, BiPredicate.

UnaryOperator<Integer> square = x -> x * x;

Supplier<String> someString = () -> "some return value";

Consumer<String> consumer = s -> System.out.println(s);

BiConsumer<Integer, Long> multiplier = (Integer x, Long y) -> System.out.println(x * y);

• statycznych
• instancji określonego typu (klasy, interfejsu)
• instancji metod istniejących obiektów
• konstruktora

Metoda forEach dostępna w kolekcjach

List<String> list = Arrays.asList("jeden", "dwa", "trzy");

list.forEach(System.out::println); // zamiast używać referencji do metody, równie dobrze można by to zrobić po "staremu" w pętli for

Domyślne i statyczne metody w interfejsach

MetaSpace (brak PERM)

Klasy LocalDate, LocalTime i LocalDateTime mają prywatne konstruktory a ich instancję tworzymy przez statyczną metodę of.

Ponadto używamy w tych klasach metod: plus*, minus*, get*, isBefore, isAfter, isEqual.

Klasy Period (okres - dla Date) i Duration (czas trwania - dla Time) mają prywatne konstruktory a ich instancję tworzymy poprzez of*.