Tutorium Fallstudien

Tutorium 24.06¶

Lambda¶

Ein Lambda ist in Java eine kurze Schreibweise für die Implementierung genau einer abstrakten Methode eines funktionalen Interfaces.

Eigenes funktionales Interface mit Lambda¶

@FunctionalInterface
public interface Funktion2p {
    double rechne(double x, double y);
}

Funktion2p f = (a, b) -> a + b;

Wichtige funktionale Interfaces aus Java¶
Interface	Bedeutung	Methode	Beispiel
`Function<T, R>`	Eingabe `T`, Ausgabe `R`	`apply`	`text -> text.length()`
`Predicate<T>`	Eingabe `T`, Ausgabe `boolean`	`test`	`text -> text.isEmpty()`
`Consumer<T>`	Eingabe `T`, keine Ausgabe	`accept`	`text -> System.out.println(text)`
`Supplier<T>`	keine Eingabe, Ausgabe `T`	`get`	`() -> Math.random()`
`BiFunction<T, U, R>`	zwei Eingaben, eine Ausgabe	`apply`	`(a, b) -> a + b`
`UnaryOperator<T>`	Eingabe und Ausgabe gleicher Typ	`apply`	`x -> x * x`
`BinaryOperator<T>`	zwei Eingaben gleicher Typ, Ausgabe gleicher Typ	`apply`	`(a, b) -> a + b`

Frage 1¶

Was ist ein Lambda-Ausdruck in Java in einem Satz?

Frage 2¶

Warum kann Java mit diesem Ausdruck allein noch nichts anfangen?

(a, b) -> a + b

Frage 3¶

Warum funktioniert diese Zuweisung nicht?

var f = (a, b) -> a + b;

Frage 4¶

Warum funktioniert diese Zuweisung?

Funktion2p f = (a, b) -> a + b;

Gegeben sei:

@FunctionalInterface
public interface Funktion2p {
    double rechne(double x, double y);
}

Frage 5¶

Was bedeutet @FunctionalInterface?

@FunctionalInterface
public interface Funktion1p {
    double rechne(double x);
}

Frage 6¶

Ist folgendes Interface für ein Lambda geeignet? Begründe kurz.

public interface Rechner {
    double addiere(double a, double b);
    double multipliziere(double a, double b);
}

Frage 7¶

Ist folgendes Interface für ein Lambda geeignet? Begründe kurz.

public interface Aktion {
    void ausfuehren();

    default void beschreibungAusgeben() {
        System.out.println("Eine Aktion wird ausgefuehrt.");
    }
}

Frage 8¶

Was steht bei einem Lambda links vom Pfeil und was rechts vom Pfeil?

x -> x * x

Frage 9¶

Sind diese beiden Lambdas gleichwertig?

x -> x * x

(x) -> x * x

Frage 10¶

Warum braucht dieses Lambda kein return?

x -> x * x

Warum braucht dieses Lambda ein return?

x -> {
    System.out.println(x);
    return x * x;
}

Frage 11¶

Welches funktionale Interface aus Java passt zu dieser Idee?

text -> text.length()

Also: Ein String wird in einen Integer umgewandelt.

Frage 12¶

Welches funktionale Interface aus Java passt zu dieser Idee?

text -> text.length() > 10

Also: Ein String wird auf true oder false geprüft.

Frage 13¶

Welches funktionale Interface aus Java passt zu dieser Idee?

text -> System.out.println(text)

Also: Ein String wird verarbeitet, aber es wird kein Wert zurückgegeben.

Frage 14¶

Welches funktionale Interface aus Java passt zu dieser Idee?

() -> Math.random()

Also: Es gibt keine Eingabe, aber es wird ein Wert erzeugt.

Frage 15¶

Welches funktionale Interface aus Java passt zu dieser Idee?

(a, b) -> a + b

Also: Zwei Werte werden zu einem Ergebnis verarbeitet.

Frage 16¶

Was gibt dieser Code aus?

Predicate<String> istLang = text -> text.length() > 5;

System.out.println(istLang.test("Hallo"));
System.out.println(istLang.test("Programmieren"));

Frage 17¶

Was gibt dieser Code aus?

