Table of Contents

Java Programming
#

Lecture 39: Lambda Expressions and Functional Interfaces
#

GTU Diploma in Computer Engineering
#

layout: two-cols
#

Learning Objectives
#

After this lecture, you will be able to:

Understand functional programming concepts in Java
Write and use lambda expressions effectively
Work with built-in functional interfaces
Create custom functional interfaces
Use method references and constructor references
Apply functional programming patterns
Understand the benefits of functional style programming

::right::

Lecture Overview
#

Introduction to Functional Programming
Lambda Expression Syntax
Functional Interfaces
Built-in Functional Interfaces
Method References
Custom Functional Interfaces
Functional Programming Patterns
Best Practices
Hands-on Exercises

What is Functional Programming?
#

Functional programming is a programming paradigm that treats computation as evaluation of mathematical functions.

Key Concepts
#

Functions as First-Class Objects: Functions can be assigned to variables, passed as parameters
Immutability: Data doesn’t change after creation
Pure Functions: Functions with no side effects
Higher-Order Functions: Functions that take or return other functions

Java 8 and Functional Programming
#

// Traditional approach (before Java 8)
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
});

// Functional approach (Java 8+)
names.sort((a, b) -> a.compareTo(b));
// Or even simpler
names.sort(String::compareTo);

Introduction to Lambda Expressions
#

Lambda expressions provide a concise way to represent anonymous functions.

Syntax
#

// Basic syntax
(parameters) -> expression
(parameters) -> { statements; }

// Examples
() -> System.out.println("Hello")                    // No parameters
x -> x * x                                           // Single parameter
(x, y) -> x + y                                     // Multiple parameters
(String s) -> s.length()                            // Explicit type
x -> { return x * x; }                              // Block body
(x, y) -> { 
    int sum = x + y; 
    return sum * 2; 
}                                                   // Multi-statement block

Comparison with Anonymous Classes
#

// Anonymous class
Runnable runnable1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello from anonymous class");
    }
};

// Lambda expression
Runnable runnable2 = () -> System.out.println("Hello from lambda");

// Both work the same way
new Thread(runnable1).start();
new Thread(runnable2).start();
new Thread(() -> System.out.println("Direct lambda")).start();

Lambda Expression Examples
#

Basic Examples
#

import java.util.*;
import java.util.function.*;

public class LambdaBasics {
    public static void main(String[] args) {
        // Example 1: Simple operations
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Print each number
        numbers.forEach(n -> System.out.println(n));
        
        // Example 2: Filtering
        List<Integer> evenNumbers = new ArrayList<>();
        numbers.forEach(n -> {
            if (n % 2 == 0) {
                evenNumbers.add(n);
            }
        });
        System.out.println("Even numbers: " + evenNumbers);
        
        // Example 3: Transformation
        List<Integer> squares = new ArrayList<>();
        numbers.forEach(n -> squares.add(n * n));
        System.out.println("Squares: " + squares);
        
        // Example 4: Comparison
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
        names.sort((a, b) -> a.length() - b.length());  // Sort by length
        System.out.println("Sorted by length: " + names);
        
        names.sort((a, b) -> a.compareTo(b));  // Sort alphabetically
        System.out.println("Sorted alphabetically: " + names);
    }
}

Functional Interfaces
#

A functional interface has exactly one abstract method (SAM - Single Abstract Method).

@FunctionalInterface Annotation
#

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
    
    // Default methods are allowed
    default void printResult(int a, int b) {
        System.out.println("Result: " + calculate(a, b));
    }
    
    // Static methods are allowed
    static void info() {
        System.out.println("Calculator interface");
    }
}

Using Functional Interfaces
#

public class FunctionalInterfaceDemo {
    public static void main(String[] args) {
        // Using lambda expressions
        Calculator add = (a, b) -> a + b;
        Calculator subtract = (a, b) -> a - b;
        Calculator multiply = (a, b) -> a * b;
        Calculator divide = (a, b) -> a / b;
        
        System.out.println("Addition: " + add.calculate(10, 5));
        System.out.println("Subtraction: " + subtract.calculate(10, 5));
        System.out.println("Multiplication: " + multiply.calculate(10, 5));
        System.out.println("Division: " + divide.calculate(10, 5));
        
        // Using default method
        add.printResult(10, 5);
        
        // Using static method
        Calculator.info();
        
        // Passing lambda as parameter
        performOperation(15, 3, (a, b) -> a % b);
    }
    
    public static void performOperation(int x, int y, Calculator calc) {
        int result = calc.calculate(x, y);
        System.out.println("Operation result: " + result);
    }
}

Built-in Functional Interfaces
#

Java 8 provides many built-in functional interfaces in java.util.function package.

Predicate<T>
#

Tests a condition and returns boolean.

import java.util.function.Predicate;
import java.util.*;

