Przykład interfejsu w Javie

1. Definiowanie interfejsu:

interface Zwierze {
    void dajGlos(); // Metoda abstrakcyjna (brak implementacji)
}

2. Implementacja interfejsu w klasie:

class Pies implements Zwierze {
    @Override
    public void dajGlos() {
        System.out.println("Hau Hau!");
    }
}

3. Implementacja interfejsu w innej klasie:

class Kot implements Zwierze {
    @Override
    public void dajGlos() {
        System.out.println("Miau Miau!");
    }
}

4. Użycie interfejsu:

public class Main {
    public static void main(String[] args) {
        Zwierze pies = new Pies();
        Zwierze kot = new Kot();

        pies.dajGlos(); // Wywoła "Hau Hau!"
        kot.dajGlos();  // Wywoła "Miau Miau!"
    }
}

Podsumowanie

• Interfejsy definiują kontrakt dla klas.

• Klasa może implementować wiele interfejsów (co nie jest możliwe w przypadku dziedziczenia klas).

• Od Javy 8 interfejsy mogą zawierać metody domyślne i statyczne z implementacją.

• Pozwalają na luźniejsze powiązania między komponentami w programowaniu obiektowym.

Mapy

Mapy to struktury danych opartych na relacji klucz-wartość, w niektórych językach struktura ta jest nazywana słownikiem. Najpopularniejszą implementacją Mapy jak HashMapa oparta na funkcji skrótu mapującej klucz na miejsce w pamięci.

HashMap nie daje żadnej gwarancji wzlędem kolejności elementów na mapie. Oznacza to, że nie możemy przyjąć żadnej kolejności podczas iteracji po kluczach czy wartościach hash mapy:

@Test
public void whenInsertObjectsHashMap_thenRandomOrder() {
        Map<Integer, String> hashmap = new HashMap<>();
        hashmap.put(3, "TreeMap");
        hashmap.put(2, "vs");
        hashmap.put(1, "HashMap");

        assertThat(hashmap.keySet(), containsInAnyOrder(1, 2, 3));
}

Elementy w TreeMap są sortowane zgodnie z ich naturalną kolejnością.

Składnia

Wyrażenie lambda składa się z:

• Listy parametrów w nawiasach (param1, param2, ...)

• Strzałki ->, oddzielającej parametry od ciała wyrażenia

• Ciała wyrażenia, które może być pojedynczą instrukcją lub blokiem kodu

Przykład

@FunctionalInterface
interface Kalkulator {
    int operacja(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        Kalkulator dodawanie = (a, b) -> a + b;
        System.out.println("Wynik: " + dodawanie.operacja(5, 3)); // Wynik: 8
    }
}

Zastosowanie

• Programowanie funkcyjne

• Przetwarzanie kolekcji z Stream API

• Obsługa zdarzeń w GUI

• Współpraca z interfejsami funkcyjnymi w Javie (np. Runnable, Comparator)

Podsumowanie

• Lambda expressions upraszczają kod i eliminują potrzebę stosowania klas anonimowych.

• Można je stosować tylko w interfejsach funkcyjnych (z jedną metodą abstrakcyjną).

• Znacząco poprawiają czytelność i zwięzłość kodu.

Function

Function to specjalny interfejs w javie do definiowania funkcji. Posiada on trzy główne metody.

Wyróżniamy trzy rodzaje funkcji : Function (która przyjmuje i zwraca argumenty), Consumer (która przyjmuje arumenty, ale nic nie zwraca) oraz Producer (który produkuje dane, ale nie pobiera argumentów).

Function<Integer, Double> half = a -> a / 2.0;
  // apply the function to get the result
System.out.println(half.apply(10));

Function<Integer, Double> half = a -> a / 2.0;
// Now treble the output of half function
half = half.andThen(a -> 3 * a);
// apply the function to get the result
System.out.println(half.apply(10));