Function<String, Integer> laenge = text -> text.length();

int ergebnis = laenge.apply("Java");
System.out.println(ergebnis);

Frage 18¶

Ersetze die anonyme Klasse durch ein Lambda.

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Programm laeuft");
    }
};

r.run();

Frage 19¶

Ersetze die anonyme Klasse durch ein Lambda.

Comparator<String> nachLaenge = new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
};

Frage 20¶

Wann ist ein Lambda sinnvoll und wann eher nicht? Nenne jeweils ein Beispiel.

Collections¶

Collections sind Datenstrukturen, mit denen mehrere Werte gespeichert und verarbeitet werden können.

Überblick über die wichtigsten Collection-Typen¶
Typ	Grundidee	Typische Frage
`List<E>`	geordnete Sammlung, Duplikate erlaubt	In welcher Reihenfolge stehen die Elemente?
`Set<E>`	Sammlung ohne Duplikate	Ist dieses Element enthalten?
`Map<K, V>`	Zuordnung von Schlüssel zu Wert	Welcher Wert gehört zu diesem Schlüssel?
`Queue<E>`	Warteschlange	Wer ist als Nächstes dran?
`Deque<E>`	beidseitige Warteschlange	Vorne oder hinten einfügen/entfernen?

Wichtige Implementierungen¶
Interface	Implementierung	Eigenschaft
`List`	`ArrayList`	Standardliste, schneller Zugriff per Index
`Set`	`HashSet`	keine Duplikate, keine garantierte Reihenfolge
`Set`	`LinkedHashSet`	keine Duplikate, Einfügereihenfolge bleibt erhalten
`Set`	`TreeSet`	keine Duplikate, sortierte Reihenfolge
`Map`	`HashMap`	Standard-Map, schnelle Zuordnung
`Map`	`LinkedHashMap`	Map mit Einfügereihenfolge
`Map`	`TreeMap`	Map mit sortierten Schlüsseln
`Map`	`EnumMap`	sehr effiziente Map, wenn der Schlüssel ein `enum` ist

Frage 1¶

Du willst eine Liste von Namen speichern. Die Reihenfolge soll erhalten bleiben und Namen dürfen mehrfach vorkommen. Welche Collection passt?

Frage 2¶

Du willst speichern, welche Studierenden bei einer Veranstaltung anwesend waren. Jede Person soll nur einmal vorkommen. Welche Collection passt?

Frage 3¶

Du willst zu einer Matrikelnummer den Namen eines Studierenden speichern.

12345 -> "Anna"
67890 -> "Max"

Welche Collection passt?

Frage 4¶

Was ist der wichtigste Unterschied zwischen List und Set?

Frage 5¶

Was ist der wichtigste Unterschied zwischen Set und Map?

Frage 6¶

Was gibt dieser Code aus?

List<String> namen = new ArrayList<>();

namen.add("Anna");
namen.add("Max");
namen.add("Anna");

System.out.println(namen);

Frage 7¶

Was gibt dieser Code ungefähr aus? Warum steht "Anna" nicht zweimal darin?

Set<String> namen = new HashSet<>();

namen.add("Anna");
namen.add("Max");
namen.add("Anna");

System.out.println(namen);

Frage 8¶

Warum sollte man sich bei einem HashSet nicht auf die Reihenfolge der Ausgabe verlassen?

Frage 9¶

Welche Collection passt, wenn jedes Element nur einmal vorkommen soll, aber die Einfügereihenfolge erhalten bleiben soll?

Frage 10¶

Welche Collection passt, wenn jedes Element nur einmal vorkommen soll und automatisch sortiert werden soll?

Frage 11¶

Was gibt dieser Code aus? Warum?

Map<String, Integer> alter = new HashMap<>();

alter.put("Anna", 22);
alter.put("Max", 25);
alter.put("Anna", 23);

System.out.println(alter.get("Anna"));

Frage 12¶

Was ist der Unterschied zwischen diesen beiden Operationen?

namen.add("Anna");

alter.put("Anna", 22);

Frage 13¶

Was passiert, wenn man bei einer Map einen Wert mit einem bereits vorhandenen Schlüssel einfügt?

Map<String, String> emails = new HashMap<>();

