Java Training Block 4 – Tag 2 – Lambda + Streaming

Ich nehme derzeit an einer Akademie zum Java Fullstack Software Engineer teil. In den kommenden Wochen möchte ich hier meine Mitschrift, so gut es geht, aufzeichnen und mitteilen. Hier ist das, was ich vom zweiten Tag in Block 4 gelernt und behalten habe:

Java Lambda

Unterschied zwischen Funktionen und Methoden

Folgendes zeichnet ganz allgemein Funktionen und Methoden aus:

Code Kapselung mehrerer Anweisung
Wiederverwendbarkeit
Ergebnisse
Berechnungen
Doing
Ausgaben

Funktionen können frei definiert werden.
Methoden können nicht frei definiert werden. Sie hängen an Objekten bzw. Klassen.

Methode bzw. Funktion haben einen Namen:

name(parameter) {
Anweisung
Anweisung
Anweisung
summe = parameter + 1
}

Bei Java gibt es aber auch unbenamte, bzw. anonyme Methoden. Sie werden nur einmal in einem bestimmten Kontext verwendet. Es werden also nur Parameter an einen funktionalen Block übergeben. Man nennt sie “Lambda”-Methoden.

Lambdas sind Einwegspritzen.

(parameter) {
Anweisung
Anweisung
Anweisung
summe = parameter + 1
}

In Java sieht das Ganze dann z.B. so aus:

(key, value) -> {
System.out.println(“Key : ” + key);
System.out.println(” Value : ” + value);
}

Weiteres Beispiel: Prop.forEach ist eine Schleife, die für jedes Element der Objektliste Prob eine Funktion (Executable) ausführt. Hier ein paar mögliche Schreibweisen dafür:

Vorteil von Lambda gegenüber einer Schleife: Ein Lambda ist executable. Man kann ihm Parameter von außen übergeben. (Biontec (Value) benutzt eine Einwegspritze(Lambda))

Begriffe:

MathOperation ist ein Interface
addition ist der Name des Objektes
Int a, int b sind die Übergabeparameter
a+b ist die Aktion
Executable ist beides: der Parameterteil und der Aktionsteil

Weitere Literatur zu Java Lambda λ:

Beispiele zu Lamda:

Beispiel 1:

Normalerweise kommt bei einem Interface hinter dem Befehl mit dem new ein Semikolon.
Hier überschreiben wir aber das Interface. Daher öffnen wir eine gechweifte Klammer und fügen dort etwas Code ein:

Beispiel 2:

d2 ist ein Objekt vom Typ Drawable, welches ein Interface ist. Es wird kein Parameter übergeben (weil es keinen gibt und weil dies auch nicht definiert ist).
Mit d2.draw wird die Methode draw aus dem Interface aufgerufen.

Beispiel 4:
Links vom Lambda-Pfeil stehen die Parameter und rechts davon in geschweiften Klammern die Aktionen:

Beispiel von gestern:
Hier kann man sehen, wie eine Schreibweise mit und ohne Lambda aussehen:

Beispiel addierbar:

ForEach Beispiel:

Message Beispiel:

Beispiel Multithreading:

Kleiner Exkurs: Wenn ich hier das main Program starte, erzeuge ich drei Threads (main und t1 und t2):

Darstellung der Threads mit VisualVM:

Beispiel sorting eines beliebigen Parameters in einer Arraylist von Objekten:

    public static void main(String[] args) {
        List<Product> list=new ArrayList<Product>();
        //Adding Products
        list.add(new Product(1,"HP Laptop",25000f));
        list.add(new Product(3,"Keyboard",300f));
        list.add(new Product(2,"Dell Mouse",150f));
        System.out.println("Sorting on the basis of name...");
        // implementing lambda expression
        Collections.sort(list,(p1, p2)->{
            return p1.getName().compareTo(p2.getName());
        });
        for(Product p:list){
            System.out.println(p.getId()+" "+p.getName()+" "+p.getPrice());
        }

Ergebnis:

Beispiel mit Streams:

Streams

Streams sind so etwas wie Pipelines in Unix.
Man kann Lambda-Ausdrücke miteinander verknüpfen.

Beispiel Liste ohne Stream und mit Stream:
Das “p” ist vom typ “Product”, weil es oben bei der Arraylist so definiert wird.

Streams nutzen von Hause aus Multithreading. Im Gegensatz zur Schleife, die den Mainprocess blockiert, solange sie läuft.

Weiteres Beispiel, wie man auf die Elemente noch die Mehrwertsteuer drauf setzt:

Siehe auch: – https://ertan-toker.de/java-streams-tutorial-and-examples/

Übungen mit Lambdas und Streams

ueb-lambda-stream

Einlesen der “Kurz und Gut”-Bücher in eine Bücherliste
https://4point.de/seminar/telekom-agil-2021-22-e/uebungen/kurz_u_gut.datList<

Ausgabe der Bücherliste via forEach
auf der Liste mit eine lambda-Ausdrucks
- Isbn Titel Autor Preis
Ausgabe der Bücherliste via stream gefiltert nach stream auf der Liste mit gefiltert nach nach Erscheinungsjahr < 2000
- Isbn Titel Autor Jahr Preisauf der Liste mit Titel kommplett GROSS-geschrieben und Autor kommplett kein-geschrieben
Isbn Titel Autor Jahr Preis

*) Ausgabe der Bücherliste via stream
auf der Liste mit sortiert nach Namen
– Isbn Titel Autor Preis

