Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Java 8 Stream API — creation, intermediate operations, terminal operations, parallel streams, collectors, and real-world data processing pipelines.
What is the Stream API?
The Stream API provides a declarative way to process collections of data. Instead of telling Java *how* to iterate (for loops, iterators), you describe *what* transformations you want — the Stream handles the iteration internally.
java example
// Imperative approach (HOW)
List<String> filtered = new ArrayList<>();
for (String name : names) {
if (name.length() > 3) {
filtered.add(name.toUpperCase());
}
}
Collections.sort(filtered);
// Declarative approach with Streams (WHAT)
List<String> filtered = names.stream()
.filter(name -> name.length() > 3)
.map(String::toUpperCase)
.sorted()
.collect(Collectors.toList());Key Characteristics
- Not a data structure — doesn't store elements
- Lazy evaluation — intermediate operations execute only when a terminal operation is called
- Possibly unbounded — can process infinite sequences
- Consumable — can only be traversed once
- Non-interfering — doesn't modify the source
Intermediate Operations (Lazy)
These return a new Stream and are not executed until a terminal operation is invoked.
filter — Select elements matching a predicate
Example
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> evens = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList()); // [2, 4, 6, 8, 10]
map — Transform each element
Example
List<String> names = Arrays.asList("alice", "bob", "charlie");
List<String> upper = names.stream()
.map(String::toUpperCase)
.collect(Collectors.toList()); // [ALICE, BOB, CHARLIE]
List<Integer> lengths = names.stream()
.map(String::length)
.collect(Collectors.toList()); // [5, 3, 7]
flatMap — Flatten nested structures
Example
List<List<Integer>> nested = Arrays.asList(
Arrays.asList(1, 2, 3),
Arrays.asList(4, 5, 6),
Arrays.asList(7, 8, 9)
);
List<Integer> flat = nested.stream()
.flatMap(Collection::stream)
.collect(Collectors.toList()); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
// Real-world: flatten orders to items
List<OrderItem> allItems = orders.stream()
.flatMap(order -> order.getItems().stream())
.collect(Collectors.toList());
// Get unique words from sentences
List<String> sentences = Arrays.asList("Hello World", "Java Streams", "Are Awesome");
List<String> words = sentences.stream()
.flatMap(s -> Arrays.stream(s.split(" ")))
.distinct()
.collect(Collectors.toList());
sorted — Sort elements
java example
// Natural order
List<Integer> sorted = numbers.stream().sorted().collect(Collectors.toList());
// Custom comparator
List<String> sortedByLength = names.stream()
.sorted(Comparator.comparingInt(String::length))
.collect(Collectors.toList());
// Multiple criteria
List<Person> sortedPeople = people.stream()
.sorted(Comparator.comparing(Person::getLastName)
.thenComparing(Person::getFirstName)
.thenComparingInt(Person::getAge))
.collect(Collectors.toList());
// Reverse order
List<Integer> descending = numbers.stream()
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());distinct, limit, skip, peek
Example
// Remove duplicates (uses equals/hashCode)
List<Integer> unique = Arrays.asList(1, 2, 2, 3, 3, 3)
.stream().distinct().collect(Collectors.toList()); // [1, 2, 3]
// Limit results
List<Integer> firstThree = numbers.stream().limit(3).collect(Collectors.toList());
// Skip elements
List<Integer> skipTwo = numbers.stream().skip(2).collect(Collectors.toList());
// Pagination
List<Integer> page = numbers.stream()
.skip((pageNumber - 1) * pageSize)
.limit(pageSize)
.collect(Collectors.toList());
// peek - for debugging (don't use for side effects in production)
List<Integer> result = numbers.stream()
.filter(n -> n > 3)
.peek(n -> System.out.println("Filtered: " + n))
.map(n -> n * 2)
.peek(n -> System.out.println("Mapped: " + n))
.collect(Collectors.toList());
Terminal Operations (Trigger Execution)
collect — Accumulate into a collection
Example
// To List
List<String> list = stream.collect(Collectors.toList());
// To Set
Set<String> set = stream.collect(Collectors.toSet());
// To specific collection
TreeSet<String> treeSet = stream.collect(Collectors.toCollection(TreeSet::new));
// To Map
Map<String, Integer> nameToAge = people.stream()
.collect(Collectors.toMap(Person::getName, Person::getAge));
// Handle duplicate keys
Map<String, Integer> map = people.stream()
.collect(Collectors.toMap(
Person::getDepartment,
Person::getSalary,
Integer::sum // merge function for duplicate keys
));
// Joining strings
String joined = names.stream().collect(Collectors.joining(", ", "[", "]"));
// [Alice, Bob, Charlie]
// Grouping
Map<String, List<Person>> byDept = people.stream()
.collect(Collectors.groupingBy(Person::getDepartment));
// Grouping with downstream collector
Map<String, Long> countByDept = people.stream()
.collect(Collectors.groupingBy(Person::getDepartment, Collectors.counting()));
Map<String, Double> avgSalaryByDept = people.stream()
.collect(Collectors.groupingBy(
Person::getDepartment,
Collectors.averagingDouble(Person::getSalary)
));
// Partitioning (boolean grouping)
Map<Boolean, List<Integer>> evenOdd = numbers.stream()
.collect(Collectors.partitioningBy(n -> n % 2 == 0));
// Statistics
IntSummaryStatistics stats = numbers.stream()
.collect(Collectors.summarizingInt(Integer::intValue));
// count=10, sum=55, min=1, max=10, average=5.5
Output
[Alice, Bob, Charlie]
reduce — Combine elements into a single result
java example
// Sum
Optional<Integer> sum = numbers.stream().reduce((a, b) -> a + b);
int sumWithIdentity = numbers.stream().reduce(0, Integer::sum);
// Max/Min
Optional<Integer> max = numbers.stream().reduce(Integer::max);
// String concatenation
String concat = words.stream().reduce("", (a, b) -> a + " " + b).trim();
// Complex reduction
record Product(String name, double price, int qty) {}
double totalValue = products.stream()
.reduce(0.0, (sum, p) -> sum + p.price() * p.qty(), Double::sum);forEach, count, anyMatch, allMatch, noneMatch
java example
// forEach (terminal - consumes stream)
names.stream().forEach(System.out::println);
// count
long count = names.stream().filter(n -> n.length() > 3).count();
// Short-circuit matching
boolean anyLong = names.stream().anyMatch(n -> n.length() > 10);
boolean allShort = names.stream().allMatch(n -> n.length() < 20);
boolean noneEmpty = names.stream().noneMatch(String::isEmpty);
// findFirst and findAny
Optional<String> first = names.stream()
.filter(n -> n.startsWith("A"))
.findFirst();
Optional<String> any = names.parallelStream()
.filter(n -> n.startsWith("A"))
.findAny(); // May return different results in parallelParallel Streams
java example
// Creating parallel streams
Stream<Integer> parallel = list.parallelStream();
Stream<Integer> parallel2 = list.stream().parallel();
// When to use parallel streams:
// ✅ Large datasets (> 10,000 elements)
// ✅ CPU-intensive operations (computation, not I/O)
// ✅ Stateless, non-interfering operations
// ✅ Unordered results acceptable
// ❌ Don't use when:
// - Small datasets (overhead > benefit)
// - Order matters (use forEachOrdered)
// - Operations have side effects
// - Source is LinkedList or I/O-based
// Performance example
long start = System.nanoTime();
long sum = LongStream.range(0, 100_000_000).parallel().sum();
System.out.println("Parallel: " + (System.nanoTime() - start) / 1_000_000 + "ms");
start = System.nanoTime();
sum = LongStream.range(0, 100_000_000).sum();
System.out.println("Sequential: " + (System.nanoTime() - start) / 1_000_000 + "ms");
// Thread safety with parallel streams
// ❌ NOT SAFE
List<Integer> unsafeList = new ArrayList<>();
IntStream.range(0, 1000).parallel().forEach(unsafeList::add); // ConcurrentModification!
// ✅ SAFE
List<Integer> safeList = IntStream.range(0, 1000)
.parallel()
.boxed()
.collect(Collectors.toList());Output
Parallel: " + (System.nanoTime() - start) / 1_000_000 + "ms Sequential: " + (System.nanoTime() - start) / 1_000_000 + "ms
Advanced Patterns
Custom Collector
java example
// Collect to ImmutableList (Guava)
Collector<String, ?, ImmutableList<String>> toImmutableList =
Collector.of(
ImmutableList::<String>builder, // supplier
ImmutableList.Builder::add, // accumulator
(b1, b2) -> b1.addAll(b2.build()), // combiner
ImmutableList.Builder::build // finisher
);
// Collect to comma-separated string with limit
public static <T> Collector<T, ?, String> joiningWithLimit(int limit, String delimiter) {
return Collectors.collectingAndThen(
Collectors.toList(),
list -> {
String joined = list.stream()
.limit(limit)
.map(Object::toString)
.collect(Collectors.joining(delimiter));
if (list.size() > limit) {
joined += delimiter + "... and " + (list.size() - limit) + " more";
}
return joined;
}
);
}Stream Pipeline for Data Processing
java example
record Transaction(String id, String type, double amount, LocalDate date, String category) {}
public class TransactionAnalyzer {
public static void main(String[] args) {
List<Transaction> transactions = getTransactions();
// Monthly spending summary by category
Map<String, Map<String, Double>> monthlyByCategory = transactions.stream()
.filter(t -> "DEBIT".equals(t.type()))
.collect(Collectors.groupingBy(
t -> t.date().getMonth().toString(),
Collectors.groupingBy(
Transaction::category,
Collectors.summingDouble(Transaction::amount)
)
));
// Top 5 largest transactions
List<Transaction> top5 = transactions.stream()
.sorted(Comparator.comparingDouble(Transaction::amount).reversed())
.limit(5)
.collect(Collectors.toList());
// Running total
List<Double> runningTotal = new ArrayList<>();
transactions.stream()
.mapToDouble(Transaction::amount)
.reduce(0.0, (sum, amount) -> {
double newSum = sum + amount;
runningTotal.add(newSum);
return newSum;
});
}
}Interview Questions
Q1: What is the difference between intermediate and terminal operations?
Answer: Intermediate operations (filter, map, sorted) are lazy — they return a new Stream and don't process data until a terminal operation (collect, forEach, reduce) is invoked. Terminal operations trigger the pipeline execution and produce a result.
Q2: Can a stream be reused after a terminal operation?
Answer: No. Once a terminal operation is called, the stream is consumed and cannot be reused. Attempting to reuse it throws IllegalStateException. Create a new stream from the source instead.
Q3: What's the difference between map and flatMap?
Answer: map transforms each element to exactly one output element (1:1). flatMap transforms each element to zero or more elements by flattening nested structures (1:N). Use flatMap when each element maps to a collection.
Q4: When should you use parallel streams?
Answer: When processing large datasets (>10K elements) with CPU-intensive, stateless operations where order doesn't matter. Avoid for I/O-bound operations, small datasets, or operations with side effects.
Q5: What is lazy evaluation in streams?
Answer: Intermediate operations are not executed immediately. They build a pipeline that executes only when a terminal operation is called. This enables optimizations like short-circuiting (findFirst stops after finding one match).
Q6: How does reduce differ from collect?
Answer: reduce combines elements into a single immutable result through repeated application of a binary operator. collect is a mutable reduction that accumulates elements into a container (List, Map, etc.) and is more efficient for building collections.
Q7: Write a stream pipeline to find the second-highest salary.
java example
Optional<Double> secondHighest = employees.stream()
.map(Employee::getSalary)
.distinct()
.sorted(Comparator.reverseOrder())
.skip(1)
.findFirst();Summary
In this chapter, we learned about Stream API in Java 8 in detail. Here are the key points:
- Basic introduction to the concept and why it is needed
- Syntax and structure with complete examples
- Internal working and best practices
- Real-world applications and use cases
- Common mistakes and how to avoid them
- How this topic is asked in interviews
To practice these concepts, write and run the code in your IDE and verify the output. Modify each example and experiment so that you deeply understand the concept.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Stream API in Java 8.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, features, stream, api
Related Java Master Course Topics
Continue learning this concept
Java 8 FeaturesDate and Time API in Java 8Complete guide to java.time package — LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Duration, Period, formatting, parsing, and migration from legacy Date/Calendar.Java 8 FeaturesDefault and Static Methods in InterfacesComplete guide to Default and Static methods in Java 8 interfaces — interface evolution, multiple inheritance resolution, and practical design patterns.Java 8 FeaturesFunctional Interface in Java 8Complete guide to Functional Interfaces in Java 8 — @FunctionalInterface annotation, built-in interfaces (Predicate, Function, Consumer, Supplier), composition, and custom interfaces.Java 8 FeaturesLambda Expression in Java 8Master Lambda Expressions in Java 8 — syntax, functional programming paradigm, type inference, variable capture, and real-world usage patterns with comprehensive examples.Java 8 FeaturesMethod Reference in Java 8Deep guide to Method References in Java 8 — all four types, when to use vs lambdas, constructor references, and practical patterns.Java 8 FeaturesOptional Class in Java 8Master the Optional class in Java 8 — eliminating null pointer exceptions, proper usage patterns, chaining operations, and anti-patterns to avoid.