public class PredicateDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // Basic predicates
        Predicate<Integer> isEven = n -> n % 2 == 0;
        Predicate<Integer> isPositive = n -> n > 0;
        Predicate<Integer> isGreaterThan5 = n -> n > 5;
        
        // Using predicates
        System.out.println("Even numbers:");
        filterAndPrint(numbers, isEven);
        
        System.out.println("Numbers greater than 5:");
        filterAndPrint(numbers, isGreaterThan5);
        
        // Combining predicates
        Predicate<Integer> evenAndGreaterThan5 = isEven.and(isGreaterThan5);
        System.out.println("Even numbers greater than 5:");
        filterAndPrint(numbers, evenAndGreaterThan5);
        
        Predicate<Integer> evenOrGreaterThan8 = isEven.or(n -> n > 8);
        System.out.println("Even numbers or greater than 8:");
        filterAndPrint(numbers, evenOrGreaterThan8);
        
        // Negation
        Predicate<Integer> notEven = isEven.negate();
        System.out.println("Odd numbers:");
        filterAndPrint(numbers, notEven);
        
        // String predicates
        List<String> words = Arrays.asList("Java", "Python", "JavaScript", "C++");
        Predicate<String> startsWithJ = s -> s.startsWith("J");
        Predicate<String> longerThan4 = s -> s.length() > 4;
        
        System.out.println("Words starting with 'J':");
        filterAndPrint(words, startsWithJ);
        
        System.out.println("Words starting with 'J' and longer than 4 characters:");
        filterAndPrint(words, startsWithJ.and(longerThan4));
    }
    
    public static <T> void filterAndPrint(List<T> list, Predicate<T> predicate) {
        list.stream().filter(predicate).forEach(System.out::println);
    }
}

Function<T, R>
#

Represents a function that takes one argument and returns a result.

import java.util.function.Function;
import java.util.*;

public class FunctionDemo {
    public static void main(String[] args) {
        // Basic functions
        Function<String, Integer> stringLength = s -> s.length();
        Function<Integer, Integer> square = n -> n * n;
        Function<String, String> uppercase = s -> s.toUpperCase();
        Function<Integer, String> numberToString = n -> "Number: " + n;
        
        // Using functions
        System.out.println("Length of 'Hello': " + stringLength.apply("Hello"));
        System.out.println("Square of 5: " + square.apply(5));
        System.out.println("Uppercase 'hello': " + uppercase.apply("hello"));
        System.out.println(numberToString.apply(42));
        
        // Function composition
        Function<String, String> trimAndUppercase = 
            ((Function<String, String>) String::trim).andThen(String::toUpperCase);
        
        System.out.println("Trim and uppercase '  hello  ': '" + 
                          trimAndUppercase.apply("  hello  ") + "'");
        
        // Chaining functions
        Function<Integer, Integer> multiplyBy2 = n -> n * 2;
        Function<Integer, Integer> add10 = n -> n + 10;
        
        Function<Integer, Integer> multiplyThenAdd = multiplyBy2.andThen(add10);
        Function<Integer, Integer> addThenMultiply = add10.compose(multiplyBy2);
        
        System.out.println("5 * 2 + 10 = " + multiplyThenAdd.apply(5));  // (5*2)+10 = 20
        System.out.println("(5 + 10) * 2 = " + addThenMultiply.apply(5)); // 5*2+10 = 20
        
        // Working with lists
        List<String> names = Arrays.asList("alice", "bob", "charlie");
        List<Integer> nameLengths = transform(names, stringLength);
        List<String> upperNames = transform(names, uppercase);
        
        System.out.println("Original: " + names);
        System.out.println("Lengths: " + nameLengths);
        System.out.println("Uppercase: " + upperNames);
    }
    
    public static <T, R> List<R> transform(List<T> list, Function<T, R> function) {
        List<R> result = new ArrayList<>();
        for (T item : list) {
            result.add(function.apply(item));
        }
        return result;
    }
}

Consumer<T> and Supplier<T>
#

Consumer<T> - Consumes input, returns nothing
#

import java.util.function.Consumer;
import java.util.*;

public class ConsumerDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        
        // Basic consumers
        Consumer<String> print = s -> System.out.println(s);
        Consumer<String> printUppercase = s -> System.out.println(s.toUpperCase());
        Consumer<String> printLength = s -> System.out.println("Length: " + s.length());
        
        // Using consumers
        System.out.println("Using print consumer:");
        names.forEach(print);
        
        System.out.println("\nUsing printUppercase consumer:");
        names.forEach(printUppercase);
        
        // Chaining consumers
        Consumer<String> printAndLength = print.andThen(printLength);
        
        System.out.println("\nUsing chained consumer:");
        names.forEach(printAndLength);
        
        // Consumer with side effects
        List<String> processedNames = new ArrayList<>();
        Consumer<String> addToList = s -> processedNames.add(s.toUpperCase());
        
        names.forEach(addToList);
        System.out.println("Processed names: " + processedNames);
        
        // Bi-Consumer example
        Map<String, Integer> nameAges = new HashMap<>();
        nameAges.put("Alice", 25);
        nameAges.put("Bob", 30);
        nameAges.put("Charlie", 35);
        
        nameAges.forEach((name, age) -> 
            System.out.println(name + " is " + age + " years old"));
    }
}

Supplier<T> - Supplies a value
#

