Java Streams

List<Integer> salaries = List.of(3000, 4000, 1000, 9000, 1000, 3500);

// Without Stream
int count = 0;
for (int salary : salaries) {
    if (salary > 3000) {
        count++;
    }
}
System.out.println(count);   // 3

// With Stream
long total = salaries.stream()
.filter(salary -> salary > 3000)
.count();
System.out.println(total);   // 3

import java.util.*;
import java.util.stream.*;

// 1. From a collection
Stream<Integer> s1 = List.of(1, 2, 3).stream();

// 2. From an array
int[] nums = {1, 2, 3, 4, 5};
IntStream s2 = Arrays.stream(nums);

String[] names = {"Akash", "Rahul", "Amit"};
Stream<String> s3 = Arrays.stream(names);

// 3. Stream.of()
Stream<Integer> s4 = Stream.of(1, 2, 3, 4, 5);

// 4. Stream.Builder
Stream.Builder<Integer> builder = Stream.builder();
builder.add(1);
builder.add(2);
builder.add(3);
Stream<Integer> s5 = builder.build();

// 5. Stream.iterate() with limit
Stream.iterate(1000, n -> n + 5000)
.limit(5)
.forEach(System.out::println);
// 1000, 6000, 11000, 16000, 21000

// 6. iterate with a stop condition (Java 9+)
Stream.iterate(1, n -> n <= 20, n -> n * 2)
.forEach(System.out::println);
// 1, 2, 4, 8, 16

List<Integer> result = List.of(1, 2, 3, 4, 5, 6).stream()
.filter(n -> n > 3)
.toList();

System.out.println(result);   // [4, 5, 6]

List<String> result = List.of("HELLO", "EVERYBODY", "JAVA").stream()
.map(String::toLowerCase)
.toList();

System.out.println(result);   // [hello, everybody, java]

List<List<String>> data = List.of(
    List.of("I", "love", "Java"),
    List.of("Streams", "are", "powerful")
);

List<String> result = data.stream()
.flatMap(List::stream)
.toList();

System.out.println(result);
// [I, love, Java, Streams, are, powerful]

List<Integer> result = List.of(1, 2, 2, 3, 3, 4, 4, 5).stream()
.distinct()
.toList();

System.out.println(result);   // [1, 2, 3, 4, 5]

List<Integer> numbers = List.of(5, 1, 9, 2, 4);

// Natural order
numbers.stream().sorted().toList();                        // [1, 2, 4, 5, 9]

// Descending
numbers.stream().sorted(Comparator.reverseOrder()).toList(); // [9, 5, 4, 2, 1]

// Custom: sort strings by length
List.of("banana", "kiwi", "apple").stream()
.sorted(Comparator.comparing(String::length))
.toList();                                             // [kiwi, apple, banana]

List<Integer> result = List.of(1, 2, 3, 4, 5).stream()
.filter(n -> n > 2)
.peek(n -> System.out.println("Passed filter: " + n))
.toList();

List<Integer> data = List.of(2, 1, 3, 4, 6);

data.stream().limit(3).toList();   // [2, 1, 3]  (first 3)
data.stream().skip(3).toList();    // [4, 6]     (skip first 3)

// Pagination: page 2, page size 2
data.stream().skip(2).limit(2).toList();   // [3, 4]

List<String> numbers = List.of("2", "1", "4", "7");

int[] arr = numbers.stream()
.mapToInt(Integer::parseInt)
.toArray();

int sum = IntStream.of(arr).sum();                       // 14
double avg = IntStream.of(arr).average().orElse(0);      // 3.5

IntStream.rangeClosed(1, 5).forEach(System.out::println); // 1 2 3 4 5

// Back to objects
Stream<Integer> boxed = IntStream.of(arr).boxed();

List<Integer> numbers = List.of(2, 1, 4, 7, 10);

// No terminal operation: NOTHING is printed
numbers.stream()
.filter(n -> n >= 3)
.peek(System.out::println);

// With a terminal operation: pipeline runs
long count = numbers.stream()
.filter(n -> n >= 3)
.peek(System.out::println)
.count();

// Output:
// 4
// 7
// 10

Stream.of(2, 1, 4, 7)
.filter(n -> {
        System.out.println("filter " + n);
        return n >= 3;
    })
.map(n -> {
        System.out.println("map " + n);
        return n * 10;
    })
.forEach(n -> System.out.println("result " + n));

// Output:
// filter 2
// filter 1
// filter 4
// map 4
// result 40
// filter 7
// map 7
// result 70

List<Integer> numbers = List.of(2, 1, 4, 7, 10);

// forEach
numbers.stream().filter(n -> n >= 3).forEach(System.out::println);   // 4 7 10

// toArray
Object[] a = numbers.stream().toArray();
Integer[] b = numbers.stream().toArray(Integer[]::new);   // typed array

