Java 8: Revolution der Code-Schreibweise – 50 essentielle Lambda- und Stream-Snippets

Julian | Jul 24, 2025 min read
Java 8: Revolution der Code-Schreibweise – 50 essentielle Lambda- und Stream-Snippets

Hallo zusammen,

Java 8 hat die Art und Weise, wie wir Code schreiben, von Grund auf verändert. Die Einführung von Lambda-Ausdrücken und der Stream API brachte einen deutlich funktionaleren Programmierstil in Java, der es uns Entwicklern ermöglicht, saubereren, prägnanteren und wesentlich besser lesbaren Code zu schreiben.

In diesem Beitrag habe ich 50 essenzielle Snippets zu Lambda-Ausdrücken zusammengestellt. Sie demonstrieren den praktischen Einsatz – von grundlegenden Operationen bis hin zur fortgeschrittenen Stream-Verarbeitung. Egal, ob ihr gerade an Enterprise-Grade-Code arbeitet oder euch auf ein Tech-Interview vorbereitet, diese Beispiele werden euer Verständnis schärfen und eure Produktivität steigern.

Lasst uns direkt eintauchen!

Die Snippets: Lambda-Ausdrücke und Streams in Aktion

  1. Einfaches Runnable-Beispiel

    Runnable meinRunnable = () -> System.out.println("Hallo, Lambda!");
new Thread(meinRunnable).start();

  2. Liste mit Lambda durchlaufen

    List<String> technologien = Arrays.asList("Java", "Spring", "Lambda");
technologien.forEach(element -> System.out.println(element));

  3. Liste mit Lambda filtern

    List<String> programmiersprachen = Arrays.asList("Java", "JavaScript", "Python");
List<String> gefilterteListe = programmiersprachen.stream()
    .filter(sprache -> sprache.startsWith("J"))
    .collect(Collectors.toList());
gefilterteListe.forEach(System.out::println);

  4. Liste mit Lambda sortieren

    List<String> themen = Arrays.asList("Java", "Lambda", "Kafka");
themen.sort((thema1, thema2) -> thema1.compareTo(thema2));
themen.forEach(System.out::println);

  5. Benutzerdefiniertes funktionales Interface nutzen

    @FunctionalInterface
interface Rechner {
    int berechne(int zahl1, int zahl2);
}

public static void main(String[] args) {
    Rechner addieren = (zahl1, zahl2) -> zahl1 + zahl2;
    Rechner multiplizieren = (zahl1, zahl2) -> zahl1 * zahl2;
    System.out.println("Addition: " + addieren.berechne(5, 3));
    System.out.println("Multiplikation: " + multiplizieren.berechne(5, 3));
}

  6. Lambda bei Map-Iteration

    Map<String, Integer> versionen = new HashMap<>();
versionen.put("Java", 8);
versionen.put("Spring", 5);
versionen.put("Lambda", 1);
versionen.forEach((schluessel, wert) -> System.out.println(schluessel + ": " + wert));

  7. Thread mit Lambda erstellen

    new Thread(() -> System.out.println("Thread mit Lambda läuft!")).start();

  8. Lambda in Comparator

    List<String> frameworks = Arrays.asList("Java", "Lambda", "Kafka");
frameworks.sort(Comparator.comparingInt(String::length));
frameworks.forEach(System.out::println);

  9. Methodenreferenz mit Lambda

    List<String> tools = Arrays.asList("Java", "Lambda", "Kafka");
tools.forEach(System.out::println);

  10. Lambda mit Optional

    Optional<String> optionalWert = Optional.of("Java");
optionalWert.ifPresent(wert -> System.out.println("Wert ist vorhanden: " + wert));

  11. Lambda mit Predicate

    Predicate<String> istLeer = s -> s.isEmpty();
System.out.println(istLeer.test("")); // true
System.out.println(istLeer.test("Java")); // false

  12. Lambda mit BiFunction

    BiFunction<Integer, Integer, Integer> addierer = (z1, z2) -> z1 + z2;
System.out.println(addierer.apply(2, 3)); // 5

  13. Lambda mit Consumer

    Consumer<String> ausgeber = s -> System.out.println(s);
ausgeber.accept("Hallo, Welt!"); // Hallo, Welt!

  14. Lambda mit Supplier

    Supplier<String> lieferant = () -> "Java";
System.out.println(lieferant.get()); // Java

  15. Lambda mit Stream Sorted

    List<String> fruechte = Arrays.asList("Banane", "Birne", "Traube");
fruechte.stream()
    .sorted()
    .forEach(System.out::println);

  16. Lambda mit Stream Count

    List<Integer> zahlenMenge = Arrays.asList(1, 2, 3, 4, 5);
long anzahl = zahlenMenge.stream()
    .count();
System.out.println("Anzahl: " + anzahl); // Anzahl: 5

  17. Lambda mit Stream AnyMatch

    List<String> suchliste = Arrays.asList("Java", "Spring", "Lambda");
boolean enthaeltJava = suchliste.stream()
    .anyMatch(s -> s.equals("Java"));
