[EN] Java 8: revolution in code writing – 50 essential lambda and stream snippets

Julian | Jul 24, 2025 min read
[EN] Java 8: revolution in code writing – 50 essential lambda and stream snippets

This image was AI-generated.

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!

This text was created with the help of AI.