**) Ausgabe der Bücherliste via stream
sortiert nach preis
– Isbn Titel Autor Jahr Preis

package de.firma.view;

import de.firma.model.KUGBuch;

import java.util.Comparator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.stream.Collectors;

public class KUGBuchView {

    public void view(List<KUGBuch> buchlist, Map<String, KUGBuch> buchmap) {
        System.out.println("KuG Buecher As List");
        System.out.println("Anzahl: " + buchlist.size());
        for (KUGBuch kb : buchlist) {
            System.out.printf("%s  %s  %d  %6.2f \n", kb.getIsbn(), kb.getTitel(), kb.getJahr(), kb.getPreis());
        }

        System.out.println("---  Aufgabe 1   -----------------------");

        buchlist.forEach((value) ->
                System.out.printf("%s  %s  %6.2f \n", value.getIsbn(), value.getTitel(), value.getPreis()));

        System.out.println("--------   Aufgabe 2   ------------------");

        List<KUGBuch> blist = buchlist.stream()
                .filter(p -> p.getPreis() < 100.0)
                .filter(y -> y.getJahr() < 2000)
                .collect(Collectors.toList());

        blist.forEach((value) ->
                System.out.printf("%s  %s  %s %d %6.2f \n", value.getIsbn(), value.getTitel(), value.getAutor(), value.getJahr(), value.getPreis()));

        System.out.println("--------   Aufgabe 3   ------------------");

        blist.forEach((value) ->
                System.out.printf("%s  %s  %s %d %6.2f \n", value.getIsbn(), value.getTitel().toUpperCase(Locale.ROOT), value.getAutor().toLowerCase(Locale.ROOT), value.getJahr(), value.getPreis()));

        System.out.println("--------   Aufgabe 3 *   ------------------");

        List<KUGBuch> blist2 = buchlist.stream()
                .sorted((n1,n2) -> n1.getAutor().compareTo(n2.getAutor()))
                .collect(Collectors.toList());
        blist2.forEach((value) ->
                System.out.printf("%s  %s  %s %d %6.2f \n", value.getIsbn(), value.getTitel().toUpperCase(Locale.ROOT), value.getAutor().toLowerCase(Locale.ROOT), value.getJahr(), value.getPreis()));

        System.out.println("--------   Aufgabe 3 **   ------------------");
        double a = Math.max(1,2);
        List<KUGBuch> blist3 = buchlist.stream()
                .sorted(Comparator.comparingDouble(KUGBuch::getPreis))
              // .sorted((n1,n2) -> Double.compare(n1.getPreis(), n2.getPreis()))   Das geht auch
                .collect(Collectors.toList());
        blist3.forEach((value) ->
                System.out.printf("%s  %s  %s %d %6.2f \n", value.getIsbn(), value.getTitel().toUpperCase(Locale.ROOT), value.getAutor().toLowerCase(Locale.ROOT), value.getJahr(), value.getPreis()));

    }
}

——————

Disclaimer

Alles was ich mitschrieb und verstanden habe ist ohne Gewähr.

Besten Dank an unseren

Trainer: Hans-Joachim Blanke blanke@4point.de

In den nächsten Tagen und Wochen geht’s weiter, so: stay tuned!

Gruß, Achim Mertens

About greensniper

Ich bemühe mich die Welt zu verbessern. Mein Beitrag ist nicht groß, aber ich bin ein Legionär - und die bewirken das meiste.

View all posts by greensniper →