System.out.println("Enthält 'Java': " + enthaeltJava); // true

  18. Lambda mit Stream AllMatch

    List<Integer> geradeZahlen = Arrays.asList(2, 4, 6, 8, 10);
boolean alleGerade = geradeZahlen.stream()
    .allMatch(n -> n % 2 == 0);
System.out.println("Alle gerade: " + alleGerade); // true

  19. Lambda mit Stream NoneMatch

    List<String> technologieCheck = Arrays.asList("Java", "Spring", "Lambda");
boolean keinePython = technologieCheck.stream()
    .noneMatch(s -> s.equals("Python"));
System.out.println("Enthält kein 'Python': " + keinePython); // true

  20. Lambda mit Stream FindFirst

    List<String> ersteElemente = Arrays.asList("Java", "Spring", "Lambda");
Optional<String> erster = ersteElemente.stream()
    .findFirst();
erster.ifPresent(System.out::println); // Java

  21. Lambda mit Stream FindAny

    List<String> beliebigeElemente = Arrays.asList("Java", "Spring", "Lambda");
Optional<String> beliebig = beliebigeElemente.stream()
    .findAny();
beliebig.ifPresent(System.out::println);

  22. Lambda zum Summieren von Integer

    List<Integer> zahlenSumme = Arrays.asList(1, 2, 3, 4, 5);
int summe = zahlenSumme.stream()
    .mapToInt(Integer::intValue)
    .sum();
System.out.println("Summe: " + summe); // Summe: 15

  23. Lambda für größten Integer

    List<Integer> zahlenMax = Arrays.asList(1, 2, 3, 4, 5);
int maximum = zahlenMax.stream()
    .mapToInt(Integer::intValue)
    .max()
    .orElse(Integer.MIN_VALUE);
System.out.println("Maximum: " + maximum); // Maximum: 5

  24. Lambda für kleinsten Integer

    List<Integer> zahlenMin = Arrays.asList(1, 2, 3, 4, 5);
int minimum = zahlenMin.stream()
    .mapToInt(Integer::intValue)
    .min()
    .orElse(Integer.MAX_VALUE);
System.out.println("Minimum: " + minimum); // Minimum: 1

  25. Lambda zum Verbinden von Strings

    List<String> woerter = Arrays.asList("Java", "Spring", "Lambda");
String verbunden = woerter.stream()
    .collect(Collectors.joining(", "));
System.out.println(verbunden); // Java, Spring, Lambda

  26. Lambda mit Stream MapToInt

    List<String> namenLaengen = Arrays.asList("Java", "Spring", "Lambda");
namenLaengen.stream()
    .mapToInt(String::length)
    .forEach(System.out::println); // 4, 6, 6

  27. Lambda mit Stream Collect to Set

    List<String> duplikate = Arrays.asList("Java", "Spring", "Lambda", "Spring");
Set<String> eindeutig = duplikate.stream()
    .collect(Collectors.toSet());
eindeutig.forEach(System.out::println); // Java, Spring, Lambda

  28. Lambda mit Stream GroupingBy

    List<String> haeufigkeitListe = Arrays.asList("Java", "Spring", "Lambda", "Java");
Map<String, Long> haeufigkeit = haeufigkeitListe.stream()
    .collect(Collectors.groupingBy(s -> s, Collectors.counting()));
haeufigkeit.forEach((schluessel, zaehler) -> System.out.println(schluessel + ": " + zaehler));
// Java: 2, Spring: 1, Lambda: 1

  29. Lambda mit Stream PartitioningBy

    List<Integer> zahlenPartition = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Map<Boolean, List<Integer>> partitioniert = zahlenPartition.stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));
partitioniert.forEach((istGerade, liste) -> System.out.println(istGerade + ": " + liste));
// true: [2, 4, 6, 8, 10], false: [1, 3, 5, 7, 9]

  30. Lambda mit Stream Counting (Collector)

    List<String> elementeZaehlen = Arrays.asList("Java", "Spring", "Lambda");
long anzahlCollector = elementeZaehlen.stream()
    .collect(Collectors.counting());
System.out.println("Anzahl (Collector): " + anzahlCollector); // Anzahl (Collector): 3

  31. Lambda mit Stream SummarizingInt

    List<Integer> statistikZahlen = Arrays.asList(1, 2, 3, 4, 5);
IntSummaryStatistics statistiken = statistikZahlen.stream()
    .collect(Collectors.summarizingInt(Integer::intValue));
System.out.println("Summe: " + statistiken.getSum());
System.out.println("Durchschnitt: " + statistiken.getAverage());
System.out.println("Maximum: " + statistiken.getMax());
System.out.println("Minimum: " + statistiken.getMin());

  32. Lambda mit Stream Mapping (GroupingBy)

    List<String> laengenNachGruppen = Arrays.asList("Java", "Spring", "Lambda");
Map<Integer, List<String>> nachLaengeGruppiert = laengenNachGruppen.stream()
    .collect(Collectors.groupingBy(String::length));
