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

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

Hello everyone,

Java 8 fundamentally changed the way we write code. The introduction of Lambda expressions and the Stream API brought a much more functional programming style to Java, allowing us developers to write cleaner, more concise and much more readable code.

In this post I have put together 50 essential snippets about lambda expressions. They demonstrate practical use - from basic operations to advanced stream processing. Whether you’re working on enterprise-grade code or preparing for a tech interview, these examples will sharpen your understanding and increase your productivity.

Let’s dive right in!

The Snippets: Lambda Expressions and Streams in Action

  1. Simple Runnable Example
Runnable meinRunnable = () -> System.out.println("Hallo, Lambda!");
new Thread(meinRunnable).start();
  1. Iterate through list with lambda
List<String> technologies = Arrays.asList("Java", "Spring", "Lambda"); 
technologies.forEach(element -> System.out.println(element));
  1. Filter list with lambda
List<String> programming languages = Arrays.asList("Java", "JavaScript", "Python"); 
List<String> filteredList = programminglanguages.stream() 
.filter(language -> language.startsWith("J")) 
.collect(Collectors.toList()); 
filteredList.forEach(System.out::println);
  1. Sort list with lambda
List<String> themen = Arrays.asList("Java", "Lambda", "Kafka");
themen.sort((thema1, thema2) -> thema1.compareTo(thema2));
themen.forEach(System.out::println);
  1. Use custom functional interface
@FunctionalInterface 
interface calculator { 
int calculate(int number1, int number2); 
}

public static void main(String[] args) { 
Calculator add = (number1, number2) -> number1 + number2; 
Multiply calculator = (number1, number2) -> number1 * number2; 
System.out.println("Addition: " + add.calculate(5, 3)); 
System.out.println("Multiplication: " + multiply.calculate(5, 3)); 
}
  1. Lambda bei Map-Iteration
Map<String, Integer> versions = new HashMap<>(); 
versions.put("Java", 8); 
versions.put("Spring", 5); 
versions.put("Lambda", 1); 
versions.forEach((key, value) -> System.out.println(key + ": " + value));
  1. Create thread with Lambda
new Thread(() -> System.out.println("Thread with Lambda running!")).start();
  1. Lambda in Comparator
List<String> frameworks = Arrays.asList("Java", "Lambda", "Kafka");
frameworks.sort(Comparator.comparingInt(String::length));
frameworks.forEach(System.out::println);
  1. Method Reference with Lambda
List<String> tools = Arrays.asList("Java", "Lambda", "Kafka");
tools.forEach(System.out::println);
  1. Lambda with Optional
Optional<String> optionalValue = Optional.of("Java"); 
optionalValue.ifPresent(value -> System.out.println("Value is present: " + value));
  1. Lambda mit Predicate
Predicate<String> istLeer = s -> s.isEmpty();
System.out.println(istLeer.test("")); // true
System.out.println(istLeer.test("Java")); // false
  1. Lambda mit BiFunction
BiFunction<Integer, Integer, Integer> adder = (z1, z2) -> z1 + z2; 
System.out.println(adder.apply(2, 3)); // 5
  1. Lambda mit Consumer
Consumer<String> issuer = s -> System.out.println(s); 
issuer.accept("Hello, world!"); // Hello World!
  1. Lambda mit Supplier
Supplier<String> supplier = () -> "Java"; 
System.out.println(supplier.get()); // Java
  1. Lambda mit Stream Sorted
List<String> fruits = Arrays.asList("Banana", "Pear", "Grape"); 
fruits.stream() 
.sorted() 
.forEach(System.out::println);
  1. Lambda mit Stream Count
List<Integer> numbersQuantity = Arrays.asList(1, 2, 3, 4, 5); 
long number = numbersQuantity.stream() 
.count(); 
System.out.println("Count: " + count); // Number: 5
  1. 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
  1. Lambda mit Stream AllMatch
List<Integer> evenNumbers = Arrays.asList(2, 4, 6, 8, 10); 
boolean allEven = evenNumbers.stream() 
.allMatch(n -> n % 2 == 0); 
System.out.println("AllEven: " + allEven); // true
  1. Lambda mit Stream NoneMatch
List<String> technologyCheck = Arrays.asList("Java", "Spring", "Lambda"); 
boolean nonePython = technologyCheck.stream() 
.noneMatch(s -> s.equals("Python")); 
System.out.println("Does not contain 'Python': " + noPython); // true
  1. Lambda mit Stream FindFirst
List<String> firstElements = Arrays.asList("Java", "Spring", "Lambda"); 
Optional<String> first = firstElements.stream() 
.findFirst(); 
first.ifPresent(System.out::println); // Java
  1. Lambda with Stream FindAny
List<String> anyElements = Arrays.asList("Java", "Spring", "Lambda"); 
Optional<String> any = anyElements.stream() 
.findAny(); 
any.ifPresent(System.out::println);
  1. Lambda for summing integers
List<Integer> numbersSum = Arrays.asList(1, 2, 3, 4, 5); 
int sum = numbersSum.stream() 
.mapToInt(Integer::intValue) 
.sum(); 
System.out.println("Sum: " + sum); // Total: 15
  1. Lambda for largest 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
  1. Lambda for smallest 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
  1. Lambda for connecting strings
List<String> words = Arrays.asList("Java", "Spring", "Lambda"); 
String connected = words.stream() 
.collect(Collectors.joining(", ")); 
System.out.println(connected); // Java, Spring, Lambda
  1. Lambda mit Stream MapToInt
List<String> namenLaengen = Arrays.asList("Java", "Spring", "Lambda");
namenLaengen.stream()
.mapToInt(String::length)
.forEach(System.out::println); // 4, 6, 6
  1. Lambda mit Stream Collect to Set