Function<Integer, Double> half = a -> a / 2.0;
// Now treble the output of halffunction
half = half.andThen(Function.identity());
// apply the function to get the result
System.out.println(half.apply(2));

Rodzaje referencji do metod

1. Referencja do metody statycznej

class Utils {
    static int kwadrat(int x) {
        return x * x;
    }
}

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> funkcja = Utils::kwadrat;
        System.out.println(funkcja.apply(5)); // Wynik: 25
    }
}

2. Referencja do metody instancyjnej

class Printer {
    void drukuj(String tekst) {
        System.out.println(tekst);
    }
}

public class Main {
    public static void main(String[] args) {
        Printer printer = new Printer();
        Consumer<String> funkcja = printer::drukuj;
        funkcja.accept("Witaj, świecie!"); // Witaj, świecie!
    }
}

3. Referencja do konstruktora

class Osoba {
    String imie;
    Osoba(String imie) {
        this.imie = imie;
    }
}

public class Main {
    public static void main(String[] args) {
        Function<String, Osoba> konstruktor = Osoba::new;
        Osoba osoba = konstruktor.apply("Jan");
        System.out.println(osoba.imie); // Jan
    }
}

Podsumowanie

• Operator :: jest skrótem dla wyrażeń lambda, gdy wywołujemy istniejące metody.

• Może być używany do odwoływania się do metod statycznych, metod instancyjnych i konstruktorów.

• Ułatwia kodowanie, sprawiając, że wyrażenia są bardziej czytelne i zwięzłe.

Operacje na strumieniach

Operacja na strumieniach dzielimy na pośrednie i końcowe (terminalne). Operacje pośrednie zwracają jako wynik działania strumień (czyli są elementem wywołań łańcuchowych). W powyższym przykładzie takimi operacjami są map i filter. Operacje terminalne kończą przetwarzanie, zwykle agregują one wyniki, zliczają wartości, albo też nic nie wykonują (np. operacja foreach może być terminalna). Powyżej przykładem takiej operacji jest collect.

Dla operacji numerycznych stworzono specjalne strumienie IntStream, DoubleStream, and LongStream.

IntStream.rangeClosed(1, 10).forEach(num -> System.out.print(num));
// ->12345678910
IntStream.range(1, 10).forEach(num -> System.out.print(num));
// ->123456789

Budowa strumieni

Stream stałych i elementów tablicy i wykorzystanie funkcji forEach do przejścia przez strumień.

Stream.of("This", "is", "Java8", "Stream").forEach(System.out::println);

String[] stringArray = new String[]{"Streams", "can", "be", "created", "from", "arrays"};
Arrays.stream(stringArray).forEach(System.out::println);

Filter

Wybiera elementy ze strumienia względem danego warunku

students.stream()
                .filter(student -> student.getScore() >= 60)
                .collect(Collectors.toList());

Map

Zmienia przetwarzany element na coś innego, czyli pobiera element jednego typu i zwraca element innego typu. W praktyce najczęściej służy do wyciągnięcia jakiś atrybutów z obiektów.

students.stream()
        .map(Student::getName)
        .collect(Collectors.toList());

The Student::getName jest tzw. method reference, skrótowym odwołaniem się do metody z klasy. Czyli na obiekcie typu Student, który przyjdzie ze streama wywołujemy metodę getName(), zadziała tylko z obiektem odpowiedniego typu.

Równoważnie możemy zapisać taki strumień jako:

students.stream()
        .map(student -> student.getName())
        .collect(Collectors.toList());

Distinct

Usuwa powtórzenia

students.stream()
                .map(Student::getName)
                .distinct()
                .collect(Collectors.toList());

Limit

Ogranicza liczbę elementów w strumieniu do podanej liczby.

Sorted

Sortuje elementy w naturalnym dla nich porządku.

students.stream()
                .map(Student::getName)
                .sorted()
                .collect(Collectors.toList());

