Java Streams Basics – Practical Foundations for Beginners

In this one-day course, you'll learn the fundamentals of the Java Streams API – with clear explanations, practical examples, and lots of hands-on exercises.

You'll discover how Streams differ from traditional Collections – and why they’re such a powerful tool for modern data processing in Java.

Through practical scenarios, we'll explore the structure of a stream pipeline – from the data source, through intermediate operations like map(), filter(), and flatMap(), to final processing with collect() and other terminal operations.

A special focus is placed on understanding the underlying concepts: What happens when? What actually gets executed – and what doesn't? What exactly does Lazy Evaluation mean? And where are the typical pitfalls?

By the end of the day, you’ll be able to confidently use streams, express complex data operations elegantly, and apply functional programming effectively in your projects.

Request in-house training »

👉 Already familiar with streams and ready to go deeper? Check out Java Streams Advanced – Gatherers, Spliterators & More.

👉 Want to cover the full range of the Stream API in one go? Then the combined course Java Streams Basics + Advanced is ideal for you.

This course is designed for Java developers who want to systematically learn streams and functional programming from the ground up.

Whether you’ve avoided streams, only scratched the surface, or want to refresh your knowledge – this course will help you build a solid foundation for productive use in real-world projects.

If you’ve preferred traditional loops because streams seemed too abstract: after this course, you’ll know when and how to use them effectively.

The course alternates between short theory segments, hands-on code examples, and interactive exercises – so you learn the fundamentals of the Stream API in a well-structured and practical way.

• Lambda expressions: syntax, types, and usage
• Functional interfaces (Consumer, Supplier, Function, Predicate, etc.)
• Method references: static, instance, constructor references
• Hands-on exercises: Lambda expressions vs. anonymous classes

• What is a stream? Conceptual differences from collections
• Anatomy of a stream pipeline: Source → Intermediate Operations → Terminal Operations
• Lazy evaluation and its implications
• Creating streams: from collections, arrays, files, ranges
• Primitive streams: IntStream, LongStream, DoubleStream
• Hands-on exercises: First stream pipelines with primitive streams

• Transformations with map(), flatMap(), filter()
• Selection and sorting: distinct(), sorted(), limit(), skip()
• Debugging with peek() – used correctly
• Chaining operations and performance aspects
• Hands-on exercises: More complex data processing

• collect() – the most versatile terminal operator
• Built-in collectors: toList(), toSet(), toMap()
• forEach(), forEachOrdered()
• reduce() for aggregations
• Finding operations: findFirst(), findAny()
• Matching operations: allMatch(), anyMatch(), noneMatch()
• Hands-on exercises: Terminal operations with standard collectors