import java.util.function.Supplier;
import java.util.*;
import java.time.LocalDateTime;

public class SupplierDemo {
    public static void main(String[] args) {
        // Basic suppliers
        Supplier<String> helloSupplier = () -> "Hello World";
        Supplier<Double> randomSupplier = () -> Math.random();
        Supplier<LocalDateTime> timeSupplier = () -> LocalDateTime.now();
        Supplier<List<String>> listSupplier = () -> new ArrayList<>();
        
        // Using suppliers
        System.out.println("Hello supplier: " + helloSupplier.get());
        System.out.println("Random number: " + randomSupplier.get());
        System.out.println("Current time: " + timeSupplier.get());
        
        // Supplier for lazy initialization
        Supplier<String> expensiveOperation = () -> {
            System.out.println("Performing expensive operation...");
            try {
                Thread.sleep(1000); // Simulate expensive operation
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "Expensive result";
        };
        
        System.out.println("Before calling supplier");
        String result = expensiveOperation.get(); // Operation happens here
        System.out.println("Result: " + result);
        
        // Using supplier to generate test data
        Supplier<Person> personSupplier = () -> new Person(
            "Person" + (int)(Math.random() * 1000),
            (int)(Math.random() * 50) + 18
        );
        
        List<Person> people = generateList(personSupplier, 5);
        people.forEach(System.out::println);
    }
    
    public static <T> List<T> generateList(Supplier<T> supplier, int count) {
        List<T> list = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            list.add(supplier.get());
        }
        return list;
    }
    
    static class Person {
        private String name;
        private int age;
        
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return "Person{name='" + name + "', age=" + age + '}';
        }
    }
}

Method References
#

Method references provide a way to refer to methods without executing them.

Types of Method References
#

import java.util.*;
import java.util.function.*;

public class MethodReferencesDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
        
        // 1. Reference to static method
        // Lambda: s -> Integer.parseInt(s)
        Function<String, Integer> parseInt = Integer::parseInt;
        System.out.println("Parsed number: " + parseInt.apply("123"));
        
        // 2. Reference to instance method of particular object
        String prefix = "Hello, ";
        // Lambda: s -> prefix.concat(s)
        Function<String, String> greeting = prefix::concat;
        System.out.println(greeting.apply("World"));
        
        // 3. Reference to instance method of arbitrary object
        // Lambda: s -> s.length()
        Function<String, Integer> length = String::length;
        names.stream()
             .map(String::length)  // Same as s -> s.length()
             .forEach(System.out::println);
        
        // Lambda: s -> s.toUpperCase()
        names.stream()
             .map(String::toUpperCase)  // Same as s -> s.toUpperCase()
             .forEach(System.out::println);
        
        // 4. Reference to constructor
        // Lambda: () -> new ArrayList<>()
        Supplier<List<String>> listSupplier = ArrayList::new;
        List<String> newList = listSupplier.get();
        
        // Lambda: s -> new String(s)
        Function<String, String> stringConstructor = String::new;
        
        // More complex constructor reference
        BiFunction<String, Integer, Person> personConstructor = Person::new;
        Person person = personConstructor.apply("Alice", 25);
        System.out.println("Created person: " + person);
        
        // Using method references with collections
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
        
        // Method reference for comparison
        numbers.sort(Integer::compareTo);
        System.out.println("Sorted numbers: " + numbers);
        
        // Method reference for printing
        System.out.println("Numbers:");
        numbers.forEach(System.out::println);
    }
    
    static class Person {
        private String name;
        private int age;
        
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return "Person{name='" + name + "', age=" + age + '}';
        }
    }
}

Constructor References
#

Constructor references are a special form of method references.

import java.util.*;
import java.util.function.*;

public class ConstructorReferencesDemo {
    
    static class Product {
        private String name;
        private double price;
        private String category;
        
        // Default constructor
        public Product() {
            this("Unknown", 0.0, "General");
        }
        
        // Constructor with name and price
        public Product(String name, double price) {
            this.name = name;
            this.price = price;
            this.category = "General";
        }
        
        // Constructor with all parameters
        public Product(String name, double price, String category) {
            this.name = name;
            this.price = price;
            this.category = category;
        }
        
        // Getters
        public String getName() { return name; }
        public double getPrice() { return price; }
        public String getCategory() { return category; }
        
        @Override
        public String toString() {
            return String.format("Product{name='%s', price=%.2f, category='%s'}", 
                               name, price, category);
        }
    }
    
