Java Programming#
Lecture 40: Stream API#
GTU Diploma in Computer Engineering#
layout: two-cols#
Learning Objectives#
After this lecture, you will be able to:
- Understand the concept and benefits of Java Streams
- Create streams from various data sources
- Use intermediate operations for data transformation
- Apply terminal operations to produce results
- Work with parallel streams for performance
- Use collectors for data aggregation
- Create custom collectors for specific needs
- Apply stream best practices and performance optimization
::right::
Lecture Overview#
- Introduction to Stream API
- Creating Streams
- Intermediate Operations
- Terminal Operations
- Parallel Streams
- Collectors
- Custom Collectors
- Advanced Stream Operations
- Performance and Best Practices
- Hands-on Exercises
What is Stream API?#
Stream API provides a functional programming approach to processing collections of data.
Key Characteristics#
- No Storage: Streams don’t store data, they operate on data sources
- Functional in Nature: Operations don’t modify the source
- Lazy Evaluation: Intermediate operations are not executed until terminal operation is called
- Possibly Unbounded: Streams can be infinite
- Consumable: Stream elements are visited only once
Stream vs Collection#
import java.util.*;
import java.util.stream.*;
public class StreamIntroduction {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
// Traditional approach
List<String> upperCaseNames = new ArrayList<>();
for (String name : names) {
if (name.length() > 3) {
upperCaseNames.add(name.toUpperCase());
}
}
Collections.sort(upperCaseNames);
System.out.println("Traditional: " + upperCaseNames);
// Stream approach
List<String> streamResult = names.stream()
.filter(name -> name.length() > 3)
.map(String::toUpperCase)
.sorted()
.collect(Collectors.toList());
System.out.println("Stream: " + streamResult);
}
}
Creating Streams#
From Collections#
import java.util.*;
import java.util.stream.*;
public class StreamCreation {
public static void main(String[] args) {
// From List
List<String> list = Arrays.asList("apple", "banana", "cherry");
Stream<String> streamFromList = list.stream();
// From Array
String[] array = {"red", "green", "blue"};
Stream<String> streamFromArray = Arrays.stream(array);
// From Set
Set<Integer> set = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Stream<Integer> streamFromSet = set.stream();
// From Map
Map<String, Integer> map = new HashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);
map.put("Charlie", 35);
Stream<String> keysStream = map.keySet().stream();
Stream<Integer> valuesStream = map.values().stream();
Stream<Map.Entry<String, Integer>> entriesStream = map.entrySet().stream();
// Display results
System.out.println("From list:");
streamFromList.forEach(System.out::println);
System.out.println("From array:");
streamFromArray.forEach(System.out::println);
System.out.println("From set:");
streamFromSet.forEach(System.out::println);
System.out.println("Map entries:");
entriesStream.forEach(entry ->
System.out.println(entry.getKey() + " -> " + entry.getValue()));
}
}
Stream Factory Methods#
import java.util.stream.*;
import java.nio.file.*;
import java.util.*;
public class StreamFactoryMethods {
public static void main(String[] args) {
// Stream.of()
Stream<String> streamOf = Stream.of("Java", "Python", "JavaScript");
System.out.println("Stream.of():");
streamOf.forEach(System.out::println);
// Stream.empty()
Stream<String> emptyStream = Stream.empty();
System.out.println("Empty stream count: " + emptyStream.count());
// Stream.generate() - infinite stream
Stream<Double> randomStream = Stream.generate(Math::random);
System.out.println("5 random numbers:");
randomStream.limit(5).forEach(System.out::println);
// Stream.iterate() - infinite stream
Stream<Integer> numbersStream = Stream.iterate(0, n -> n + 2);
System.out.println("First 10 even numbers:");
numbersStream.limit(10).forEach(System.out::println);
// Stream.iterate() with predicate (Java 9+)
Stream<Integer> limitedStream = Stream.iterate(1, n -> n <= 100, n -> n * 2);
System.out.println("Powers of 2 up to 100:");
limitedStream.forEach(System.out::println);
// IntStream, LongStream, DoubleStream
IntStream intStream = IntStream.range(1, 6); // 1, 2, 3, 4, 5
System.out.println("IntStream range:");
intStream.forEach(System.out::println);
IntStream intStreamClosed = IntStream.rangeClosed(1, 5); // 1, 2, 3, 4, 5
System.out.println("IntStream rangeClosed:");
intStreamClosed.forEach(System.out::println);
// Random number streams
Random random = new Random();
Stream<Integer> randomInts = random.ints(5, 1, 10).boxed();
System.out.println("5 random integers between 1-10:");
randomInts.forEach(System.out::println);
// Stream from String
IntStream charsStream = "Hello".chars();
System.out.println("Characters in 'Hello':");
charsStream.forEach(c -> System.out.print((char)c + " "));
System.out.println();
// Stream from file lines (requires exception handling)
try {
// Creates a temporary file for demonstration
Path tempFile = Files.createTempFile("demo", ".txt");
Files.write(tempFile, Arrays.asList("Line 1", "Line 2", "Line 3"));
Stream<String> linesStream = Files.lines(tempFile);
System.out.println("Lines from file:");
linesStream.forEach(System.out::println);
// Clean up
Files.deleteIfExists(tempFile);
} catch (Exception e) {
System.out.println("File operation error: " + e.getMessage());
}
}
}
Intermediate Operations#
Intermediate operations are lazy and return a stream.
Filter, Map, and Sorted#
import java.util.*;
import java.util.stream.*;
public class IntermediateOperations {
static class Person {
private String name;
private int age;
private String city;
private double salary;
public Person(String name, int age, String city, double salary) {
this.name = name;
this.age = age;
this.city = city;
this.salary = salary;
}
// Getters
public String getName() { return name; }
public int getAge() { return age; }
public String getCity() { return city; }
public double getSalary() { return salary; }
@Override
public String toString() {
return String.format("Person{name='%s', age=%d, city='%s', salary=%.2f}",
name, age, city, salary);
}
}
public static void main(String[] args) {
List<Person> people = Arrays.asList(
new Person("Alice", 25, "New York", 75000),
new Person("Bob", 30, "London", 65000),
new Person("Charlie", 35, "New York", 85000),
new Person("Diana", 28, "London", 70000),
new Person("Eve", 32, "Paris", 80000)
);
System.out.println("Original list:");
people.forEach(System.out::println);
// Filter - people older than 30
System.out.println("\nPeople older than 30:");
people.stream()
.filter(person -> person.getAge() > 30)
.forEach(System.out::println);
// Map - extract names
System.out.println("\nNames only:");
people.stream()
.map(Person::getName)
.forEach(System.out::println);
// Map - transform to uppercase names
System.out.println("\nUppercase names:");
people.stream()
.map(Person::getName)
.map(String::toUpperCase)
.forEach(System.out::println);
// Sorted - by age
System.out.println("\nSorted by age:");
people.stream()
.sorted(Comparator.comparing(Person::getAge))
.forEach(System.out::println);
// Sorted - by salary (descending)
System.out.println("\nSorted by salary (descending):");
people.stream()
.sorted(Comparator.comparing(Person::getSalary).reversed())
.forEach(System.out::println);
// Complex chain - filter, map, and sort
System.out.println("\nNew York people, names only, sorted:");
people.stream()
.filter(person -> "New York".equals(person.getCity()))
.map(Person::getName)
.sorted()
.forEach(System.out::println);
}
}
More Intermediate Operations#
Distinct, Limit, Skip, and FlatMap#
import java.util.*;
import java.util.stream.*;
public class MoreIntermediateOperations {
public static void main(String[] args) {
// Distinct
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 5);
System.out.println("Original: " + numbers);
System.out.println("Distinct:");
numbers.stream()
.distinct()
.forEach(System.out::println);
// Limit
System.out.println("\nFirst 3 distinct numbers:");
numbers.stream()
.distinct()
.limit(3)
.forEach(System.out::println);
// Skip
System.out.println("\nSkip first 2 distinct numbers:");
numbers.stream()
.distinct()
.skip(2)
.forEach(System.out::println);
// FlatMap - flatten nested collections
List<List<String>> nestedList = Arrays.asList(
Arrays.asList("Java", "Python"),
Arrays.asList("JavaScript", "C++"),
Arrays.asList("Ruby", "Go")
);
System.out.println("\nNested list:");
nestedList.forEach(System.out::println);
System.out.println("Flattened:");
nestedList.stream()
.flatMap(Collection::stream)
.forEach(System.out::println);
// FlatMap with arrays
String[] words = {"Hello World", "Java Streams", "Functional Programming"};
System.out.println("\nAll words from sentences:");
Arrays.stream(words)
.flatMap(sentence -> Arrays.stream(sentence.split(" ")))
.forEach(System.out::println);
// FlatMap with Optional
List<Optional<String>> optionals = Arrays.asList(
Optional.of("Alice"),
Optional.empty(),
Optional.of("Bob"),
Optional.empty(),
Optional.of("Charlie")
);
System.out.println("\nNon-empty optionals:");
optionals.stream()
.flatMap(Optional::stream) // Java 9+ feature
.forEach(System.out::println);
// Alternative for Java 8
System.out.println("Non-empty optionals (Java 8 compatible):");
optionals.stream()
.filter(Optional::isPresent)
.map(Optional::get)
.forEach(System.out::println);
// Complex example: processing orders
List<Order> orders = Arrays.asList(
new Order("Order1", Arrays.asList(
new Product("Laptop", 999.99),
new Product("Mouse", 29.99)
)),
new Order("Order2", Arrays.asList(
new Product("Keyboard", 79.99),
new Product("Monitor", 299.99)
))
);
System.out.println("\nAll products from all orders:");
orders.stream()
.flatMap(order -> order.getProducts().stream())
.forEach(System.out::println);
System.out.println("\nTotal value of all products:");
double total = orders.stream()
.flatMap(order -> order.getProducts().stream())
.mapToDouble(Product::getPrice)
.sum();
System.out.println("$" + total);
}
static class Order {
private String id;
private List<Product> products;
public Order(String id, List<Product> products) {
this.id = id;
this.products = products;
}
public String getId() { return id; }
public List<Product> getProducts() { return products; }
}
static class Product {
private String name;
private double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() { return name; }
public double getPrice() { return price; }
@Override
public String toString() {
return String.format("Product{name='%s', price=%.2f}", name, price);
}
}
}
Terminal Operations#
Terminal operations consume the stream and produce a result.
Basic Terminal Operations#
import java.util.*;
import java.util.stream.*;
public class TerminalOperations {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// forEach
System.out.println("All numbers:");
numbers.stream().forEach(System.out::println);
// count
long count = numbers.stream()
.filter(n -> n % 2 == 0)
.count();
System.out.println("Count of even numbers: " + count);
// collect to List
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println("Even numbers: " + evenNumbers);
// collect to Set
Set<Integer> oddNumbers = numbers.stream()
.filter(n -> n % 2 == 1)
.collect(Collectors.toSet());
System.out.println("Odd numbers: " + oddNumbers);
// toArray
Integer[] array = numbers.stream()
.filter(n -> n > 5)
.toArray(Integer[]::new);
System.out.println("Numbers > 5: " + Arrays.toString(array));
// reduce - sum
Optional<Integer> sum = numbers.stream().reduce((a, b) -> a + b);
System.out.println("Sum: " + sum.orElse(0));
// reduce with identity
Integer sumWithIdentity = numbers.stream().reduce(0, (a, b) -> a + b);
System.out.println("Sum with identity: " + sumWithIdentity);
// reduce - product
Integer product = numbers.stream().reduce(1, (a, b) -> a * b);
System.out.println("Product: " + product);
// reduce - find maximum
Optional<Integer> max = numbers.stream().reduce(Integer::max);
System.out.println("Maximum: " + max.orElse(0));
// min and max methods
Optional<Integer> min = numbers.stream().min(Integer::compareTo);
Optional<Integer> max2 = numbers.stream().max(Integer::compareTo);
System.out.println("Min: " + min.orElse(0) + ", Max: " + max2.orElse(0));
List<String> words = Arrays.asList("apple", "banana", "cherry", "date");
// findFirst
Optional<String> firstLongWord = words.stream()
.filter(word -> word.length() > 5)
.findFirst();
System.out.println("First long word: " + firstLongWord.orElse("none"));
// findAny
Optional<String> anyLongWord = words.stream()
.filter(word -> word.length() > 5)
.findAny();
System.out.println("Any long word: " + anyLongWord.orElse("none"));
// anyMatch, allMatch, noneMatch
boolean anyLong = words.stream().anyMatch(word -> word.length() > 5);
boolean allShort = words.stream().allMatch(word -> word.length() < 10);
boolean noneEmpty = words.stream().noneMatch(String::isEmpty);
System.out.println("Any long word: " + anyLong);
System.out.println("All short words: " + allShort);
System.out.println("No empty words: " + noneEmpty);
}
}
Advanced Terminal Operations#
Working with Primitive Streams#
import java.util.*;
import java.util.stream.*;
public class PrimitiveStreams {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// mapToInt, mapToLong, mapToDouble
IntStream intStream = numbers.stream().mapToInt(Integer::intValue);
// Statistical operations on IntStream
IntSummaryStatistics stats = numbers.stream()
.mapToInt(Integer::intValue)
.summaryStatistics();
System.out.println("Statistics for numbers 1-10:");
System.out.println("Count: " + stats.getCount());
System.out.println("Sum: " + stats.getSum());
System.out.println("Min: " + stats.getMin());
System.out.println("Max: " + stats.getMax());
System.out.println("Average: " + stats.getAverage());
// Sum, average, min, max on primitive streams
int sum = numbers.stream().mapToInt(Integer::intValue).sum();
OptionalDouble average = numbers.stream().mapToInt(Integer::intValue).average();
OptionalInt min = numbers.stream().mapToInt(Integer::intValue).min();
OptionalInt max = numbers.stream().mapToInt(Integer::intValue).max();
System.out.println("\nDirect operations:");
System.out.println("Sum: " + sum);
System.out.println("Average: " + average.orElse(0));
System.out.println("Min: " + min.orElse(0));
System.out.println("Max: " + max.orElse(0));
// Working with doubles
List<Double> prices = Arrays.asList(19.99, 29.99, 39.99, 49.99, 59.99);
DoubleSummaryStatistics priceStats = prices.stream()
.mapToDouble(Double::doubleValue)
.summaryStatistics();
System.out.println("\nPrice statistics:");
System.out.println("Count: " + priceStats.getCount());
System.out.println("Sum: $" + String.format("%.2f", priceStats.getSum()));
System.out.println("Average: $" + String.format("%.2f", priceStats.getAverage()));
System.out.println("Min: $" + String.format("%.2f", priceStats.getMin()));
System.out.println("Max: $" + String.format("%.2f", priceStats.getMax()));
// Range operations
System.out.println("\nSquares of numbers 1-10:");
IntStream.rangeClosed(1, 10)
.map(n -> n * n)
.forEach(n -> System.out.print(n + " "));
System.out.println();
// Generate Fibonacci sequence
System.out.println("\nFirst 10 Fibonacci numbers:");
Stream.iterate(new int[]{0, 1}, fib -> new int[]{fib[1], fib[0] + fib[1]})
.limit(10)
.mapToInt(fib -> fib[0])
.forEach(n -> System.out.print(n + " "));
System.out.println();
// Working with random numbers
System.out.println("\n5 random numbers between 1-100:");
new Random().ints(5, 1, 101)
.forEach(n -> System.out.print(n + " "));
System.out.println();
// Box primitive stream back to object stream
List<Integer> boxedNumbers = IntStream.rangeClosed(1, 5)
.boxed()
.collect(Collectors.toList());
System.out.println("\nBoxed numbers: " + boxedNumbers);
}
}
Collectors#
Collectors provide a way to accumulate stream elements into collections or other results.
Basic Collectors#
import java.util.*;
import java.util.stream.*;
public class BasicCollectors {
static class Employee {
private String name;
private String department;
private double salary;
private int age;
public Employee(String name, String department, double salary, int age) {
this.name = name;
this.department = department;
this.salary = salary;
this.age = age;
}
// Getters
public String getName() { return name; }
public String getDepartment() { return department; }
public double getSalary() { return salary; }
public int getAge() { return age; }
@Override
public String toString() {
return String.format("Employee{name='%s', dept='%s', salary=%.2f, age=%d}",
name, department, salary, age);
}
}
public static void main(String[] args) {
List<Employee> employees = Arrays.asList(
new Employee("Alice", "Engineering", 75000, 25),
new Employee("Bob", "Engineering", 80000, 30),
new Employee("Charlie", "Sales", 65000, 35),
new Employee("Diana", "Sales", 70000, 28),
new Employee("Eve", "Marketing", 72000, 32),
new Employee("Frank", "Engineering", 85000, 29)
);
System.out.println("All employees:");
employees.forEach(System.out::println);
// Collect to List
List<String> names = employees.stream()
.map(Employee::getName)
.collect(Collectors.toList());
System.out.println("\nNames: " + names);
// Collect to Set
Set<String> departments = employees.stream()
.map(Employee::getDepartment)
.collect(Collectors.toSet());
System.out.println("Departments: " + departments);
// Collect to specific collection type
LinkedList<String> linkedNames = employees.stream()
.map(Employee::getName)
.collect(Collectors.toCollection(LinkedList::new));
System.out.println("LinkedList names: " + linkedNames);
// Collect to array
String[] nameArray = employees.stream()
.map(Employee::getName)
.toArray(String[]::new);
System.out.println("Name array: " + Arrays.toString(nameArray));
// Joining
String allNames = employees.stream()
.map(Employee::getName)
.collect(Collectors.joining(", "));
System.out.println("All names joined: " + allNames);
String namesWithPrefix = employees.stream()
.map(Employee::getName)
.collect(Collectors.joining(", ", "Employees: [", "]"));
System.out.println("Names with prefix/suffix: " + namesWithPrefix);
// Counting
long count = employees.stream()
.filter(emp -> emp.getSalary() > 70000)
.collect(Collectors.counting());
System.out.println("High salary employees count: " + count);
// Summarizing
DoubleSummaryStatistics salaryStats = employees.stream()
.collect(Collectors.summarizingDouble(Employee::getSalary));
System.out.println("\nSalary statistics:");
System.out.println("Count: " + salaryStats.getCount());
System.out.println("Sum: $" + String.format("%.2f", salaryStats.getSum()));
System.out.println("Average: $" + String.format("%.2f", salaryStats.getAverage()));
System.out.println("Min: $" + String.format("%.2f", salaryStats.getMin()));
System.out.println("Max: $" + String.format("%.2f", salaryStats.getMax()));
// Averaging
OptionalDouble averageSalary = employees.stream()
.mapToDouble(Employee::getSalary)
.average();
System.out.println("Average salary: $" +
String.format("%.2f", averageSalary.orElse(0)));
// Min and Max with Collectors
Optional<Employee> youngestEmployee = employees.stream()
.collect(Collectors.minBy(Comparator.comparing(Employee::getAge)));
Optional<Employee> highestPaid = employees.stream()
.collect(Collectors.maxBy(Comparator.comparing(Employee::getSalary)));
System.out.println("Youngest employee: " + youngestEmployee.orElse(null));
System.out.println("Highest paid employee: " + highestPaid.orElse(null));
}
}
Advanced Collectors#
Grouping and Partitioning#
import java.util.*;
import java.util.stream.*;
public class AdvancedCollectors {
static class Employee {
private String name;
private String department;
private double salary;
private int age;
public Employee(String name, String department, double salary, int age) {
this.name = name;
this.department = department;
this.salary = salary;
this.age = age;
}
public String getName() { return name; }
public String getDepartment() { return department; }
public double getSalary() { return salary; }
public int getAge() { return age; }
@Override
public String toString() {
return String.format("Employee{name='%s', dept='%s', salary=%.2f, age=%d}",
name, department, salary, age);
}
}
public static void main(String[] args) {
List<Employee> employees = Arrays.asList(
new Employee("Alice", "Engineering", 75000, 25),
new Employee("Bob", "Engineering", 80000, 30),
new Employee("Charlie", "Sales", 65000, 35),
new Employee("Diana", "Sales", 70000, 28),
new Employee("Eve", "Marketing", 72000, 32),
new Employee("Frank", "Engineering", 85000, 29),
new Employee("Grace", "Marketing", 68000, 26),
new Employee("Henry", "Sales", 73000, 31)
);
// Group by department
Map<String, List<Employee>> byDepartment = employees.stream()
.collect(Collectors.groupingBy(Employee::getDepartment));
System.out.println("Employees by department:");
byDepartment.forEach((dept, empList) -> {
System.out.println(dept + ":");
empList.forEach(emp -> System.out.println(" " + emp));
});
// Group by salary range
Map<String, List<Employee>> bySalaryRange = employees.stream()
.collect(Collectors.groupingBy(emp -> {
double salary = emp.getSalary();
if (salary < 70000) return "Low";
else if (salary < 80000) return "Medium";
else return "High";
}));
System.out.println("\nEmployees by salary range:");
bySalaryRange.forEach((range, empList) -> {
System.out.println(range + " salary:");
empList.forEach(emp -> System.out.println(" " + emp));
});
// Count by department
Map<String, Long> countByDepartment = employees.stream()
.collect(Collectors.groupingBy(
Employee::getDepartment,
Collectors.counting()
));
System.out.println("\nEmployee count by department:");
countByDepartment.forEach((dept, count) ->
System.out.println(dept + ": " + count));
// Average salary by department
Map<String, Double> avgSalaryByDept = employees.stream()
.collect(Collectors.groupingBy(
Employee::getDepartment,
Collectors.averagingDouble(Employee::getSalary)
));
System.out.println("\nAverage salary by department:");
avgSalaryByDept.forEach((dept, avgSalary) ->
System.out.println(dept + ": $" + String.format("%.2f", avgSalary)));
// Sum salary by department
Map<String, Double> totalSalaryByDept = employees.stream()
.collect(Collectors.groupingBy(
Employee::getDepartment,
Collectors.summingDouble(Employee::getSalary)
));
System.out.println("\nTotal salary by department:");
totalSalaryByDept.forEach((dept, total) ->
System.out.println(dept + ": $" + String.format("%.2f", total)));
// Partitioning by condition
Map<Boolean, List<Employee>> partitionByAge = employees.stream()
.collect(Collectors.partitioningBy(emp -> emp.getAge() >= 30));
System.out.println("\nEmployees partitioned by age >= 30:");
System.out.println("Age >= 30:");
partitionByAge.get(true).forEach(emp -> System.out.println(" " + emp));
System.out.println("Age < 30:");
partitionByAge.get(false).forEach(emp -> System.out.println(" " + emp));
// Partition and count
Map<Boolean, Long> partitionCount = employees.stream()
.collect(Collectors.partitioningBy(
emp -> emp.getSalary() > 70000,
Collectors.counting()
));
System.out.println("\nEmployee count by salary > 70000:");
System.out.println("High salary (>70k): " + partitionCount.get(true));
System.out.println("Low salary (<=70k): " + partitionCount.get(false));
// Nested grouping - by department then by age group
Map<String, Map<String, List<Employee>>> nestedGrouping = employees.stream()
.collect(Collectors.groupingBy(
Employee::getDepartment,
Collectors.groupingBy(emp -> emp.getAge() < 30 ? "Young" : "Senior")
));
System.out.println("\nNested grouping (Department -> Age Group):");
nestedGrouping.forEach((dept, ageGroups) -> {
System.out.println(dept + ":");
ageGroups.forEach((ageGroup, empList) -> {
System.out.println(" " + ageGroup + ":");
empList.forEach(emp -> System.out.println(" " + emp));
});
});
}
}
Custom Collectors#
Creating your own collectors for specific use cases.
import java.util.*;
import java.util.function.*;
import java.util.stream.*;
public class CustomCollectors {
// Custom collector to collect to a specific string format
public static Collector<String, ?, String> toFormattedString(String delimiter, String prefix, String suffix) {
return Collector.of(
StringBuilder::new, // supplier
(sb, str) -> sb.append(str).append(delimiter), // accumulator
(sb1, sb2) -> sb1.append(sb2), // combiner
sb -> { // finisher
if (sb.length() > 0) {
sb.setLength(sb.length() - delimiter.length()); // remove last delimiter
}
return prefix + sb.toString() + suffix;
}
);
}
// Custom collector to collect statistics
public static <T> Collector<T, ?, Statistics<T>> toStatistics(Function<T, Double> mapper) {
return Collector.of(
Statistics::new, // supplier
(stats, item) -> stats.add(mapper.apply(item)), // accumulator
Statistics::combine, // combiner
Function.identity() // finisher
);
}
// Custom collector to collect to immutable list
public static <T> Collector<T, ?, List<T>> toImmutableList() {
return Collector.of(
ArrayList::new, // supplier
ArrayList::add, // accumulator
(list1, list2) -> { list1.addAll(list2); return list1; }, // combiner
Collections::unmodifiableList // finisher
);
}
// Custom collector to collect unique elements by a key function
public static <T, K> Collector<T, ?, List<T>> uniqueBy(Function<T, K> keyExtractor) {
return Collector.of(
() -> new LinkedHashMap<K, T>(), // supplier
(map, item) -> map.putIfAbsent(keyExtractor.apply(item), item), // accumulator
(map1, map2) -> { map2.forEach(map1::putIfAbsent); return map1; }, // combiner
map -> new ArrayList<>(map.values()) // finisher
);
}
static class Statistics<T> {
private long count = 0;
private double sum = 0;
private double min = Double.MAX_VALUE;
private double max = Double.MIN_VALUE;
public void add(double value) {
count++;
sum += value;
min = Math.min(min, value);
max = Math.max(max, value);
}
public Statistics<T> combine(Statistics<T> other) {
count += other.count;
sum += other.sum;
min = Math.min(min, other.min);
max = Math.max(max, other.max);
return this;
}
public long getCount() { return count; }
public double getSum() { return sum; }
public double getAverage() { return count > 0 ? sum / count : 0; }
public double getMin() { return min; }
public double getMax() { return max; }
@Override
public String toString() {
return String.format("Statistics{count=%d, sum=%.2f, avg=%.2f, min=%.2f, max=%.2f}",
count, sum, getAverage(), min, max);
}
}
static class Product {
private String name;
private String category;
private double price;
public Product(String name, String category, double price) {
this.name = name;
this.category = category;
this.price = price;
}
public String getName() { return name; }
public String getCategory() { return category; }
public double getPrice() { return price; }
@Override
public String toString() {
return String.format("Product{name='%s', category='%s', price=%.2f}", name, category, price);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Product)) return false;
Product product = (Product) o;
return Objects.equals(name, product.name) && Objects.equals(category, product.category);
}
@Override
public int hashCode() {
return Objects.hash(name, category);
}
}
public static void main(String[] args) {
List<String> words = Arrays.asList("Java", "Python", "JavaScript", "Ruby", "Go");
// Using custom formatted string collector
String formatted = words.stream()
.collect(toFormattedString(", ", "Languages: [", "]"));
System.out.println("Formatted string: " + formatted);
List<Product> products = Arrays.asList(
new Product("Laptop", "Electronics", 999.99),
new Product("Mouse", "Electronics", 29.99),
new Product("Keyboard", "Electronics", 79.99),
new Product("Desk", "Furniture", 299.99),
new Product("Chair", "Furniture", 199.99),
new Product("Laptop", "Electronics", 1299.99), // Duplicate name/category
new Product("Monitor", "Electronics", 349.99)
);
// Using custom statistics collector
Statistics<Product> priceStats = products.stream()
.collect(toStatistics(Product::getPrice));
System.out.println("Price statistics: " + priceStats);
// Using immutable list collector
List<String> immutableCategories = products.stream()
.map(Product::getCategory)
.distinct()
.collect(toImmutableList());
System.out.println("Immutable categories: " + immutableCategories);
// Try to modify (will throw UnsupportedOperationException)
try {
immutableCategories.add("New Category");
} catch (UnsupportedOperationException e) {
System.out.println("Cannot modify immutable list: " + e.getMessage());
}
// Using unique by collector
List<Product> uniqueProducts = products.stream()
.collect(uniqueBy(p -> p.getName() + p.getCategory()));
System.out.println("\nUnique products (by name and category):");
uniqueProducts.forEach(System.out::println);
// Complex custom collector - most expensive product by category
Map<String, Optional<Product>> mostExpensiveByCategory = products.stream()
.collect(Collectors.groupingBy(
Product::getCategory,
Collector.of(
() -> Optional.<Product>empty(),
(opt, product) -> opt.map(p -> p.getPrice() > product.getPrice() ? p : product)
.or(() -> Optional.of(product)),
(opt1, opt2) -> opt1.flatMap(p1 -> opt2.map(p2 -> p1.getPrice() > p2.getPrice() ? p1 : p2))
.or(() -> opt1.or(() -> opt2))
)
));
System.out.println("\nMost expensive product by category:");
mostExpensiveByCategory.forEach((category, product) ->
System.out.println(category + ": " + product.orElse(null)));
}
}
Parallel Streams#
Parallel streams can improve performance for CPU-intensive operations on large datasets.
import java.util.*;
import java.util.stream.*;
import java.time.Instant;
import java.time.Duration;
public class ParallelStreams {
public static void measureTime(String description, Runnable operation) {
Instant start = Instant.now();
operation.run();
Instant end = Instant.now();
Duration duration = Duration.between(start, end);
System.out.println(description + ": " + duration.toMillis() + "ms");
}
// CPU-intensive operation for demonstration
public static boolean isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0) return false;
}
return true;
}
public static void main(String[] args) {
// Create a large dataset
List<Integer> numbers = IntStream.rangeClosed(1, 100000)
.boxed()
.collect(Collectors.toList());
System.out.println("Processing " + numbers.size() + " numbers\n");
// Sequential processing
measureTime("Sequential sum", () -> {
long sum = numbers.stream()
.mapToLong(Integer::longValue)
.sum();
});
// Parallel processing
measureTime("Parallel sum", () -> {
long sum = numbers.parallelStream()
.mapToLong(Integer::longValue)
.sum();
});
// More CPU-intensive operation - finding prime numbers
List<Integer> testNumbers = IntStream.rangeClosed(1, 10000)
.boxed()
.collect(Collectors.toList());
System.out.println("\nFinding prime numbers up to 10000:");
measureTime("Sequential prime check", () -> {
List<Integer> primes = testNumbers.stream()
.filter(ParallelStreams::isPrime)
.collect(Collectors.toList());
System.out.println(" Found " + primes.size() + " primes");
});
measureTime("Parallel prime check", () -> {
List<Integer> primes = testNumbers.parallelStream()
.filter(ParallelStreams::isPrime)
.collect(Collectors.toList());
System.out.println(" Found " + primes.size() + " primes");
});
// Demonstrating parallel processing characteristics
System.out.println("\nParallel processing characteristics:");
// Check available processors
int processors = Runtime.getRuntime().availableProcessors();
System.out.println("Available processors: " + processors);
// Show which threads are used in parallel processing
Set<String> threadNames = new HashSet<>();
numbers.parallelStream()
.limit(20)
.forEach(n -> threadNames.add(Thread.currentThread().getName()));
System.out.println("Threads used in parallel processing:");
threadNames.forEach(name -> System.out.println(" " + name));
// Order considerations in parallel streams
System.out.println("\nOrder considerations:");
List<Integer> smallNumbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println("Sequential processing (ordered):");
smallNumbers.stream()
.map(n -> n * 2)
.forEach(n -> System.out.print(n + " "));
System.out.println();
System.out.println("Parallel processing (potentially unordered):");
smallNumbers.parallelStream()
.map(n -> n * 2)
.forEach(n -> System.out.print(n + " "));
System.out.println();
System.out.println("Parallel processing with forEachOrdered (ordered):");
smallNumbers.parallelStream()
.map(n -> n * 2)
.forEachOrdered(n -> System.out.print(n + " "));
System.out.println();
// When parallel streams might not help
System.out.println("\nWhen parallel streams might not be beneficial:");
List<String> words = Arrays.asList("Java", "Python", "JavaScript", "C++", "Ruby");
measureTime("Sequential simple operation", () -> {
List<String> upper = words.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
});
measureTime("Parallel simple operation", () -> {
List<String> upper = words.parallelStream()
.map(String::toUpperCase)
.collect(Collectors.toList());
});
// Reduce operations in parallel
System.out.println("\nReduce operations:");
Integer sequentialSum = numbers.stream()
.limit(1000)
.reduce(0, Integer::sum);
Integer parallelSum = numbers.parallelStream()
.limit(1000)
.reduce(0, Integer::sum);
System.out.println("Sequential sum: " + sequentialSum);
System.out.println("Parallel sum: " + parallelSum);
// Parallel reduce with combiner
Integer parallelSumWithCombiner = numbers.parallelStream()
.limit(1000)
.reduce(0,
Integer::sum, // accumulator
Integer::sum); // combiner
System.out.println("Parallel sum with combiner: " + parallelSumWithCombiner);
}
}
Stream Performance and Best Practices#
import java.util.*;
import java.util.stream.*;
import java.time.Instant;
import java.time.Duration;
public class StreamPerformance {
public static void measureTime(String description, Runnable operation) {
Instant start = Instant.now();
operation.run();
Instant end = Instant.now();
Duration duration = Duration.between(start, end);
System.out.println(description + ": " + duration.toMillis() + "ms");
}
public static void main(String[] args) {
List<Integer> largeList = IntStream.rangeClosed(1, 1_000_000)
.boxed()
.collect(Collectors.toList());
System.out.println("Performance comparison on " + largeList.size() + " elements:\n");
// 1. Stream vs Traditional Loop
measureTime("Traditional for-each loop", () -> {
List<Integer> result = new ArrayList<>();
for (Integer n : largeList) {
if (n % 2 == 0) {
result.add(n * n);
}
}
});
measureTime("Stream operations", () -> {
List<Integer> result = largeList.stream()
.filter(n -> n % 2 == 0)
.map(n -> n * n)
.collect(Collectors.toList());
});
measureTime("Parallel stream", () -> {
List<Integer> result = largeList.parallelStream()
.filter(n -> n % 2 == 0)
.map(n -> n * n)
.collect(Collectors.toList());
});
// 2. Short-circuiting operations
System.out.println("\nShort-circuiting benefits:");
measureTime("findFirst (short-circuit)", () -> {
Optional<Integer> result = largeList.stream()
.filter(n -> n > 500_000)
.findFirst();
});
measureTime("collect all (no short-circuit)", () -> {
List<Integer> result = largeList.stream()
.filter(n -> n > 500_000)
.collect(Collectors.toList());
});
// 3. Primitive streams vs boxed streams
System.out.println("\nPrimitive vs Boxed streams:");
measureTime("IntStream (primitive)", () -> {
long sum = IntStream.rangeClosed(1, 1_000_000)
.filter(n -> n % 2 == 0)
.sum();
});
measureTime("Stream<Integer> (boxed)", () -> {
Integer sum = IntStream.rangeClosed(1, 1_000_000)
.boxed()
.filter(n -> n % 2 == 0)
.reduce(0, Integer::sum);
});
// 4. Lazy evaluation demonstration
System.out.println("\nLazy evaluation:");
System.out.println("Creating stream with side effects:");
Stream<Integer> stream = Arrays.asList(1, 2, 3, 4, 5).stream()
.peek(n -> System.out.println("Processing: " + n))
.filter(n -> n % 2 == 0)
.peek(n -> System.out.println("Filtered: " + n))
.map(n -> n * n)
.peek(n -> System.out.println("Mapped: " + n));
System.out.println("Stream created, but no operations executed yet");
System.out.println("Now executing terminal operation:");
List<Integer> result = stream.collect(Collectors.toList());
System.out.println("Result: " + result);
// 5. Best practices
System.out.println("\nBest Practices:");
// Avoid side effects in lambda expressions
List<String> words = Arrays.asList("Java", "Python", "JavaScript", "Ruby");
// Bad: side effects
List<String> sideEffectList = new ArrayList<>();
words.stream()
.filter(word -> word.length() > 4)
.forEach(sideEffectList::add); // Side effect - modifying external state
// Good: functional approach
List<String> functionalResult = words.stream()
.filter(word -> word.length() > 4)
.collect(Collectors.toList());
System.out.println("Side effect result: " + sideEffectList);
System.out.println("Functional result: " + functionalResult);
// Keep lambda expressions simple
List<String> complexWords = Arrays.asList("hello", "world", "java", "stream");
// Bad: complex lambda
List<String> complexResult = complexWords.stream()
.filter(word -> {
boolean startsWithVowel = "aeiouAEIOU".indexOf(word.charAt(0)) != -1;
boolean longerThan4 = word.length() > 4;
boolean containsA = word.contains("a");
return startsWithVowel || (longerThan4 && containsA);
})
.collect(Collectors.toList());
// Better: extract to method
List<String> betterResult = complexWords.stream()
.filter(StreamPerformance::isComplexMatch)
.collect(Collectors.toList());
System.out.println("Complex filter result: " + betterResult);
// Use appropriate collectors
System.out.println("\nCollector performance:");
measureTime("Collect to ArrayList", () -> {
List<Integer> result_list = largeList.stream()
.filter(n -> n % 100 == 0)
.collect(Collectors.toList());
});
measureTime("Collect to specific collection", () -> {
ArrayList<Integer> result_arraylist = largeList.stream()
.filter(n -> n % 100 == 0)
.collect(Collectors.toCollection(ArrayList::new));
});
measureTime("Collect to array", () -> {
Integer[] resultArray = largeList.stream()
.filter(n -> n % 100 == 0)
.toArray(Integer[]::new);
});
}
private static boolean isComplexMatch(String word) {
boolean startsWithVowel = "aeiouAEIOU".indexOf(word.charAt(0)) != -1;
boolean longerThan4 = word.length() > 4;
boolean containsA = word.contains("a");
return startsWithVowel || (longerThan4 && containsA);
}
// Guidelines for when to use parallel streams
public static void parallelStreamGuidelines() {
System.out.println("\nParallel Stream Guidelines:");
System.out.println("Use parallel streams when:");
System.out.println("1. Large amount of data (>10,000 elements typically)");
System.out.println("2. CPU-intensive operations");
System.out.println("3. Operations are stateless and don't depend on order");
System.out.println("4. No shared mutable state");
System.out.println("\nAvoid parallel streams when:");
System.out.println("1. Small datasets");
System.out.println("2. I/O bound operations");
System.out.println("3. Operations have side effects");
System.out.println("4. Order matters and can't use forEachOrdered");
}
}
Hands-on Exercise 1: Student Management System#
Create a comprehensive student management system using Stream API:
import java.util.*;
import java.util.stream.*;
// Student class
class Student {
private String name;
private int age;
private String major;
private double gpa;
private List<String> courses;
public Student(String name, int age, String major, double gpa, List<String> courses) {
this.name = name;
this.age = age;
this.major = major;
this.gpa = gpa;
this.courses = courses;
}
// Getters
public String getName() { return name; }
public int getAge() { return age; }
public String getMajor() { return major; }
public double getGpa() { return gpa; }
public List<String> getCourses() { return courses; }
@Override
public String toString() {
return String.format("Student{name='%s', age=%d, major='%s', gpa=%.2f}", name, age, major, gpa);
}
}
public class StudentManagementSystem {
public static void main(String[] args) {
List<Student> students = Arrays.asList(
new Student("Alice", 20, "Computer Science", 3.8, Arrays.asList("Java", "Database", "Algorithms")),
new Student("Bob", 21, "Computer Science", 3.2, Arrays.asList("Java", "Web Development")),
new Student("Charlie", 22, "Mathematics", 3.9, Arrays.asList("Calculus", "Statistics", "Linear Algebra")),
new Student("Diana", 19, "Physics", 3.7, Arrays.asList("Mechanics", "Thermodynamics")),
new Student("Eve", 23, "Computer Science", 3.5, Arrays.asList("Database", "Machine Learning", "AI")),
new Student("Frank", 20, "Mathematics", 3.6, Arrays.asList("Calculus", "Discrete Math"))
);
// TODO: Implement the following using Stream API:
// 1. Find all Computer Science students with GPA > 3.5
System.out.println("1. CS students with GPA > 3.5:");
// Your implementation here
// 2. Get average GPA by major
System.out.println("\n2. Average GPA by major:");
// Your implementation here
// 3. Find the oldest student in each major
System.out.println("\n3. Oldest student in each major:");
// Your implementation here
// 4. Get all unique courses being taken by students
System.out.println("\n4. All unique courses:");
// Your implementation here
// 5. Count students by age group (18-20, 21-23, 24+)
System.out.println("\n5. Students by age group:");
// Your implementation here
// 6. Find students taking more than 2 courses
System.out.println("\n6. Students taking more than 2 courses:");
// Your implementation here
// 7. Get top 3 students by GPA
System.out.println("\n7. Top 3 students by GPA:");
// Your implementation here
// 8. Create a summary report
System.out.println("\n8. Summary report:");
// Your implementation here
}
}
Hands-on Exercise 2: E-commerce Data Analysis#
Create an e-commerce data analysis system:
import java.util.*;
import java.util.stream.*;
import java.time.LocalDate;
class Product {
private String id;
private String name;
private String category;
private double price;
public Product(String id, String name, String category, double price) {
this.id = id;
this.name = name;
this.category = category;
this.price = price;
}
// Getters
public String getId() { return id; }
public String getName() { return name; }
public String getCategory() { return category; }
public double getPrice() { return price; }
@Override
public String toString() {
return String.format("Product{id='%s', name='%s', category='%s', price=%.2f}", id, name, category, price);
}
}
class Order {
private String orderId;
private String customerId;
private LocalDate orderDate;
private List<OrderItem> items;
public Order(String orderId, String customerId, LocalDate orderDate, List<OrderItem> items) {
this.orderId = orderId;
this.customerId = customerId;
this.orderDate = orderDate;
this.items = items;
}
public String getOrderId() { return orderId; }
public String getCustomerId() { return customerId; }
public LocalDate getOrderDate() { return orderDate; }
public List<OrderItem> getItems() { return items; }
public double getTotalAmount() {
return items.stream().mapToDouble(OrderItem::getSubtotal).sum();
}
}
class OrderItem {
private Product product;
private int quantity;
public OrderItem(Product product, int quantity) {
this.product = product;
this.quantity = quantity;
}
public Product getProduct() { return product; }
public int getQuantity() { return quantity; }
public double getSubtotal() { return product.getPrice() * quantity; }
}
public class ECommerceAnalysis {
public static void main(String[] args) {
// Sample data setup
List<Product> products = Arrays.asList(
new Product("P1", "Laptop", "Electronics", 999.99),
new Product("P2", "Mouse", "Electronics", 29.99),
new Product("P3", "Keyboard", "Electronics", 79.99),
new Product("P4", "Monitor", "Electronics", 299.99),
new Product("P5", "Chair", "Furniture", 199.99),
new Product("P6", "Desk", "Furniture", 399.99),
new Product("P7", "Book", "Books", 19.99),
new Product("P8", "Pen", "Stationery", 4.99)
);
List<Order> orders = Arrays.asList(
new Order("O1", "C1", LocalDate.of(2024, 1, 15), Arrays.asList(
new OrderItem(products.get(0), 1), new OrderItem(products.get(1), 2)
)),
new Order("O2", "C2", LocalDate.of(2024, 1, 20), Arrays.asList(
new OrderItem(products.get(2), 1), new OrderItem(products.get(3), 1)
)),
new Order("O3", "C1", LocalDate.of(2024, 2, 5), Arrays.asList(
new OrderItem(products.get(4), 1), new OrderItem(products.get(5), 1)
))
);
// TODO: Implement the following analyses:
// 1. Total revenue by category
System.out.println("1. Total revenue by category:");
// Your implementation here
// 2. Most popular products (by quantity sold)
System.out.println("\n2. Most popular products:");
// Your implementation here
// 3. Average order value by customer
System.out.println("\n3. Average order value by customer:");
// Your implementation here
// 4. Monthly sales summary
System.out.println("\n4. Monthly sales summary:");
// Your implementation here
// 5. Products never ordered
System.out.println("\n5. Products never ordered:");
// Your implementation here
}
}
Exercise Solutions: Student Management System#
public class StudentManagementSystemSolution {
public static void main(String[] args) {
// ... (same student data as above)
// 1. CS students with GPA > 3.5
List<Student> csHighGpa = students.stream()
.filter(s -> "Computer Science".equals(s.getMajor()))
.filter(s -> s.getGpa() > 3.5)
.collect(Collectors.toList());
csHighGpa.forEach(System.out::println);
// 2. Average GPA by major
Map<String, Double> avgGpaByMajor = students.stream()
.collect(Collectors.groupingBy(
Student::getMajor,
Collectors.averagingDouble(Student::getGpa)
));
avgGpaByMajor.forEach((major, avg) ->
System.out.println(major + ": " + String.format("%.2f", avg)));
// 3. Oldest student in each major
Map<String, Optional<Student>> oldestByMajor = students.stream()
.collect(Collectors.groupingBy(
Student::getMajor,
Collectors.maxBy(Comparator.comparing(Student::getAge))
));
oldestByMajor.forEach((major, student) ->
System.out.println(major + ": " + student.orElse(null)));
// 4. All unique courses
Set<String> uniqueCourses = students.stream()
.flatMap(s -> s.getCourses().stream())
.collect(Collectors.toSet());
System.out.println(uniqueCourses);
// 5. Students by age group
Map<String, Long> studentsByAgeGroup = students.stream()
.collect(Collectors.groupingBy(
s -> {
int age = s.getAge();
if (age <= 20) return "18-20";
else if (age <= 23) return "21-23";
else return "24+";
},
Collectors.counting()
));
studentsByAgeGroup.forEach((group, count) ->
System.out.println(group + ": " + count));
// 6. Students taking more than 2 courses
List<Student> activeStudents = students.stream()
.filter(s -> s.getCourses().size() > 2)
.collect(Collectors.toList());
activeStudents.forEach(System.out::println);
// 7. Top 3 students by GPA
List<Student> top3Students = students.stream()
.sorted(Comparator.comparing(Student::getGpa).reversed())
.limit(3)
.collect(Collectors.toList());
top3Students.forEach(System.out::println);
// 8. Summary report
DoubleSummaryStatistics gpaStats = students.stream()
.mapToDouble(Student::getGpa)
.summaryStatistics();
System.out.println("Total students: " + students.size());
System.out.println("Average GPA: " + String.format("%.2f", gpaStats.getAverage()));
System.out.println("Highest GPA: " + gpaStats.getMax());
System.out.println("Lowest GPA: " + gpaStats.getMin());
System.out.println("Total unique courses: " + uniqueCourses.size());
}
}
Summary#
Key Concepts Covered#
- Stream Creation: Various ways to create streams from different data sources
- Intermediate Operations: filter, map, sorted, distinct, limit, skip, flatMap
- Terminal Operations: collect, forEach, reduce, find operations, match operations
- Collectors: Built-in collectors for common aggregation operations
- Custom Collectors: Creating specialized collectors for specific use cases
- Parallel Streams: Leveraging multiple cores for performance
- Performance Considerations: When and how to optimize stream operations
Benefits of Stream API#
- Functional Style: More expressive and readable code
- Lazy Evaluation: Operations are optimized and executed only when needed
- Composability: Operations can be easily chained and combined
- Parallelization: Easy to leverage multiple cores
- Integration: Works seamlessly with collections and other Java APIs
Best Practices#
- Keep lambda expressions simple and readable
- Avoid side effects in stream operations
- Use appropriate collectors for better performance
- Consider parallel streams for CPU-intensive operations on large datasets
- Prefer primitive streams for numerical operations
Next Lecture Preview#
Lecture 41: JavaFX Basics and GUI Programming#
- Introduction to JavaFX
- Scene Graph and Application Structure
- Creating User Interfaces with FXML
- Event Handling and Controls
- Layouts and Styling with CSS
- Building Desktop Applications
Preparation#
- Ensure JavaFX is available in your development environment
- Review event-driven programming concepts
- Practice with lambda expressions for event handling
Thank You!#
Questions and Discussion#
- How do streams improve code readability and maintainability?
- When would you choose parallel streams over sequential streams?
- What are the trade-offs between streams and traditional loops?
Resources for Further Learning#
- Oracle Stream API Documentation
- Java 8 in Action by Raoul-Gabriel Urma
- Practice with real-world datasets and stream operations
Next: JavaFX and GUI Application Development