emails.put("anna", "anna@example.com");
emails.put("anna", "anna.neu@example.com");

System.out.println(emails);

Frage 14¶

Welche Collection würdest du verwenden, um zu zählen, wie oft jeder Name vorkommt? Begründe kurz.

List<String> namen = List.of(
        "Anna", "Max", "Anna", "Lena", "Max", "Anna"
);

Erwartetes Ergebnis:

Anna -> 3
Max  -> 2
Lena -> 1

Frage 15¶

Ergänze den Code, sodass die Namen gezählt werden.

List<String> namen = List.of(
        "Anna", "Max", "Anna", "Lena", "Max", "Anna"
);

Map<String, Integer> counts = new HashMap<>();

for (String name : namen) {
    // Was fehlt hier?
}

System.out.println(counts);

Frage 16¶

Was macht getOrDefault in diesem Beispiel?

counts.put(name, counts.getOrDefault(name, 0) + 1);

Frage 17¶

Was gibt dieser Code aus?

List<String> namen = List.of("Anna", "Max", "Lena");

System.out.println(namen.contains("Max"));
System.out.println(namen.contains("Tom"));

Frage 18¶

Warum ist ein Set oft besser geeignet als eine List, wenn man sehr oft prüfen möchte, ob ein Element enthalten ist?

Frage 19¶

Entferne Duplikate aus einer Liste, aber behalte die ursprüngliche Reihenfolge.

List<String> namen = List.of(
        "Anna", "Max", "Anna", "Lena", "Max"
);

Erwartetes Ergebnis:

[Anna, Max, Lena]

Welche Collection hilft?

Frage 20¶

Gruppiere Studierende nach Kurs. Gesucht ist eine Struktur wie:

Programmieren -> [Anna, Max]
Datenbanken   -> [Lena, Max]

Welche Collection-Kombination passt?

Frage 21¶

Welche Collection passt für eine Warteschlange, zum Beispiel bei Druckaufträgen?

Frage 22¶

Welche Collection passt, wenn man Elemente vorne und hinten einfügen oder entfernen will?

Frage 23¶

Was ist an diesem Code problematisch?

Map<String, Integer> lager = new HashMap<>();

lager.put("Apfel", 30);
lager.put("Banane", 12);

System.out.println(lager.get("Milch") + 1);

Frage 24¶

Wie kann man das Problem aus Frage 23 mit getOrDefault lösen?

Frage 25¶

Was ist der Unterschied zwischen keySet, values und entrySet bei einer Map?

Frage 26¶

Welche Schleife ist meistens besser, wenn man sowohl Schlüssel als auch Wert einer Map braucht?

Variante A:

for (String key : map.keySet()) {
    System.out.println(key + ": " + map.get(key));
}

Variante B:

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

Frage 27¶

Sortiere Namen alphabetisch und entferne gleichzeitig Duplikate.

List<String> namen = List.of(
        "Max", "Anna", "Lena", "Anna", "Tom"
);

Erwartetes Ergebnis:

[Anna, Lena, Max, Tom]

Welche Collection passt?

Frage 28¶

Warum sollte man meistens gegen das Interface programmieren?

List<String> namen = new ArrayList<>();

statt:

ArrayList<String> namen = new ArrayList<>();

Mini-Aufgabe¶

Ein kleines Programm soll Bestellungen auswerten.

List<String> bestellungen = List.of(
        "Apfel", "Banane", "Apfel", "Milch", "Banane", "Apfel"
);

Bearbeite folgende Teilaufgaben:

Speichere alle bestellten Produkte in der ursprünglichen Reihenfolge.
Ermittle alle unterschiedlichen Produkte (Reihenfolge egal).
Ermittle alle unterschiedlichen Produkte in der Reihenfolge ihres ersten Auftretens.
Ermittle, wie oft jedes Produkt bestellt wurde.
Gib alle Produkte mit ihrer Anzahl aus.

Streams¶

Ein Stream in Java ermöglicht es, eine Folge von Elementen deklarativ zu verarbeiten. Statt einer Schleife beschreibt man, was mit den Elementen passieren soll, nicht wie.

Einfacher Stream¶

List<String> namen = List.of("Anna", "Max", "Lena", "Tom");

