Java 8+

List<String> list = List.of("A", "B", "C", "D");
Spliterator<String> s1 = list.spliterator();
Spliterator<String> s2 = s1.trySplit(); // Splits first partition into s2

// Pure function (Stateless, deterministic):
int add(int a, int b) { return a + b; }

// Impure function (Side effect, non-deterministic):
int total = 0;
int addWithSideEffect(int a) { total += a; return total; }

// Custom collector summing string lengths:
Collector<String, int[], Integer> lengthCollector = Collector.of(
    () -> new int[1],                     // supplier
    (acc, str) -> acc[0] += str.length(), // accumulator
    (a1, a2) -> { a1[0] += a2[0]; return a1; }, // combiner
    acc -> acc[0]                         // finisher
);

IntStream intStream = IntStream.rangeClosed(1, 3);
Stream<Integer> boxedStream = intStream.boxed(); // Stream<Integer>

IntStream stream2 = IntStream.rangeClosed(1, 3);
Stream<String> stringStream = stream2.mapToObj(i -> "ID-" + i); // Stream<String>

List<String> list = List.of("a", "b", "c");
List<String> immutable = list.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.toList(),
        Collections::unmodifiableList
    ));

// Higher-order method returning a function configured by threshold:
public static Predicate<Integer> isGreaterThan(int threshold) {
    return val -> val > threshold;
}
// Usage:
List<Integer> list = List.of(5, 10, 15, 20);
List<Integer> gt12 = list.stream().filter(isGreaterThan(12)).toList();

// Curried Function: (a) -> (b) -> a + b
Function<Integer, Function<Integer, Integer>> addCurried = a -> b -> a + b;
Function<Integer, Integer> addTen = addCurried.apply(10); // Partially applied
System.out.println(addTen.apply(5)); // 15

List<Optional<String>> optionalList = List.of(Optional.of("A"), Optional.empty(), Optional.of("B"));
// Cleanly extracts only present values into Stream<String>:
List<String> presentValues = optionalList.stream()
    .flatMap(Optional::stream)
    .collect(Collectors.toList()); // ["A", "B"]

Optional<String> opt = findUsername();
opt.ifPresentOrElse(
    name -> System.out.println("Found: " + name),
    () -> System.out.println("User not found")
);

record Address(String zipCode) {}
record User(Optional<Address> address) {}

Optional<User> userOpt = Optional.of(new User(Optional.of(new Address("10001"))));
// flatMap extracts inner optional cleanly:
Optional<String> zip = userOpt
    .flatMap(User::address)
    .map(Address::zipCode);

List<String> list = List.of("A", "B", "C");
Map<String, Integer> map = list.stream()
    .collect(Collectors.toMap(Function.identity(), String::length));

Predicate<String> nonNull = Objects::nonNull;
Predicate<String> notEmpty = s -> !s.trim().isEmpty();
Predicate<String> valid = nonNull.and(notEmpty);

// Java 11 Predicate.not:
List<String> filtered = list.stream().filter(Predicate.not(String::isBlank)).toList();

List<Integer> list = List.of(2, 4, 6, 8);
boolean allEven = list.stream().allMatch(n -> n % 2 == 0); // true
boolean hasNegative = list.stream().anyMatch(n -> n < 0);  // false
boolean noneOdd = list.stream().noneMatch(n -> n % 2 != 0); // true

int page = 2, pageSize = 5;
List<Integer> pagedData = IntStream.rangeClosed(1, 50)
    .boxed()
    .skip((long) page * pageSize)
    .limit(pageSize)
    .collect(Collectors.toList());

List<String> languages = List.of("Java", "Kotlin", "Scala");
String result = languages.stream()
    .collect(Collectors.joining(", ", "[", "]"));
System.out.println(result); // [Java, Kotlin, Scala]

List<String> items = List.of("apple", "banana", "apricot");
Map<Character, String> map = items.stream()
    .collect(Collectors.toMap(
        s -> s.charAt(0),
        s -> s,
        (existing, replacement) -> existing + "/" + replacement // Collision merger
    ));

List<Integer> numbers = List.of(1, 2, 3);
// mapMulti pushes 0 or more elements directly to downstream consumer:
List<Integer> doubled = numbers.stream()
    .<Integer>mapMulti((num, consumer) -> {
        consumer.accept(num);
        consumer.accept(num * 10);
    })
    .toList(); // [1, 10, 2, 20, 3, 30]

record User(String name, int age) {}
List<User> users = getUsers();
// Sort by age ascending, then by name descending:
List<User> sorted = users.stream()
    .sorted(Comparator.comparing(User::age).thenComparing(Comparator.comparing(User::name).reversed()))
    .collect(Collectors.toList());

List<String> words = List.of("apple", "banana", "cherry");
// mapToInt produces IntStream with direct sum() method:
int totalChars = words.stream().mapToInt(String::length).sum();

UnaryOperator<String> toUpper = String::toUpperCase;
BinaryOperator<Integer> multiply = (a, b) -> a * b;

System.out.println(toUpper.apply("java")); // JAVA
System.out.println(multiply.apply(4, 5));  // 20

List<String> source = List.of("Apple", "Banana");
// Modern concise unmodifiable collection (Java 16+):
List<String> directList = source.stream()
    .filter(s -> s.startsWith("A"))
    .toList(); // Direct unmodifiable list

Stream<String> s1 = Stream.of("A", "B");
Stream<String> s2 = Stream.of("C", "D");
Stream<String> combined = Stream.concat(s1, s2);
combined.forEach(System.out::println);

List<String> list = List.of("a", "b", "a", "c");
List<String> unique = list.stream()
    .distinct() // Uses equals() and hashCode()
    .collect(Collectors.toList()); // ["a", "b", "c"]

Function<Integer, Integer> multiplyBy2 = x -> x * 2;
Function<Integer, Integer> add3 = x -> x + 3;

// (5 * 2) + 3 = 13
int res1 = multiplyBy2.andThen(add3).apply(5);
// (5 + 3) * 2 = 16
int res2 = multiplyBy2.compose(add3).apply(5);

// ANTI-PATTERN (Side effect bug):
// List<String> result = new ArrayList<>();
// stream.parallel().filter(...).forEach(result::add); // Race condition!

// CORRECT (Pure Functional):
List<String> result = stream.parallel().filter(...).collect(Collectors.toList());

List<String> items = List.of("A", "B", "C");
List<String> unmodifiable = items.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.toList(),
        Collections::unmodifiableList // Finisher function
    ));

// Fibonacci sequence using Stream.iterate:
Stream.iterate(new int[]{0, 1}, f -> new int[]{f[1], f[0] + f[1]})
    .limit(10)
    .map(f -> f[0])
    .forEach(System.out::println);

record MinMax(int min, int max) {}
List<Integer> list = List.of(5, 2, 9, 1, 7);
// Computes min and max in one pass:
MinMax result = list.stream().collect(Collectors.teeing(
    Collectors.minBy(Integer::compareTo),
    Collectors.maxBy(Integer::compareTo),
    (min, max) -> new MinMax(min.orElse(0), max.orElse(0))
));

List<String> list = List.of("one", "two", "three");
List<String> result = list.stream()
    .filter(s -> s.length() > 3)
    .peek(e -> System.out.println("Filtered value: " + e)) // Debugging inspection
    .map(String::toUpperCase)
    .collect(Collectors.toList());

int baseRate = 10; // Effectively final
// baseRate = 20; // Reassigning breaks effectively final and causes compilation error!

Function<Integer, Integer> calc = x -> x * baseRate; // Valid variable capture