nachLaengeGruppiert.forEach((laenge, liste) -> System.out.println(laenge + ": " + liste));
// 4: [Java], 6: [Spring, Lambda]

  33. Lambda mit Stream Joining ohne Delimiter

    List<String> ohneTrennung = Arrays.asList("Java", "Spring", "Lambda");
String verbundenOhneDelimiter = ohneTrennung.stream()
    .collect(Collectors.joining());
System.out.println(verbundenOhneDelimiter); // JavaSpringLambda

  34. Lambda mit Stream ToMap

    List<String> listZuMap = Arrays.asList("Java", "Spring", "Lambda");
Map<String, Integer> zugeordnet = listZuMap.stream()
    .collect(Collectors.toMap(s -> s, String::length));
zugeordnet.forEach((schluessel, wert) -> System.Lister.println(schluessel + ": " + wert));
// Java: 4, Spring: 6, Lambda: 6

  35. Lambda zum Erstellen eines Streams

    Stream<String> meinStream = Stream.of("Java", "Spring", "Lambda");
meinStream.forEach(System.out::println);

  36. Lambda mit Stream Limit

    Stream<String> begrenzterStream = Stream.of("Java", "Spring", "Lambda", "Kafka");
begrenzterStream.limit(2)
    .forEach(System.out::println); // Java, Spring

  37. Lambda mit Stream Peek

    Stream<String> peekStream = Stream.of("Java", "Spring", "Lambda", "Kafka");
peekStream.peek(System.out::println)
    .collect(Collectors.toList());

  38. Lambda mit Optional (ifPresent)

    Optional<String> optionalVorhanden = Optional.of("Java");
optionalVorhanden.ifPresent(System.out::println); // Java

  39. Lambda mit Stream Distinct

    List<String> duplikateEntfernen = Arrays.asList("Java", "Spring", "Java", "Lambda");
duplikateEntfernen.stream()
    .distinct()
    .forEach(System.out::println);
// Java, Spring, Lambda

  40. Lambda mit Stream FlatMap

    List<List<String>> listeVonListen = Arrays.asList(
    Arrays.asList("Java", "Spring"),
    Arrays.asList("Lambda", "Kafka")
);
listeVonListen.stream()
    .flatMap(List::stream)
    .forEach(System.out::println);
// Java, Spring, Lambda, Kafka

  41. Lambda mit Stream Reduce

    List<Integer> zahlenReduzieren = Arrays.asList(1, 2, 3, 4, 5);
int reduzierteSumme = zahlenReduzieren.stream()
    .reduce(0, (akkumulator, element) -> akkumulator + element);
System.out.println("Summe (Reduce): " + reduzierteSumme); // Summe (Reduce): 15

  42. Lambda mit Stream Map

    List<String> namenGross = Arrays.asList("Java", "Spring", "Lambda");
namenGross.stream()
    .map(String::toUpperCase)
    .forEach(System.out::println);
// JAVA, SPRING, LAMBDA

  43. Lambda mit Stream Filter und Map

    List<String> gefiltertUndGross = Arrays.asList("Java", "Spring", "Lambda");
gefiltertUndGross.stream()
    .filter(s -> s.startsWith("J"))
    .map(String::toUpperCase)
    .forEach(System.out::println);
// JAVA

  44. Lambda mit Stream Sorted mit Comparator (Reverse)

    List<String> sortiertReverse = Arrays.asList("Java", "Spring", "Lambda");
sortiertReverse.stream()
    .sorted((s1, s2) -> s2.compareTo(s1)) // umgekehrte Reihenfolge
    .forEach(System.out::println);
// Spring, Lambda, Java

  45. Lambda mit Stream Iterate

    Stream.iterate(0, n -> n + 2)
    .limit(5)
    .forEach(System.out::println);
// 0, 2, 4, 6, 8

  46. Lambda mit Stream Generate

    Stream.generate(() -> "Java")
    .limit(3)
    .forEach(System.out::println);
// Java, Java, Java

  47. Lambda mit Stream of Primitives

    IntStream.range(1, 4)
    .forEach(System.out::println);
// 1, 2, 3

  48. Lambda mit Stream to Array

    List<String> listeZuArray = Arrays.asList("Java", "Spring", "Lambda");
String[] array = listeZuArray.stream()
    .toArray(String[]::new);
System.out.println(Arrays.toString(array));
// [Java, Spring, Lambda]

  49. Lambda mit Stream Collect to List

    Stream<String> streamZuListe = Stream.of("Java", "Spring", "Lambda");
List<String> gesammelteListe = streamZuListe
    .collect(Collectors.toList());
System.out.println(gesammelteListe);
// [Java, Spring, Lambda]

Ich hoffe, diese Sammlung von Lambda- und Stream-Snippets gibt dir einen guten Überblick und praktische Beispiele an die Hand. Die funktionale Programmierung mit Java 8 ist ein mächtiges Werkzeug, das deinen Code sauberer und deine Entwicklung effizienter macht.

Welche Snippets findest du am nützlichsten in deinem Arbeitsalltag? Lass es mich wissen!