List<String> ergebnis = namen.stream()
        .filter(n -> n.length() > 3)
        .sorted()
        .collect(Collectors.toList());

System.out.println(ergebnis); // [Anna, Lena]

Wichtige Stream-Operationen¶
Operation	Beschreibung	Beispiel
`.filter`	Nur Elemente durchlassen, die eine Bedingung erfüllen	`.filter(n -> n.length() > 3)`
`.map`	Jedes Element in etwas anderes umwandeln	`.map(String::toUpperCase)`
`.sorted`	Elemente sortieren (natürlich oder mit Comparator)	`.sorted()` / `.sorted((a, b) -> ...)`
`.collect`	Ergebnis zusammenfassen, z. B. in eine Liste	`.collect(Collectors.toList())`
`.forEach`	Jedes Element verarbeiten (kein Rückgabewert)	`.forEach(System.out::println)`
`.count`	Anzahl der verbleibenden Elemente zählen	`.count()`
`.distinct`	Duplikate entfernen	`.distinct()`
`.limit`	Nur die ersten N Elemente weitergeben	`.limit(3)`
`.noneMatch`	`true`, wenn kein Element die Bedingung erfüllt	`.noneMatch(n -> n < 0)`

Frage 1¶

Was gibt dieses Programm aus?

import java.util.*;

public class Pipeline1 {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("bb", "ZZ", "aa", "PP", "zz");

        strings
            .stream()
            .sorted()
            .map(String::toUpperCase)
            .forEach(n -> System.out.print(n + " "));
    }
}

Lösung anzeigen

Ausgabe¶

PP ZZ AA BB ZZ

sorted() verwendet die natürliche Reihenfolge von Strings. Großbuchstaben haben niedrigere Unicode-Werte als Kleinbuchstaben (z. B. 'Z' = 90, 'a' = 97). Deshalb kommen "PP" und "ZZ" vor "aa", "bb" und "zz".

Sortiert: ["PP", "ZZ", "aa", "bb", "zz"]

Erst danach wandelt map(String::toUpperCase) alles in Großbuchstaben um. Die Reihenfolge ändert sich dabei nicht mehr.

Original	nach `sorted`	nach `toUpperCase`
`"bb"`	`"PP"`	`"PP"`
`"ZZ"`	`"ZZ"`	`"ZZ"`
`"aa"`	`"aa"`	`"AA"`
`"PP"`	`"bb"`	`"BB"`
`"zz"`	`"zz"`	`"ZZ"`

Frage 2¶

Was gibt dieses Programm aus? Erkläre jeden Schritt kurz.

import java.util.*;

public class Pipeline2 {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList(
            "bbb", "ZZZ", "aaa", "PPP",
            "zzz", "fff", "vvv"
        );

        boolean i = strings
            .stream()
            .distinct()
            .sorted((a, b) -> a.compareToIgnoreCase(b))
            .limit(4)
            .map(a -> a.substring(0, 2))
            .noneMatch(a -> a.equals("aa"));

        System.out.println(i);
    }
}

Frage 3¶

Ergänze die zwei fehlenden Stream-Operationen, sodass nur die geraden Zahlen aus der Liste aufsteigend sortiert ausgegeben werden.

Erwartete Ausgabe:

2
4
6

import java.util.*;

public class Pipeline3 {

    public static void main(String[] args) {

        List<Integer> intArray = Arrays.asList(7, 6, 5, 4, 3, 2, 1);

        intArray
            .stream()
            ._____________________________
            ._____________________________
            .forEach(System.out::println);
    }
}

Aufgaben¶

Aufgabe 1: Benachrichtigungssystem¶

Eine Anwendung verwaltet verschiedene Arten von Benachrichtigungen. Jede Benachrichtigung hat einen Empfänger und einen Text. Es gibt unterschiedliche Kanäle, zum Beispiel E-Mail und SMS.

Gegeben ist folgendes Grundgerüst:

Abstrakte Basisklasse¶

public abstract class Nachricht {

    private final String empfaenger;
    private final String text;

    public Nachricht(String empfaenger, String text) {
        this.empfaenger = empfaenger;
        this.text = text;
    }