    public static void main(String[] args) {
        // Constructor reference for default constructor
        Supplier<Product> defaultConstructor = Product::new;
        Product product1 = defaultConstructor.get();
        System.out.println("Default product: " + product1);
        
        // Constructor reference for two-parameter constructor
        BiFunction<String, Double, Product> twoParamConstructor = Product::new;
        Product product2 = twoParamConstructor.apply("Laptop", 999.99);
        System.out.println("Two-param product: " + product2);
        
        // Constructor reference for three-parameter constructor
        TriFunction<String, Double, String, Product> threeParamConstructor = Product::new;
        Product product3 = threeParamConstructor.apply("Smartphone", 599.99, "Electronics");
        System.out.println("Three-param product: " + product3);
        
        // Using constructor references with collections
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        
        // Create list of products using constructor reference
        List<Product> products = names.stream()
            .map(name -> new Product(name, Math.random() * 100))
            .collect(ArrayList::new,  // Constructor reference for collection
                    ArrayList::add,   // Method reference for adding
                    ArrayList::addAll); // Method reference for combining
        
        System.out.println("\nGenerated products:");
        products.forEach(System.out::println);
        
        // Array constructor references
        IntFunction<Product[]> arrayConstructor = Product[]::new;
        Product[] productArray = arrayConstructor.apply(3);
        System.out.println("Created array of length: " + productArray.length);
    }
    
    // Custom functional interface for three parameters
    @FunctionalInterface
    interface TriFunction<T, U, V, R> {
        R apply(T t, U u, V v);
    }
}

Custom Functional Interfaces
#

Creating your own functional interfaces for specific use cases.

@FunctionalInterface
interface StringProcessor {
    String process(String input);
    
    // Default methods are allowed
    default String processWithPrefix(String input, String prefix) {
        return prefix + process(input);
    }
    
    // Static methods are allowed
    static StringProcessor identity() {
        return s -> s;
    }
    
    static StringProcessor chain(StringProcessor first, StringProcessor second) {
        return s -> second.process(first.process(s));
    }
}

@FunctionalInterface
interface MathOperation {
    double calculate(double a, double b);
    
    default boolean isCommutative() {
        return false; // Override in specific implementations if needed
    }
}

@FunctionalInterface
interface Validator<T> {
    ValidationResult validate(T input);
    
    default Validator<T> and(Validator<T> other) {
        return input -> {
            ValidationResult result = this.validate(input);
            return result.isValid() ? other.validate(input) : result;
        };
    }
    
    default Validator<T> or(Validator<T> other) {
        return input -> {
            ValidationResult result = this.validate(input);
            return result.isValid() ? result : other.validate(input);
        };
    }
}

class ValidationResult {
    private final boolean valid;
    private final String message;
    
    public ValidationResult(boolean valid, String message) {
        this.valid = valid;
        this.message = message;
    }
    
    public boolean isValid() { return valid; }
    public String getMessage() { return message; }
    
    public static ValidationResult valid() {
        return new ValidationResult(true, "Valid");
    }
    
    public static ValidationResult invalid(String message) {
        return new ValidationResult(false, message);
    }
    
    @Override
    public String toString() {
        return valid ? "Valid" : "Invalid: " + message;
    }
}

Using Custom Functional Interfaces
#

public class CustomFunctionalInterfacesDemo {
    public static void main(String[] args) {
        // String processors
        StringProcessor uppercase = s -> s.toUpperCase();
        StringProcessor reverse = s -> new StringBuilder(s).reverse().toString();
        StringProcessor removeSpaces = s -> s.replaceAll("\\s+", "");
        
        String input = "hello world";
        
        System.out.println("Original: " + input);
        System.out.println("Uppercase: " + uppercase.process(input));
        System.out.println("Reverse: " + reverse.process(input));
        System.out.println("No spaces: " + removeSpaces.process(input));
        
        // Using default method
        System.out.println("With prefix: " + 
            uppercase.processWithPrefix(input, "Processed: "));
        
        // Chaining processors
        StringProcessor chainedProcessor = StringProcessor.chain(
            removeSpaces, 
            StringProcessor.chain(uppercase, reverse)
        );
        System.out.println("Chained (remove spaces -> uppercase -> reverse): " + 
            chainedProcessor.process(input));
        
        // Math operations
        MathOperation add = (a, b) -> a + b;
        MathOperation multiply = (a, b) -> a * b;
        MathOperation power = (a, b) -> Math.pow(a, b);
        
        System.out.println("\nMath Operations:");
        System.out.println("5 + 3 = " + add.calculate(5, 3));
        System.out.println("5 * 3 = " + multiply.calculate(5, 3));
        System.out.println("5^3 = " + power.calculate(5, 3));
        
        // Validators
        Validator<String> notEmpty = s -> 
            s != null && !s.trim().isEmpty() ? 
                ValidationResult.valid() : 
                ValidationResult.invalid("String cannot be empty");
        
        Validator<String> minLength = s -> 
            s != null && s.length() >= 3 ? 
                ValidationResult.valid() : 
                ValidationResult.invalid("String must be at least 3 characters");
        
        Validator<String> noSpaces = s -> 
            s != null && !s.contains(" ") ? 
                ValidationResult.valid() : 
                ValidationResult.invalid("String cannot contain spaces");
        
        Validator<String> combinedValidator = notEmpty.and(minLength).and(noSpaces);
        
        // Testing validators
        String[] testInputs = {"", "ab", "abc", "ab c", "hello", "valid_input"};
        
        System.out.println("\nValidation Results:");
        for (String testInput : testInputs) {
            ValidationResult result = combinedValidator.validate(testInput);
            System.out.println("'" + testInput + "': " + result);
        }
    }
}

Functional Programming Patterns
#

