ল্যাম্বডা এবং স্ট্রিমস (Lambdas & Streams)

import java.util.ArrayList;
import java.util.Collections;
import java.util.Arrays;
import java.util.List;

public class Main {
    // A functional interface — has exactly ONE abstract method
    interface MathOperation {
        int operate(int a, int b);
    }

    static int calculate(int a, int b, MathOperation op) {
        return op.operate(a, b);
    }

    public static void main(String[] args) {
        // Lambda as a variable
        MathOperation add = (a, b) -> a + b;
        MathOperation multiply = (a, b) -> a * b;
        MathOperation max = (a, b) -> a > b ? a : b;

        System.out.println("5 + 3 = " + calculate(5, 3, add));
        System.out.println("5 * 3 = " + calculate(5, 3, multiply));
        System.out.println("max(5,3) = " + calculate(5, 3, max));

        System.out.println("---");

        // Sorting with lambdas — so much cleaner!
        List<String> names = new ArrayList<>(Arrays.asList(
            "Sadia", "Anika", "Rafi", "Tariq"
        ));

        // Sort alphabetically
        Collections.sort(names, (a, b) -> a.compareTo(b));
        System.out.println("Alphabetical: " + names);

        // Sort by length
        Collections.sort(names, (a, b) -> a.length() - b.length());
        System.out.println("By length: " + names);

        // forEach with lambda
        System.out.print("Each: ");
        names.forEach(n -> System.out.print(n + " "));
        System.out.println();
    }
}

5 + 3 = 8
5 * 3 = 15
max(5,3) = 5
---
Alphabetical: [Anika, Rafi, Sadia, Tariq]
By length: [Rafi, Anika, Tariq, Sadia]
Each: Rafi Anika Tariq Sadia

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Filter: keep only even numbers
        List<Integer> evens = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());
        System.out.println("Evens: " + evens);

        // Map: square each number
        List<Integer> squares = numbers.stream()
            .map(n -> n * n)
            .collect(Collectors.toList());
        System.out.println("Squares: " + squares);

        // Chain them: filter + map + sort
        List<Integer> result = numbers.stream()
            .filter(n -> n > 3)         // keep 4,5,6,7,8,9,10
            .map(n -> n * 2)            // double them
            .filter(n -> n < 16)        // keep under 16
            .sorted()                    // sort
            .collect(Collectors.toList());
        System.out.println("Chained: " + result);

        // Reduce: sum all numbers
        int sum = numbers.stream()
            .reduce(0, (a, b) -> a + b);
        System.out.println("Sum: " + sum);

        // Count
        long count = numbers.stream()
            .filter(n -> n > 5)
            .count();
        System.out.println("Numbers > 5: " + count);
    }
}

Evens: [2, 4, 6, 8, 10]
Squares: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Chained: [8, 10, 12, 14]
Sum: 55
Numbers > 5: 5

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> words = Arrays.asList(
            "hello", "world", "java", "streams", "are", "awesome", "hi"
        );

        // Method reference :: — shorthand for simple lambdas
        // Instead of: s -> s.toUpperCase()
        List<String> upper = words.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());
        System.out.println("Upper: " + upper);

        // Filter words longer than 3 chars, sort, join into one string
        String sentence = words.stream()
            .filter(w -> w.length() > 3)
            .sorted()
            .collect(Collectors.joining(", "));
        System.out.println("Long words: " + sentence);

        // Find first match
        String first = words.stream()
            .filter(w -> w.startsWith("a"))
            .findFirst()
            .orElse("none found");
        System.out.println("First 'a' word: " + first);

        // Check conditions
        boolean anyLong = words.stream().anyMatch(w -> w.length() > 5);
        boolean allShort = words.stream().allMatch(w -> w.length() < 10);
        System.out.println("Any word > 5 chars? " + anyLong);
        System.out.println("All words < 10 chars? " + allShort);

        // Get distinct lengths
        List<Integer> lengths = words.stream()
            .map(String::length)
            .distinct()
            .sorted()
            .collect(Collectors.toList());
        System.out.println("Distinct lengths: " + lengths);
    }
}

Upper: [HELLO, WORLD, JAVA, STREAMS, ARE, AWESOME, HI]
Long words: awesome, hello, java, streams, world
First 'a' word: are
Any word > 5 chars? true
All words < 10 chars? true
Distinct lengths: [2, 3, 4, 5, 7]