    public String getEmpfaenger() {
        return empfaenger;
    }

    public String getText() {
        return text;
    }

    public abstract String kanal();

    public abstract int prioritaet();
}

Unterklassen und funktionales Interface¶

public class EmailNachricht extends Nachricht {
    public EmailNachricht(String empfaenger, String text) {
        super(empfaenger, text);
    }

    @Override
    public String kanal() { return "E-Mail"; }

    @Override
    public int prioritaet() { return 1; }
}

public class SmsNachricht extends Nachricht {
    public SmsNachricht(String empfaenger, String text) {
        super(empfaenger, text);
    }

    @Override
    public String kanal() { return "SMS"; }

    @Override
    public int prioritaet() { return 2; }
}

@FunctionalInterface
public interface NachrichtenFormat {
    String formatiere(Nachricht n);
}

In der main-Methode existiert folgende Liste:

Ausgangsdaten¶

List<Nachricht> nachrichten = new ArrayList<>();

nachrichten.add(new EmailNachricht("anna@example.com", "Termin morgen"));
nachrichten.add(new SmsNachricht("Max", "Bitte zurueckrufen"));
nachrichten.add(new EmailNachricht("lena@example.com", "Unterlagen erhalten"));
nachrichten.add(new SmsNachricht("Anna", "Raum wurde geaendert"));

Aufgaben:

Erkläre, warum folgender Code bei SMS-Nachrichten "SMS" und bei E-Mail-Nachrichten "E-Mail" ausgibt, obwohl die Liste den Typ List<Nachricht> hat.
```
1for (Nachricht n : nachrichten) {
2    System.out.println(n.kanal());
3}
```
Erstelle ein Lambda vom Typ NachrichtenFormat, das eine Nachricht in folgender Form formatiert:
```
KANAL an EMPFAENGER: TEXT
```
Beispiel: SMS an Max: Bitte zurueckrufen
Wende das Lambda auf alle Nachrichten an und gib das Ergebnis aus.
Sortiere die Liste so, dass Nachrichten mit höherer Priorität zuerst kommen (SmsNachricht.prioritaet() == 2, EmailNachricht.prioritaet() == 1).
Erstelle eine Collection, die alle Empfänger enthält, aber jeden Empfänger nur einmal. Die Reihenfolge des ersten Auftretens soll erhalten bleiben.
Erstelle eine Map, die zählt, wie viele Nachrichten pro Kanal vorhanden sind. Erwartete Idee: {SMS=2, E-Mail=2}
Beantworte kurz:
- Warum wird für nachrichten eine List verwendet?
- Warum ist für eindeutige Empfänger ein Set sinnvoll?
- Warum braucht das Lambda aus Teilaufgabe 2 ein Interface?
- Warum wäre var format = n -> n.kanal(); nicht erlaubt?

Aufgabe 2: Shop-Auswertung¶

Ein kleiner Shop verwaltet Produkte. Produkte haben einen Namen, eine Kategorie und einen Preis. Es gibt verschiedene Produktarten.

Gegeben ist folgendes Grundgerüst:

Enum, abstrakte Klasse und Unterklassen¶

public enum Kategorie {
    BUCH,
    LEBENSMITTEL,
    TECHNIK
}

public abstract class Produkt {

    private final String name;
    private final Kategorie kategorie;

    public Produkt(String name, Kategorie kategorie) {
        this.name = name;
        this.kategorie = kategorie;
    }

    public String getName() { return name; }
    public Kategorie getKategorie() { return kategorie; }

    public abstract double preis();
}

public class Buch extends Produkt {
    private final double preis;

    public Buch(String name, double preis) {
        super(name, Kategorie.BUCH);
        this.preis = preis;
    }

    @Override
    public double preis() { return preis; }
}

public class Lebensmittel extends Produkt {
    private final double preis;

    public Lebensmittel(String name, double preis) {
        super(name, Kategorie.LEBENSMITTEL);
        this.preis = preis;
    }

    @Override
    public double preis() { return preis; }
}

@FunctionalInterface
public interface RabattRegel {
    double berechne(Produkt p);
}

Der folgende Code soll Produkte auswerten. Er enthält aber mehrere Fehler:

Fehlerhafter Code¶