Higher-Order Functions
#

import java.util.*;
import java.util.function.*;

public class HigherOrderFunctions {
    
    // Function that returns another function
    public static Function<Integer, Integer> createMultiplier(int factor) {
        return x -> x * factor;
    }
    
    // Function that takes functions as parameters
    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        List<T> result = new ArrayList<>();
        for (T item : list) {
            if (predicate.test(item)) {
                result.add(item);
            }
        }
        return result;
    }
    
    public static <T, R> List<R> map(List<T> list, Function<T, R> mapper) {
        List<R> result = new ArrayList<>();
        for (T item : list) {
            result.add(mapper.apply(item));
        }
        return result;
    }
    
    public static <T> Optional<T> reduce(List<T> list, BinaryOperator<T> accumulator) {
        if (list.isEmpty()) {
            return Optional.empty();
        }
        
        T result = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            result = accumulator.apply(result, list.get(i));
        }
        return Optional.of(result);
    }
    
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // Using higher-order functions
        Function<Integer, Integer> double_func = createMultiplier(2);
        Function<Integer, Integer> triple = createMultiplier(3);
        
        System.out.println("Original numbers: " + numbers);
        
        // Filter even numbers
        List<Integer> evenNumbers = filter(numbers, n -> n % 2 == 0);
        System.out.println("Even numbers: " + evenNumbers);
        
        // Map to squares
        List<Integer> squares = map(numbers, n -> n * n);
        System.out.println("Squares: " + squares);
        
        // Map using created multiplier functions
        List<Integer> doubled = map(numbers, double_func);
        List<Integer> tripled = map(numbers, triple);
        System.out.println("Doubled: " + doubled);
        System.out.println("Tripled: " + tripled);
        
        // Reduce to sum
        Optional<Integer> sum = reduce(numbers, (a, b) -> a + b);
        System.out.println("Sum: " + sum.orElse(0));
        
        // Reduce to product
        Optional<Integer> product = reduce(numbers, (a, b) -> a * b);
        System.out.println("Product: " + product.orElse(0));
        
        // Chain operations
        List<Integer> result = map(
            filter(numbers, n -> n % 2 == 0),  // Get even numbers
            n -> n * n                         // Square them
        );
        System.out.println("Even numbers squared: " + result);
    }
}

Currying and Partial Application
#

import java.util.function.*;

public class CurryingDemo {
    
    // Traditional method with multiple parameters
    public static int add(int a, int b, int c) {
        return a + b + c;
    }
    
    // Curried version - returns function that returns function
    public static Function<Integer, Function<Integer, Function<Integer, Integer>>> curriedAdd() {
        return a -> b -> c -> a + b + c;
    }
    
    // Partial application example
    public static Function<Integer, Function<Integer, Integer>> partialAdd(int a) {
        return b -> c -> a + b + c;
    }
    
    // Generic currying utility
    public static <A, B, C, R> Function<A, Function<B, Function<C, R>>> curry(
            TriFunction<A, B, C, R> function) {
        return a -> b -> c -> function.apply(a, b, c);
    }
    
    // Uncurrying utility
    public static <A, B, C, R> TriFunction<A, B, C, R> uncurry(
            Function<A, Function<B, Function<C, R>>> curried) {
        return (a, b, c) -> curried.apply(a).apply(b).apply(c);
    }
    
    @FunctionalInterface
    interface TriFunction<A, B, C, R> {
        R apply(A a, B b, C c);
    }
    
    public static void main(String[] args) {
        // Traditional approach
        int result1 = add(1, 2, 3);
        System.out.println("Traditional add(1, 2, 3): " + result1);
        
        // Curried approach
        Function<Integer, Function<Integer, Function<Integer, Integer>>> curriedAddFunc = curriedAdd();
        int result2 = curriedAddFunc.apply(1).apply(2).apply(3);
        System.out.println("Curried add(1)(2)(3): " + result2);
        
        // Partial application
        Function<Integer, Function<Integer, Integer>> addWith5 = partialAdd(5);
        Function<Integer, Integer> addWith5And10 = addWith5.apply(10);
        int result3 = addWith5And10.apply(15);
        System.out.println("Partial application 5 + 10 + 15: " + result3);
        
        // More practical example - creating specialized functions
        Function<Integer, Function<Integer, Integer>> addWithFirst = partialAdd(100);
        Function<Integer, Integer> addWith100And20 = addWithFirst.apply(20);
        
        // Use the specialized function multiple times
        System.out.println("100 + 20 + 1 = " + addWith100And20.apply(1));
        System.out.println("100 + 20 + 5 = " + addWith100And20.apply(5));
        System.out.println("100 + 20 + 10 = " + addWith100And20.apply(10));
        
        // Generic currying example
        TriFunction<String, String, String, String> concat = (a, b, c) -> a + b + c;
        Function<String, Function<String, Function<String, String>>> curriedConcat = curry(concat);
        
        String result4 = curriedConcat.apply("Hello").apply(" ").apply("World");
        System.out.println("Curried concat: " + result4);
        
        // Partial application with concat
        Function<String, Function<String, String>> greetingBuilder = 
            curriedConcat.apply("Hello ");
        Function<String, String> sayHelloTo = greetingBuilder.apply("Mr. ");
        
        System.out.println(sayHelloTo.apply("Smith"));
        System.out.println(sayHelloTo.apply("Johnson"));
        System.out.println(sayHelloTo.apply("Brown"));
    }
}