// count
long count = numbers.stream().filter(n -> n >= 3).count();   // 3

List<Integer> numbers = List.of(2, 1, 4, 7, 10);

// 1. Without identity: returns Optional (stream might be empty)
Optional<Integer> sum1 = numbers.stream().reduce((a, b) -> a + b);
System.out.println(sum1.get());   // 24

// 2. With identity: returns a plain value (identity is the result for an empty stream)
int sum2 = numbers.stream().reduce(0, (a, b) -> a + b);
System.out.println(sum2);         // 24

// Method reference
int sum3 = numbers.stream().reduce(0, Integer::sum);

// Multiplication
int product = List.of(2, 1, 4).stream().reduce(1, (a, b) -> a * b);   // 8

import java.util.stream.Collectors;

List<String> names = List.of("Ravi", "Anita", "Kiran", "Amit", "Ravi");

// To List / Set
List<String> list = names.stream().collect(Collectors.toList());
Set<String> set   = names.stream().collect(Collectors.toSet());

// Joining into a String
String joined = names.stream().collect(Collectors.joining(", ", "[", "]"));
// [Ravi, Anita, Kiran, Amit, Ravi]

// To Map (keys must be unique, else IllegalStateException)
Map<String, Integer> lengths = names.stream().distinct()
.collect(Collectors.toMap(n -> n, String::length));

// Group by first letter
Map<Character, List<String>> byLetter = names.stream()
.collect(Collectors.groupingBy(n -> n.charAt(0)));
// {A=[Anita, Amit], K=[Kiran], R=[Ravi, Ravi]}

// Count per group
Map<String, Long> freq = names.stream()
.collect(Collectors.groupingBy(n -> n, Collectors.counting()));
// {Ravi=2, Anita=1, Kiran=1, Amit=1}

// Partition into two groups (true / false)
Map<Boolean, List<String>> parts = names.stream()
.collect(Collectors.partitioningBy(n -> n.length() > 4));

Optional<Integer> min = List.of(4, 7, 10).stream().min(Integer::compareTo);
Optional<Integer> max = List.of(4, 7, 10).stream().max(Integer::compareTo);

System.out.println(min.get());   // 4
System.out.println(max.get());   // 10

List.of(1, 2, 4, 7).stream().anyMatch(n -> n > 3);        // true  (at least one)
List.of(2, 4, 6, 8).stream().allMatch(n -> n % 2 == 0);    // true  (all)
List.of(1, 3, 5).stream().noneMatch(n -> n % 2 == 0);     // true  (none)

Optional<Integer> first = List.of(4, 7, 10).stream().findFirst();   // 4
Optional<Integer> any   = List.of(4, 7, 10).stream().findAny();     // any element

Optional<Integer> result = numbers.stream().findFirst();

result.isPresent();                 // true / false
result.get();                       // value (throws if empty)
result.orElse(0);                   // value or default
result.ifPresent(System.out::println);

Stream<Integer> stream = List.of(1, 2, 3, 4, 5).stream();

stream.count();                      // terminal operation: stream is now closed
stream.filter(n -> n > 2);           // ❌ IllegalStateException

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

numbers.stream().count();
numbers.stream().filter(n -> n > 2).toList();   // ✅ new Stream

List<Integer> numbers = List.of(11, 12, 13, 14, 15);

numbers.parallelStream()
.map(n -> n * n)
.forEach(System.out::println);   // order may vary

// Or convert an existing stream
numbers.stream().parallel();

List<Integer> numbers = List.of(2, 1, 4, 7, 10);

List<Integer> result = numbers.stream()
.filter(n -> n >= 3)
.map(n -> -n)
.sorted()
.toList();

System.out.println(result);   // [-10, -7, -4]

record Employee(String name, String dept, double salary) { }

List<Employee> employees = List.of(
    new Employee("Ravi",  "IT", 80000),
    new Employee("Anita", "HR", 50000),
    new Employee("Kiran", "IT", 95000),
    new Employee("Meena", "HR", 60000)
);

// 1. Names of IT employees earning more than 85000
List<String> names = employees.stream()
.filter(e -> e.dept().equals("IT"))
.filter(e -> e.salary() > 85000)
.map(Employee::name)
.toList();                                   // [Kiran]

// 2. Total salary
double total = employees.stream()
.mapToDouble(Employee::salary)
.sum();                                      // 285000.0

// 3. Highest paid employee
Optional<Employee> top = employees.stream()
.max(Comparator.comparingDouble(Employee::salary));

// 4. Average salary per department
Map<String, Double> avgByDept = employees.stream()
.collect(Collectors.groupingBy(
        Employee::dept,
        Collectors.averagingDouble(Employee::salary)));
// {IT=87500.0, HR=55000.0}