List<String> duplicates = Arrays.asList("Java", "Spring", "Lambda", "Spring"); 
Set<String> unique = duplicates.stream() 
.collect(Collectors.toSet()); 
unique.forEach(System.out::println); // Java, Spring, Lambda
  1. 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
  1. Lambda mit Stream PartitioningBy
List<Integer> numbersPartition = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); 
Map<Boolean, List<Integer>> partitioned = numbersPartition.stream() 
.collect(Collectors.partitioningBy(n -> n % 2 == 0)); 
partitioned.forEach((isEven, list) -> System.out.println(isEven + ": " + list)); 
// true: [2, 4, 6, 8, 10], false: [1, 3, 5, 7, 9]
  1. Lambda mit Stream Counting (Collector)
List<String> elementsCount = Arrays.asList("Java", "Spring", "Lambda"); 
long numberCollector = elementsCount.stream() 
.collect(Collectors.counting()); 
System.out.println("Count (Collector): " + countCollector); // Number (Collector): 3
  1. Lambda mit Stream SummarizingInt
List<Integer> statisticsNumbers = Arrays.asList(1, 2, 3, 4, 5); 
IntSummaryStatistics statistics = statisticsNumbers.stream() 
.collect(Collectors.summarizingInt(Integer::intValue)); 
System.out.println("Sum: " + statistics.getSum()); 
System.out.println("Average: " + statistics.getAverage()); 
System.out.println("Maximum: " + statistics.getMax()); 
System.out.println("Minimum: " + statistics.getMin());
  1. Lambda mit Stream Mapping (GroupingBy)
List<String> lengthByGroups = Arrays.asList("Java", "Spring", "Lambda"); 
Map<Integer, List<String>> byLengthGroup = lengthByGroup.stream() 
.collect(Collectors.groupingBy(String::length)); 
GroupedbyLength.forEach((length, list) -> System.out.println(length + ": " + list)); 
// 4: [Java], 6: [Spring, Lambda]
  1. Lambda mit Stream Joining ohne Delimiter
List<String> without separation = Arrays.asList("Java", "Spring", "Lambda"); 
String connectedWithoutDelimiter = withoutSeparation.stream() 
.collect(Collectors.joining()); 
System.out.println(connectedWithoutDelimiter); // JavaSpringLambda
  1. Lambda mit Stream ToMap
List<String> listZuMap = Arrays.asList("Java", "Spring", "Lambda"); 
Map<String, Integer> assigned = listToMap.stream() 
.collect(Collectors.toMap(s -> s, String::length)); 
assigned.forEach((key, value) -> System.Lister.println(key + ": " + value)); 
// Java: 4, Spring: 6, Lambda: 6
  1. Lambda to create a stream
Stream<String> meinStream = Stream.of("Java", "Spring", "Lambda");
meinStream.forEach(System.out::println);
  1. Lambda mit Stream Limit
Stream<String> begrenzterStream = Stream.of("Java", "Spring", "Lambda", "Kafka");
begrenzterStream.limit(2)
.forEach(System.out::println); // Java, Spring
  1. Lambda mit Stream Peek
Stream<String> peekStream = Stream.of("Java", "Spring", "Lambda", "Kafka");
peekStream.peek(System.out::println)
.collect(Collectors.toList());
  1. Lambda mit Optional (ifPresent)
Optional<String> optionalVorhanden = Optional.of("Java");
optionalVorhanden.ifPresent(System.out::println); // Java
  1. Lambda mit Stream Distinct
List<String> duplikateEntfernen = Arrays.asList("Java", "Spring", "Java", "Lambda");
duplikateEntfernen.stream()
.distinct()
.forEach(System.out::println);
// Java, Spring, Lambda
  1. 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
  1. Lambda mit Stream Reduce
List<Integer> numbersReduce = Arrays.asList(1, 2, 3, 4, 5); 
int reducedSum = numbersReduce.stream() 
.reduce(0, (accumulator, element) -> accumulator + element); 
System.out.println("Sum(Reduce): " + reducedSum); // Sum (Reduce): 15
  1. Lambda mit Stream Map
List<String> namenGross = Arrays.asList("Java", "Spring", "Lambda");
namenGross.stream()
.map(String::toUpperCase)
.forEach(System.out::println);
// JAVA, SPRING, LAMBDA
  1. Lambda with Stream Filter and Map
List<String> gefiltertUndGross = Arrays.asList("Java", "Spring", "Lambda");
gefiltertUndGross.stream()
.filter(s -> s.startsWith("J"))
.map(String::toUpperCase)
.forEach(System.out::println);
// JAVA
  1. Lambda mit Stream Sorted mit Comparator (Reverse)
List<String> sortedReverse = Arrays.asList("Java", "Spring", "Lambda"); 
sortedReverse.stream() 
.sorted((s1, s2) -> s2.compareTo(s1)) // reverse order 
.forEach(System.out::println); 
// Spring, Lambda, Java
  1. Lambda mit Stream Iterate
Stream.iterate(0, n -> n + 2)
.limit(5)
.forEach(System.out::println);
// 0, 2, 4, 6, 8
  1. Lambda mit Stream Generate
Stream.generate(() -> "Java")
.limit(3)
.forEach(System.out::println);
// Java, Java, Java
  1. Lambda mit Stream of Primitives
IntStream.range(1, 4)
.forEach(System.out::println);
// 1, 2, 3
  1. 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]
  1. 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]

I hope this collection of Lambda and Stream snippets gives you a good overview and practical examples. Functional programming with Java 8 is a powerful tool that makes your code cleaner and your development more efficient.

Which snippets do you find most useful in your everyday work? Let me know!