Functional Composition
#

import java.util.function.*;
import java.util.*;

public class FunctionComposition {
    
    // Helper method to create function pipeline
    @SafeVarargs
    public static <T> Function<T, T> pipeline(Function<T, T>... functions) {
        return Arrays.stream(functions)
                     .reduce(Function.identity(), Function::andThen);
    }
    
    public static void main(String[] args) {
        // Basic function composition
        Function<String, String> removeSpaces = s -> s.replaceAll("\\s+", "");
        Function<String, String> toUpperCase = String::toUpperCase;
        Function<String, String> reverse = s -> new StringBuilder(s).reverse().toString();
        
        // Compose using andThen
        Function<String, String> processString1 = removeSpaces.andThen(toUpperCase).andThen(reverse);
        
        // Compose using compose (reverse order)
        Function<String, String> processString2 = reverse.compose(toUpperCase).compose(removeSpaces);
        
        String input = "Hello World Java";
        System.out.println("Original: " + input);
        System.out.println("Using andThen: " + processString1.apply(input));
        System.out.println("Using compose: " + processString2.apply(input));
        
        // More complex composition - number processing
        Function<Integer, Integer> addOne = x -> x + 1;
        Function<Integer, Integer> multiplyByTwo = x -> x * 2;
        Function<Integer, Integer> square = x -> x * x;
        
        Function<Integer, Integer> complexOperation = 
            addOne.andThen(multiplyByTwo).andThen(square);
        
        System.out.println("\nNumber processing:");
        System.out.println("5 -> add1 -> *2 -> square = " + complexOperation.apply(5));
        // (5 + 1) * 2 = 12, 12^2 = 144
        
        // Using pipeline helper method
        Function<String, String> pipeline = pipeline(
            s -> s.toLowerCase(),
            s -> s.replaceAll("[^a-z]", ""),
            s -> s.substring(0, Math.min(5, s.length())),
            String::toUpperCase
        );
        
        System.out.println("\nPipeline processing:");
        System.out.println("'Hello World 123!' -> " + pipeline.apply("Hello World 123!"));
        
        // Predicate composition
        Predicate<Integer> isPositive = x -> x > 0;
        Predicate<Integer> isEven = x -> x % 2 == 0;
        Predicate<Integer> isLessThan100 = x -> x < 100;
        
        Predicate<Integer> complexPredicate = isPositive.and(isEven).and(isLessThan100);
        
        List<Integer> numbers = Arrays.asList(-2, 0, 1, 2, 4, 50, 99, 100, 150);
        
        System.out.println("\nFiltering with complex predicate (positive AND even AND < 100):");
        numbers.stream()
               .filter(complexPredicate)
               .forEach(System.out::println);
        
        // Consumer composition
        Consumer<String> print = System.out::println;
        Consumer<String> printLength = s -> System.out.println("Length: " + s.length());
        Consumer<String> printUppercase = s -> System.out.println("Uppercase: " + s.toUpperCase());
        
        Consumer<String> combinedConsumer = print.andThen(printLength).andThen(printUppercase);
        
        System.out.println("\nCombined consumer:");
        combinedConsumer.accept("functional programming");
    }
}

Best Practices
#

1. Keep Lambdas Simple and Readable
#

// Good - simple and clear
list.stream().filter(s -> s.length() > 5).collect(toList());

// Avoid - complex logic in lambda
list.stream().filter(s -> {
    if (s == null) return false;
    String trimmed = s.trim();
    return trimmed.length() > 5 && trimmed.startsWith("A") && !trimmed.contains(" ");
}).collect(toList());

// Better - extract to method
list.stream().filter(this::isValidString).collect(toList());

private boolean isValidString(String s) {
    if (s == null) return false;
    String trimmed = s.trim();
    return trimmed.length() > 5 && trimmed.startsWith("A") && !trimmed.contains(" ");
}

2. Prefer Method References When Appropriate
#

// Less readable
list.forEach(item -> System.out.println(item));
list.stream().map(s -> s.toUpperCase()).collect(toList());

// More readable
list.forEach(System.out::println);
list.stream().map(String::toUpperCase).collect(toList());

3. Use Appropriate Functional Interfaces
#

// Avoid creating unnecessary functional interfaces
@FunctionalInterface
interface StringChecker {
    boolean check(String s);
}

// Use built-in Predicate instead
Predicate<String> checker = s -> s.length() > 5;

Performance Considerations
#

import java.util.*;
import java.util.function.*;
import java.time.Instant;
import java.time.Duration;

public class PerformanceDemo {
    
    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> numbers = new ArrayList<>();
        for (int i = 0; i < 1_000_000; i++) {
            numbers.add(i);
        }
        