List<Produkt> warenkorb = List.of(
        new Buch("Java Basics", 30.0),
        new Lebensmittel("Apfel", 1.0),
        new Buch("Java Basics", 30.0)
);

RabattRegel regel = p -> {
    if (p.preis() > 20) {
        p.preis() * 0.9;
    }

    p.preis();
};

Map<Kategorie, Double> summen = new EnumMap<>();

for (Produkt p : warenkorb) {
    summen.put(
            p.getKategorie(),
            summen.get(p.getKategorie()) + regel.berechne(p)
    );
}

Set<Produkt> eindeutigeProdukte = new HashSet<>(warenkorb);

System.out.println(eindeutigeProdukte.size());

Aufgaben:

Finde mindestens vier Probleme im Code und erkläre jeweils kurz, warum sie problematisch sind.
Korrigiere die Rabattregel. Produkte über 20 Euro erhalten 10 % Rabatt, alle anderen behalten ihren normalen Preis.
Korrigiere die Erstellung der EnumMap.
Berechne die Summe der (rabattierten) Preise pro Kategorie korrekt. Erwartete Idee: {BUCH=54.0, LEBENSMITTEL=1.0}
Erkläre, warum die beiden Bücher mit dem Namen "Java Basics" durch new HashSet<>(warenkorb) nicht automatisch als Duplikate erkannt werden. Nenne eine einfache Alternative, wenn nur eindeutige Produktnamen gesucht sind.
Beantworte kurz:
- Warum ist Produkt eine abstrakte Klasse?
- Warum ist RabattRegel ein Interface und keine Klasse?
- Warum passt EnumMap gut zu Kategorie?
- Warum ist für einen Warenkorb eine List sinnvoller als ein Set?

Lösung anzeigen

Lösung 1 – Fehler finden

Problem 1: Lambda-Block ohne ``return``

Der Lambda-Körper verwendet geschweifte Klammern, aber es fehlen die return-Anweisungen. Die Zeilen p.preis() * 0.9; und p.preis(); sind nur Ausdrücke, deren Ergebnis verworfen wird.

Problem 2: ``EnumMap`` braucht die Enum-Klasse

new EnumMap<>() funktioniert nicht. Eine EnumMap braucht beim Erzeugen die Klasse des Enums: new EnumMap<>(Kategorie.class).

Problem 3: ``summen.get(…)`` kann ``null`` liefern

Wenn für eine Kategorie noch kein Wert gespeichert wurde, liefert get den Wert null. Dann entsteht sinngemäß null + 27.0, was zu einer NullPointerException führt.

Problem 4: ``HashSet<Produkt>`` erkennt fachliche Duplikate nicht automatisch

Ohne überschriebene equals- und hashCode-Methoden sind zwei new Buch("Java Basics", 30.0)-Objekte für Java verschiedene Objekte, auch wenn Name und Preis identisch sind.

Lösung 2 – Lambda korrigieren

RabattRegel regel = p -> {
    if (p.preis() > 20) {
        return p.preis() * 0.9;
    }

    return p.preis();
};

Kürzer mit dem ternären Operator:

RabattRegel regel = p -> p.preis() > 20 ? p.preis() * 0.9 : p.preis();

Lösung 3 – ``EnumMap`` korrekt erstellen

Map<Kategorie, Double> summen = new EnumMap<>(Kategorie.class);

Die Angabe Kategorie.class sagt der EnumMap, mit welchem Enum sie arbeitet.

Lösung 4 – Summen pro Kategorie berechnen

Map<Kategorie, Double> summen = new EnumMap<>(Kategorie.class);

for (Produkt p : warenkorb) {
    Kategorie kategorie = p.getKategorie();
    double bisher = summen.getOrDefault(kategorie, 0.0);
    summen.put(kategorie, bisher + regel.berechne(p));
}

System.out.println(summen);

Mögliche Ausgabe¶

{BUCH=54.0, LEBENSMITTEL=1.0}

Zwei Bücher à 30 Euro mit je 10 % Rabatt ergeben 2 × 27 = 54 Euro.

Lösung 5 – Eindeutige Produkte