Z pomocą klasy Comparator możemy definiować sortowania różnego typu

//Sorting names if the Students in descending order
students.stream()
                .map(Student::getName)
                .sorted(Comparator.reverseOrder())
                .collect(Collectors.toList());
//Sorting students by First Name and Last Name both
students.stream()
                .sorted(Comparator.comparing(Student::getFirstName).
                                thenComparing(Student::getLastName))
                .map(Student::getName)
                .collect(Collectors.toList());
//Sorting students by First Name Descending and Last Name Ascending
students.stream()
                .sorted(Comparator.comparing(Student::getFirstName)
                                .reversed()
                                .thenComparing(Student::getLastName))
                .map(Student::getName)
                .collect(Collectors.toList());

FlatMap

Działa podobnie jak mapa, tylko jako wynik zwraca strumień przetworzonych elementów.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
List<List<Integer>> mapped =
                                numbers.stream()
                                .map(number -> Arrays.asList(number -1, number, number +1))
                                .collect(Collectors.toList());

System.out.println(mapped); //:> [[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5]]

List<Integer> flattened =
                                numbers.stream()
                                .flatMap(number -> Arrays.asList(number -1, number, number +1).stream())
                                .collect(Collectors.toList());

System.out.println(flattened);  //:> [0, 1, 2, 1, 2, 3, 2, 3, 4, 3, 4, 5]

Collect

Zbiera elementy strumienia w listę.

students.stream()
                .filter(student -> student.getScore() >= 60)
                .collect(Collectors.toList());

Ważne: Collect zwraca nowy obiekt! Nową listę, mapę, zbiór etc. ale wartości są te same co w przetwarzanej kolekcji.

grupowanie i partycjonowanie

Map<Long, List<Student>> studentsByYear = students.stream()
                        .collect(groupingBy(Student::getYear));

Map<Boolean, List<Student>> groups =
        students.stream().collect(Collectors.partitioningBy(s -> s.getName().startsWith("A")));

Match

Match stosujemy gdy interesuje nas występowanie w strumieniu elementu o danych własnościach.

//Check if at least one student has got distinction
Boolean hasStudentWithDistinction = students.stream()
                .anyMatch(student -> student.getScore() > 80);

//Check if All of the students have distinction
Boolean hasAllStudentsWithDistinction = students.stream()
                .allMatch(student -> student.getScore() > 80);

//Return true if None of the students are over distinction
Boolean hasAllStudentsBelowDistinction = students.stream()
                .noneMatch(student -> student.getScore() > 80);

Find

Pozwala znajdować obiekt w strumieniu o danych włanościach, możemy wybrać dowolny dopasowany obiekt lub pierwszy dopasowany.

//Returns any student that matches to the given condition
students.stream().filter(student -> student.getAge() > 20)
                        .findAny();
//Returns first student that matches to the given condition
students.stream().filter(student -> student.getAge() > 20)
                        .findFirst();

Reduce

Pozwala zredukować strumień danych do pojedynczej wartości.

//Summing without passing an identity
Optional<integer> sum = numbers.stream()
                .reduce((x, y) -> x + y);
//Product without passing an identity
Optional<integer> product = numbers.stream()
                .reduce((x, y) -> x * y);

ForEach

Wykonanie operacji dla każdego elementu z listy.

students.stream()
                .filter(student -> student.getScore() >= 60)
                .foreach(student -> {
                        System.out.println("Brawo");
                        student.assignGradeInUsos(5);
                });

RemoveIf

Usuwanie (w miejscu!) elementów z kolekcji spełniających zadany warunek.

students.removeIf(student -> student.getScore() >= 60)

Task 8: Streams przykłady

Przejrzyj przykłady wykorzystania strumieni z klasy StreamExamples.

Zaimplementuj korzystając ze strumieni brakujące metody w klasie Tasks. Sprawdź uruchamiając TasksTest czy dobrze wykonałeś zadanie.