        // Traditional for loop
        measureTime("Traditional for loop", () -> {
            List<Integer> evens = new ArrayList<>();
            for (Integer num : numbers) {
                if (num % 2 == 0) {
                    evens.add(num);
                }
            }
        });
        
        // Lambda with stream
        measureTime("Lambda with stream", () -> {
            List<Integer> evens = numbers.stream()
                                        .filter(n -> n % 2 == 0)
                                        .collect(ArrayList::new, 
                                               ArrayList::add, 
                                               ArrayList::addAll);
        });
        
        // Parallel stream
        measureTime("Parallel stream", () -> {
            List<Integer> evens = numbers.parallelStream()
                                        .filter(n -> n % 2 == 0)
                                        .collect(ArrayList::new, 
                                               ArrayList::add, 
                                               ArrayList::addAll);
        });
        
        // Method reference vs lambda performance
        Predicate<Integer> isEvenLambda = n -> n % 2 == 0;
        Predicate<Integer> isEvenMethod = PerformanceDemo::isEven;
        
        measureTime("Lambda predicate", () -> {
            numbers.stream().filter(isEvenLambda).count();
        });
        
        measureTime("Method reference predicate", () -> {
            numbers.stream().filter(isEvenMethod).count();
        });
    }
    
    public static boolean isEven(Integer n) {
        return n % 2 == 0;
    }
}

Hands-on Exercise 1: Event Processing System
#

Create a functional event processing system with the following requirements:

// Event class
class Event {
    private String type;
    private String data;
    private long timestamp;
    
    public Event(String type, String data) {
        this.type = type;
        this.data = data;
        this.timestamp = System.currentTimeMillis();
    }
    
    // Getters
    public String getType() { return type; }
    public String getData() { return data; }
    public long getTimestamp() { return timestamp; }
    
    @Override
    public String toString() {
        return String.format("Event{type='%s', data='%s', timestamp=%d}", 
                           type, data, timestamp);
    }
}

// TODO: Create EventProcessor interface
@FunctionalInterface
interface EventProcessor {
    // TODO: Define process method
}

// TODO: Create EventFilter interface
@FunctionalInterface 
interface EventFilter {
    // TODO: Define filter method
}

// TODO: Implement EventManager class
class EventManager {
    // TODO: Add methods to register processors and filters
    // TODO: Add method to process events
    // TODO: Use functional programming concepts
}

Test your implementation with different event types and processors.

Hands-on Exercise 2: Functional Calculator
#

Implement a calculator using functional programming concepts:

public class FunctionalCalculator {
    
    // TODO: Define Operation functional interface
    @FunctionalInterface
    interface Operation {
        // TODO: Define calculate method
    }
    
    // TODO: Create a map of operation names to Operation implementations
    private static final Map<String, Operation> operations = new HashMap<>();
    
    static {
        // TODO: Initialize operations map with lambda expressions
        // add, subtract, multiply, divide, power, etc.
    }
    
    // TODO: Implement calculate method that takes operation name and operands
    public static double calculate(String operationName, double a, double b) {
        // TODO: Your implementation
    }
    
    // TODO: Implement method to add custom operations
    public static void addOperation(String name, Operation operation) {
        // TODO: Your implementation
    }
    
    // TODO: Implement method to get available operations
    public static Set<String> getAvailableOperations() {
        // TODO: Your implementation
    }
    
    public static void main(String[] args) {
        // TODO: Test your calculator with various operations
        // TODO: Add custom operations using lambdas
    }
}

Include error handling and support for custom operations.

Hands-on Exercise 3: Data Processing Pipeline
#

Create a functional data processing pipeline:

import java.util.*;
import java.util.function.*;

public class DataPipeline<T> {
    
    private List<Function<Stream<T>, Stream<T>>> operations = new ArrayList<>();
    
    // TODO: Implement filter method
    public DataPipeline<T> filter(Predicate<T> predicate) {
        // TODO: Add filter operation to pipeline
        return this;
    }
    
    // TODO: Implement map method
    public <R> DataPipeline<R> map(Function<T, R> mapper) {
        // TODO: Create new pipeline with mapped type
    }
    
    // TODO: Implement sort method
    public DataPipeline<T> sort(Comparator<T> comparator) {
        // TODO: Add sort operation to pipeline
        return this;
    }
    
    // TODO: Implement limit method
    public DataPipeline<T> limit(long maxSize) {
        // TODO: Add limit operation to pipeline
        return this;
    }
    
    // TODO: Implement skip method
    public DataPipeline<T> skip(long n) {
        // TODO: Add skip operation to pipeline
        return this;
    }
    
    // TODO: Implement distinct method
    public DataPipeline<T> distinct() {
        // TODO: Add distinct operation to pipeline
        return this;
    }
    
    // TODO: Implement execute method to run the pipeline
    public List<T> execute(List<T> input) {
        // TODO: Apply all operations in sequence
    }
    
    // TODO: Implement executeToStream method
    public Stream<T> executeToStream(List<T> input) {
        // TODO: Return stream after applying all operations
    }
}

Test with various data transformations and operations.

Exercise Solutions: Event Processing System
#