Ohne passende equals- und hashCode-Methoden vergleicht Java Objekte nach Objektidentität. Zwei getrennt erzeugte Buch-Objekte sind daher verschiedene Objekte.

Wenn nur eindeutige Produktnamen gesucht sind, kann man ein Set<String> verwenden:

Set<String> produktNamen = new LinkedHashSet<>();

for (Produkt p : warenkorb) {
    produktNamen.add(p.getName());
}

System.out.println(produktNamen);

Mögliche Ausgabe¶

[Java Basics, Apfel]

Lösung 6 – Verständnisfragen

Produkt ist abstrakt, weil ein allgemeines Produkt nicht direkt instanziiert werden soll. Die konkrete Preisberechnung übernehmen die Unterklassen.
RabattRegel ist ein Interface, damit die Regel flexibel als Lambda übergeben werden kann.
EnumMap passt gut, weil Kategorie ein enum ist und die Menge der möglichen Schlüssel fest definiert ist.
Eine List ist für den Warenkorb sinnvoll, weil gleiche Produkte mehrfach vorkommen dürfen.
Ein Lambda kann nicht ohne Zieltyp verwendet werden, weil Java wissen muss, welches funktionale Interface und welche Methode implementiert wird.

Aufgabe 3: Stream-Verarbeitung von Städten¶

Gegeben ist folgende Liste:

List<String> staedte = List.of(
        "Berlin", "München", "Hamburg", "Köln", "Frankfurt",
        "Stuttgart", "Düsseldorf", "Leipzig", "Bremen", "Hannover"
);

Bearbeite folgende Teilaufgaben mit Java Streams.

Erstelle eine Liste aller Städte, deren Name mehr als 7 Zeichen hat. Sortiere das Ergebnis alphabetisch.
Erstelle eine Liste aller Städtenamen in Großbuchstaben, aber nur für Städte, die mit "H" beginnen.
Zähle, wie viele Städte einen Namen mit genau 6 Zeichen haben.
Erstelle eine Liste der Längen aller Städtenamen, sortiert aufsteigend. (Nicht die Namen, sondern die Längen als Integer-Liste.)

Erkläre, warum Variante A schneller ist als Variante B, obwohl beide dasselbe Ergebnis liefern:

// Variante A – erst filtern, dann sortieren
staedte.stream()
       .filter(s -> s.length() > 7)
       .sorted()
       .collect(Collectors.toList());

// Variante B – erst sortieren, dann filtern
staedte.stream()
       .sorted()
       .filter(s -> s.length() > 7)
       .collect(Collectors.toList());

Aufgabe 4: Produkt-Stream mit Fehlersuche¶

Verwendet wird dieselbe Klassenhierarchie wie in Aufgabe 2. Gegeben sind diese Produkte:

Ausgangsdaten¶

List<Produkt> produkte = new ArrayList<>(List.of(
        new Buch("Java Basics", 29.99),
        new Lebensmittel("Apfel", 1.49),
        new Buch("Clean Code", 34.99),
        new Lebensmittel("Brot", 2.89),
        new Buch("Design Patterns", 44.99),
        new Lebensmittel("Milch", 1.19),
        new Buch("Refactoring", 39.99)
));

Aufgaben:

Erstelle mit einem Stream eine Liste aller Produktnamen, deren Preis unter 5,00 Euro liegt. Sortiere die Namen alphabetisch.
Erstelle mit einem Stream eine Liste aller Buchpreise (nur Bücher), sortiert aufsteigend.

Folgender Code soll alle Produkte mit einem Preis ≥ 30 Euro, aufsteigend nach Preis sortiert, in eine Namensliste sammeln. Er kompiliert nicht und ist außerdem langsamer als nötig. Finde beide Probleme und erkläre sie:

List<String> teuer = produkte.stream()
        .sorted((a, b) -> a.preis() - b.preis())
        .filter(p -> p.preis() >= 30.0)
        .map(p -> p.getName())
        .collect(Collectors.toList());

Erstelle eine Map, die jedem Kategorienamen (als String) die Anzahl der Produkte in dieser Kategorie zuordnet. Verwende Collectors.groupingBy und Collectors.counting.

Erwartete Ausgabe:
```
{BUCH=4, LEBENSMITTEL=3}
```