import java.util.*;
import java.util.function.*;

@FunctionalInterface
interface EventProcessor {
    void process(Event event);
    
    default EventProcessor andThen(EventProcessor after) {
        return event -> {
            this.process(event);
            after.process(event);
        };
    }
}

@FunctionalInterface 
interface EventFilter {
    boolean accept(Event event);
    
    default EventFilter and(EventFilter other) {
        return event -> this.accept(event) && other.accept(event);
    }
    
    default EventFilter or(EventFilter other) {
        return event -> this.accept(event) || other.accept(event);
    }
}

class EventManager {
    private List<EventFilter> filters = new ArrayList<>();
    private List<EventProcessor> processors = new ArrayList<>();
    
    public void addFilter(EventFilter filter) {
        filters.add(filter);
    }
    
    public void addProcessor(EventProcessor processor) {
        processors.add(processor);
    }
    
    public void processEvent(Event event) {
        // Apply all filters
        boolean shouldProcess = filters.stream()
            .allMatch(filter -> filter.accept(event));
        
        if (shouldProcess) {
            // Apply all processors
            processors.forEach(processor -> processor.process(event));
        }
    }
    
    public void processEvents(List<Event> events) {
        events.forEach(this::processEvent);
    }
}

// Usage example
public class EventSystemDemo {
    public static void main(String[] args) {
        EventManager manager = new EventManager();
        
        // Add filters
        manager.addFilter(event -> "ERROR".equals(event.getType()));
        manager.addFilter(event -> event.getData().contains("database"));
        
        // Add processors
        manager.addProcessor(event -> 
            System.out.println("Logging: " + event));
        manager.addProcessor(event -> 
            System.out.println("Alerting administrators about: " + event.getType()));
        
        // Test events
        List<Event> events = Arrays.asList(
            new Event("INFO", "User logged in"),
            new Event("ERROR", "Database connection failed"),
            new Event("WARNING", "High memory usage"),
            new Event("ERROR", "Database timeout occurred")
        );
        
        manager.processEvents(events);
    }
}

Summary
#

Key Concepts Covered
#

Functional Programming: Treating functions as first-class objects
Lambda Expressions: Concise syntax for anonymous functions
Functional Interfaces: Interfaces with single abstract method
Built-in Interfaces: Predicate, Function, Consumer, Supplier
Method References: Referencing methods without executing them
Constructor References: Referencing constructors as functions
Function Composition: Combining functions to create complex operations

Benefits of Functional Programming
#

Conciseness: Less boilerplate code
Readability: More expressive code
Reusability: Functions can be composed and reused
Testability: Pure functions are easier to test
Parallelization: Functional code is often easier to parallelize

When to Use Functional Programming
#

Data processing and transformations
Event handling and filtering
Collections operations
Configuration and setup code
Validation and business rules

Next Lecture Preview
#

Lecture 40: Stream API
#

Introduction to Java Streams
Creating and Operating on Streams
Intermediate and Terminal Operations
Parallel Streams
Collectors and Custom Collectors
Stream Performance and Best Practices

Preparation
#

Practice with lambda expressions and functional interfaces
Review collections framework
Understand the concept of lazy evaluation

Thank You!
#

Questions and Discussion
#

How do lambda expressions improve code readability?
When would you choose lambda expressions over anonymous classes?
What are the performance implications of functional programming?

Resources for Further Learning
#

Oracle Java Lambda Tutorial
Functional Programming in Java by Venkat Subramaniam
Practice functional programming with different use cases

Next: Stream API and Functional Data Processing

Java Programming#

Lecture 39: Lambda Expressions and Functional Interfaces#

GTU Diploma in Computer Engineering#

layout: two-cols#

Learning Objectives#

Lecture Overview#

What is Functional Programming?#

Key Concepts#

Java 8 and Functional Programming#

Introduction to Lambda Expressions#

Syntax#

Comparison with Anonymous Classes#

Lambda Expression Examples#

Basic Examples#

Functional Interfaces#

@FunctionalInterface Annotation#

Using Functional Interfaces#

Built-in Functional Interfaces#

Predicate<T>#

Function<T, R>#

Consumer<T> and Supplier<T>#

Consumer<T> - Consumes input, returns nothing#

Supplier<T> - Supplies a value#

Method References#

Types of Method References#

Constructor References#

Custom Functional Interfaces#

Using Custom Functional Interfaces#

Functional Programming Patterns#

Higher-Order Functions#

Currying and Partial Application#

Functional Composition#

Best Practices#

1. Keep Lambdas Simple and Readable#

2. Prefer Method References When Appropriate#

3. Use Appropriate Functional Interfaces#

Performance Considerations#

Hands-on Exercise 1: Event Processing System#

Hands-on Exercise 2: Functional Calculator#

Hands-on Exercise 3: Data Processing Pipeline#

Exercise Solutions: Event Processing System#

Summary#

Key Concepts Covered#

Benefits of Functional Programming#

When to Use Functional Programming#

Next Lecture Preview#

Lecture 40: Stream API#

Preparation#

Thank You!#

Questions and Discussion#

Resources for Further Learning#