Lambda Expressions with Functional Interfaces in Java

Overview

Lambda expressions provide a clear and concise way to represent instances of functional interfaces (interfaces with a single abstract method).

Basic Lambda Syntax

@FunctionalInterface interface MyFunction { int operate(int a, int b); } public class BasicLambdaSyntax { public static void main(String[] args) { // Traditional anonymous class MyFunction traditional = new MyFunction() { @Override public int operate(int a, int b) { return a + b; } }; // Lambda expression equivalent MyFunction lambda = (a, b) -> a + b; System.out.println("Traditional: " + traditional.operate(5, 3)); System.out.println("Lambda: " + lambda.operate(5, 3)); // Different lambda syntax variations MyFunction add = (a, b) -> a + b; MyFunction multiply = (int a, int b) -> a * b; MyFunction subtract = (a, b) -> { return a - b; }; System.out.println("Add: " + add.operate(10, 5)); System.out.println("Multiply: " + multiply.operate(10, 5)); System.out.println("Subtract: " + subtract.operate(10, 5)); } }

Built-in Functional Interfaces

1. Predicate

import java.util.*; import java.util.function.Predicate; public class PredicateExample { public static void main(String[] args) { // Predicate - takes one argument, returns boolean Predicate<String> isLong = s -> s.length() > 5; Predicate<Integer> isEven = n -> n % 2 == 0; Predicate<String> startsWithA = s -> s.startsWith("A"); List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Anna"); List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // Using predicates System.out.println("Is 'Hello' long? " + isLong.test("Hello")); System.out.println("Is 4 even? " + isEven.test(4)); // Filter names with predicate System.out.println("Long names:"); names.stream() .filter(isLong) .forEach(System.out::println); // Even numbers System.out.println("Even numbers:"); numbers.stream() .filter(isEven) .forEach(System.out::println); // Predicate composition Predicate<String> longAndStartsWithA = isLong.and(startsWithA); System.out.println("Long names starting with A:"); names.stream() .filter(longAndStartsWithA) .forEach(System.out::println); // Negate Predicate<String> notLong = isLong.negate(); System.out.println("Short names:"); names.stream() .filter(notLong) .forEach(System.out::println); } }

2. Function

import java.util.*; import java.util.function.Function; public class FunctionExample { public static void main(String[] args) { // Function - takes one argument, produces result Function<String, Integer> stringLength = s -> s.length(); Function<Integer, Integer> square = n -> n * n; Function<String, String> toUpperCase = String::toUpperCase; Function<String, String> addPrefix = s -> "Mr. " + s; List<String> names = Arrays.asList("alice", "bob", "charlie"); // Apply functions System.out.println("Length of 'Hello': " + stringLength.apply("Hello")); System.out.println("Square of 5: " + square.apply(5)); // Transform names System.out.println("Uppercase names:"); names.stream() .map(toUpperCase) .forEach(System.out::println); // Function composition Function<String, String> formatName = addPrefix.andThen(toUpperCase); System.out.println("Formatted names:"); names.stream() .map(formatName) .forEach(System.out::println); // Complex transformation Function<String, String> processName = toUpperCase .andThen(s -> s + "!") .andThen(s -> "Hello " + s); System.out.println("Processed names:"); names.stream() .map(processName) .forEach(System.out::println); } }

3. Consumer

import java.util.*; import java.util.function.Consumer; public class ConsumerExample { public static void main(String[] args) { // Consumer - takes one argument, returns void Consumer<String> print = s -> System.out.println(s); Consumer<String> printUpperCase = s -> System.out.println(s.toUpperCase()); Consumer<Integer> printSquare = n -> System.out.println(n * n); List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); // Using consumers print.accept("Hello World"); printUpperCase.accept("hello world"); // Process collections System.out.println("Names:"); names.forEach(print); System.out.println("Names in uppercase:"); names.forEach(printUpperCase); // Consumer chaining Consumer<String> printAndUpperCase = print.andThen(printUpperCase); System.out.println("Chained consumers:"); printAndUpperCase.accept("test"); // Complex consumer Consumer<String> detailedPrint = s -> { System.out.println("Length: " + s.length()); System.out.println("First char: " + s.charAt(0)); System.out.println("Value: " + s); System.out.println("---"); }; System.out.println("Detailed print:"); names.forEach(detailedPrint); } }

4. Supplier

import java.util.*; import java.util.function.Supplier; import java.time.LocalDateTime; public class SupplierExample { public static void main(String[] args) { // Supplier - takes no arguments, produces result Supplier<String> currentTime = () -> LocalDateTime.now().toString(); Supplier<Double> randomNumber = () -> Math.random(); Supplier<List<String>> emptyList = () -> new ArrayList<>(); // Using suppliers System.out.println("Current time: " + currentTime.get()); System.out.println("Random number: " + randomNumber.get()); System.out.println("Empty list: " + emptyList.get()); // Lazy initialization Supplier<String> expensiveOperation = () -> { System.out.println("Performing expensive operation..."); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } return "Expensive Result"; }; System.out.println("Supplier created, but not called yet"); System.out.println("Now calling: " + expensiveOperation.get()); // Supplier for default values Supplier<String> defaultName = () -> "Unknown"; String name = null; String result = (name != null) ? name : defaultName.get(); System.out.println("Result: " + result); // Generate random data Supplier<Integer> randomInt = () -> new Random().nextInt(100); System.out.println("Random numbers:"); for (int i = 0; i < 5; i++) { System.out.println(randomInt.get()); } } }

5. UnaryOperator and BinaryOperator

import java.util.*; import java.util.function.UnaryOperator; import java.util.function.BinaryOperator; public class OperatorExamples { public static void main(String[] args) { // UnaryOperator - takes one argument of type T, returns T UnaryOperator<String> toUpperCase = String::toUpperCase; UnaryOperator<Integer> square = n -> n * n; UnaryOperator<String> addExclamation = s -> s + "!"; // BinaryOperator - takes two arguments of type T, returns T BinaryOperator<Integer> add = (a, b) -> a + b; BinaryOperator<Integer> multiply = (a, b) -> a * b; BinaryOperator<String> concat = (s1, s2) -> s1 + s2; List<String> words = Arrays.asList("hello", "world", "java"); List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); // Using operators System.out.println("Uppercase: " + toUpperCase.apply("hello")); System.out.println("Square: " + square.apply(5)); System.out.println("Add: " + add.apply(10, 20)); System.out.println("Concat: " + concat.apply("Hello", "World")); // Transform list System.out.println("Uppercase words:"); words.stream() .map(toUpperCase) .forEach(System.out::println); // Reduce with binary operator Integer sum = numbers.stream() .reduce(0, add); Integer product = numbers.stream() .reduce(1, multiply); System.out.println("Sum: " + sum); System.out.println("Product: " + product); // Complex transformation chain UnaryOperator<String> processString = toUpperCase .andThen(addExclamation) .andThen(s -> "*** " + s + " ***"); System.out.println("Processed strings:"); words.stream() .map(processString) .forEach(System.out::println); } }

Custom Functional Interfaces

import java.util.*; import java.util.function.*; // Custom functional interfaces @FunctionalInterface interface StringProcessor { String process(String input); // Can have default methods default StringProcessor andThen(StringProcessor after) { return input -> after.process(this.process(input)); } } @FunctionalInterface interface Validator<T> { boolean validate(T value); default Validator<T> and(Validator<T> other) { return value -> this.validate(value) && other.validate(value); } default Validator<T> or(Validator<T> other) { return value -> this.validate(value) || other.validate(value); } } @FunctionalInterface interface Transformer<T, R> { R transform(T input); default <V> Transformer<T, V> andThen(Transformer<R, V> after) { return input -> after.transform(this.transform(input)); } } public class CustomFunctionalInterfaces { public static void main(String[] args) { // Using custom StringProcessor StringProcessor toUpper = String::toUpperCase; StringProcessor addExclamation = s -> s + "!"; StringProcessor addPrefix = s -> "Hello " + s; StringProcessor processor = addPrefix.andThen(toUpper).andThen(addExclamation); System.out.println("Processed: " + processor.process("world")); // Using custom Validator Validator<String> notEmpty = s -> s != null && !s.trim().isEmpty(); Validator<String> isEmail = s -> s.contains("@"); Validator<String> isLongEnough = s -> s.length() >= 5; Validator<String> emailValidator = notEmpty.and(isEmail).and(isLongEnough); System.out.println("Valid email '[email protected]': " + emailValidator.validate("[email protected]")); System.out.println("Valid email 'test': " + emailValidator.validate("test")); // Using custom Transformer Transformer<String, Integer> stringToLength = String::length; Transformer<Integer, String> intToString = Object::toString; Transformer<String, String> toUpperTransformer = String::toUpperCase; Transformer<String, String> complexTransform = toUpperTransformer.andThen(stringToLength).andThen(intToString); System.out.println("Transformed: " + complexTransform.transform("hello")); } }

Method References

import java.util.*; import java.util.function.*; public class MethodReferences { public static void main(String[] args) { List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David"); // 1. Static method reference Function<String, Integer> parseInt = Integer::parseInt; Consumer<String> staticPrint = System.out::println; // 2. Instance method reference of particular object String prefix = "Mr. "; Function<String, String> addPrefix = prefix::concat; // 3. Instance method reference of arbitrary object Function<String, String> toUpperCase = String::toUpperCase; Function<String, Integer> stringLength = String::length; // 4. Constructor reference Supplier<List<String>> listSupplier = ArrayList::new; Function<Integer, String[]> arrayCreator = String[]::new; // Using method references System.out.println("Uppercase names:"); names.stream() .map(String::toUpperCase) .forEach(System.out::println); System.out.println("Name lengths:"); names.stream() .map(String::length) .forEach(System.out::println); // More examples List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); // Static method reference numbers.forEach(System.out::println); // Constructor reference Supplier<HashMap<String, Integer>> mapSupplier = HashMap::new; HashMap<String, Integer> map = mapSupplier.get(); // Complex example with custom class List<Person> people = Arrays.asList( new Person("Alice", 25), new Person("Bob", 30), new Person("Charlie", 35) ); System.out.println("People names:"); people.stream() .map(Person::getName) // Instance method reference .forEach(System.out::println); System.out.println("Sorted by age:"); people.stream() .sorted(Comparator.comparing(Person::getAge)) // Instance method reference .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; } public String getName() { return name; } public int getAge() { return age; } @Override public String toString() { return name + " (" + age + ")"; } } }

Real-World Examples

1. Filtering and Processing Data

import java.util.*; import java.util.function.*; import java.util.stream.*; public class DataProcessing { static class Product { String name; double price; String category; int stock; public Product(String name, double price, String category, int stock) { this.name = name; this.price = price; this.category = category; this.stock = stock; } // Getters public String getName() { return name; } public double getPrice() { return price; } public String getCategory() { return category; } public int getStock() { return stock; } @Override public String toString() { return String.format("%s - $%.2f (%s, stock: %d)", name, price, category, stock); } } public static void main(String[] args) { List<Product> products = Arrays.asList( new Product("Laptop", 999.99, "Electronics", 10), new Product("Phone", 699.99, "Electronics", 25), new Product("Book", 19.99, "Education", 100), new Product("Chair", 149.99, "Furniture", 15), new Product("Desk", 299.99, "Furniture", 8), new Product("Pen", 1.99, "Education", 200) ); // Predicates for filtering Predicate<Product> isElectronics = p -> "Electronics".equals(p.getCategory()); Predicate<Product> isExpensive = p -> p.getPrice() > 100; Predicate<Product> isLowStock = p -> p.getStock() < 20; // Functions for transformation Function<Product, String> getName = Product::getName; Function<Product, Double> getPrice = Product::getPrice; Function<Product, String> toUpperCaseName = p -> p.getName().toUpperCase(); // Consumers for actions Consumer<Product> printProduct = System.out::println; Consumer<Product> printNameAndPrice = p -> System.out.println(p.getName() + " - $" + p.getPrice()); // Process products System.out.println("All Electronics:"); products.stream() .filter(isElectronics) .forEach(printProduct); System.out.println("\nExpensive products:"); products.stream() .filter(isExpensive) .map(toUpperCaseName) .forEach(System.out::println); System.out.println("\nLow stock products:"); products.stream() .filter(isLowStock) .forEach(printNameAndPrice); // Complex processing System.out.println("\nElectronics with low stock:"); products.stream() .filter(isElectronics.and(isLowStock)) .forEach(printProduct); // Calculate total value Double totalValue = products.stream() .mapToDouble(Product::getPrice) .sum(); System.out.println("\nTotal value: $" + totalValue); // Group by category Map<String, List<Product>> byCategory = products.stream() .collect(Collectors.groupingBy(Product::getCategory)); System.out.println("\nProducts by category:"); byCategory.forEach((category, prods) -> { System.out.println(category + ":"); prods.forEach(p -> System.out.println(" " + p.getName())); }); } }

2. Event Handling System

import java.util.*; import java.util.function.*; public class EventHandlingSystem { @FunctionalInterface interface EventListener<T> { void onEvent(T event); default EventListener<T> andThen(EventListener<T> after) { return event -> { this.onEvent(event); after.onEvent(event); }; } } static class EventBus { private Map<Class<?>, List<EventListener<?>>> listeners = new HashMap<>(); public <T> void subscribe(Class<T> eventType, EventListener<T> listener) { listeners.computeIfAbsent(eventType, k -> new ArrayList<>()).add(listener); } @SuppressWarnings("unchecked") public <T> void publish(T event) { List<EventListener<?>> eventListeners = listeners.get(event.getClass()); if (eventListeners != null) { eventListeners.forEach(listener -> ((EventListener<T>) listener).onEvent(event)); } } } // Event classes static class UserLoginEvent { String username; LocalDateTime timestamp; public UserLoginEvent(String username) { this.username = username; this.timestamp = LocalDateTime.now(); } @Override public String toString() { return "UserLoginEvent{username='" + username + "', timestamp=" + timestamp + "}"; } } static class PaymentEvent { String userId; double amount; public PaymentEvent(String userId, double amount) { this.userId = userId; this.amount = amount; } @Override public String toString() { return "PaymentEvent{userId='" + userId + "', amount=" + amount + "}"; } } public static void main(String[] args) { EventBus eventBus = new EventBus(); // Create event listeners using lambdas EventListener<UserLoginEvent> loginLogger = event -> System.out.println("LOG: " + event); EventListener<UserLoginEvent> loginNotifier = event -> System.out.println("NOTIFICATION: User " + event.username + " logged in"); EventListener<UserLoginEvent> loginAuditor = event -> System.out.println("AUDIT: Login recorded for " + event.username); EventListener<PaymentEvent> paymentProcessor = event -> System.out.println("PROCESSING: Payment of $" + event.amount + " from " + event.userId); EventListener<PaymentEvent> paymentLogger = event -> System.out.println("PAYMENT_LOG: " + event); // Subscribe listeners eventBus.subscribe(UserLoginEvent.class, loginLogger); eventBus.subscribe(UserLoginEvent.class, loginNotifier.andThen(loginAuditor)); eventBus.subscribe(PaymentEvent.class, paymentProcessor.andThen(paymentLogger)); // Publish events System.out.println("Publishing events:"); eventBus.publish(new UserLoginEvent("alice123")); System.out.println(); eventBus.publish(new PaymentEvent("bob456", 99.99)); } }

3. Configuration System

import java.util.*; import java.util.function.*; import java.util.concurrent.*; public class ConfigurationSystem { static class ConfigManager { private Map<String, String> config = new ConcurrentHashMap<>(); private List<Consumer<Map<String, String>>> changeListeners = new CopyOnWriteArrayList<>(); public void set(String key, String value) { config.put(key, value); notifyListeners(); } public String get(String key) { return config.get(key); } public void addChangeListener(Consumer<Map<String, String>> listener) { changeListeners.add(listener); } private void notifyListeners() { Map<String, String> snapshot = new HashMap<>(config); changeListeners.forEach(listener -> listener.accept(snapshot)); } } public static void main(String[] args) { ConfigManager configManager = new ConfigManager(); // Configuration validators Predicate<String> isNotEmpty = s -> s != null && !s.trim().isEmpty(); Predicate<String> isNumeric = s -> s.matches("\\d+"); Predicate<String> isBoolean = s -> "true".equals(s) || "false".equals(s); // Configuration transformers Function<String, Integer> toInt = Integer::parseInt; Function<String, Boolean> toBoolean = Boolean::parseBoolean; // Change listeners using lambdas configManager.addChangeListener(config -> { System.out.println("Config changed: " + config); }); configManager.addChangeListener(config -> { String appName = config.get("app.name"); if (appName != null) { System.out.println("App name is now: " + appName); } }); configManager.addChangeListener(config -> { String port = config.get("server.port"); if (port != null && isNumeric.test(port)) { int portNum = toInt.apply(port); if (portNum > 0 && portNum < 65536) { System.out.println("Valid port configured: " + portNum); } else { System.out.println("Invalid port number: " + portNum); } } }); // Set configuration values System.out.println("Setting configuration values:"); configManager.set("app.name", "MyApplication"); configManager.set("server.port", "8080"); configManager.set("debug.mode", "true"); configManager.set("database.url", "jdbc:mysql://localhost:3306/mydb"); // Process configuration with functional interfaces processConfig(configManager, "server.port", isNumeric, toInt, port -> System.out.println("Server port: " + port)); processConfig(configManager, "debug.mode", isBoolean, toBoolean, debug -> System.out.println("Debug mode: " + debug)); } private static <T> void processConfig(ConfigManager config, String key, Predicate<String> validator, Function<String, T> transformer, Consumer<T> processor) { String value = config.get(key); if (value != null && validator.test(value)) { T transformed = transformer.apply(value); processor.accept(transformed); } } }

Best Practices and Common Patterns

import java.util.*; import java.util.function.*; import java.util.stream.*; public class BestPractices { public static void main(String[] args) { List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Diana"); // 1. Use method references when possible names.forEach(System.out::println); // Good names.forEach(s -> System.out.println(s)); // Okay, but verbose // 2. Keep lambdas short and focused Function<String, String> goodLambda = String::toUpperCase; Function<String, String> badLambda = s -> { // Too much logic in lambda if (s == null) return ""; String result = s.trim(); if (result.isEmpty()) return ""; return result.toUpperCase(); }; // 3. Use meaningful parameter names BinaryOperator<Integer> add = (a, b) -> a + b; // Good BinaryOperator<Integer> addBad = (x, y) -> x + y; // Less clear // 4. Combine simple lambdas for complex operations Predicate<String> isLong = s -> s.length() > 5; Predicate<String> startsWithA = s -> s.startsWith("A"); Predicate<String> longAndStartsWithA = isLong.and(startsWithA); // 5. Use existing functional interfaces when possible Consumer<String> printer = System.out::println; // Good // Avoid creating custom functional interfaces for common cases // 6. Consider using streams with lambdas List<String> result = names.stream() .filter(s -> s.length() > 3) .map(String::toUpperCase) .collect(Collectors.toList()); // 7. Handle exceptions properly List<String> numbers = Arrays.asList("1", "2", "three", "4"); numbers.forEach(s -> { try { int num = Integer.parseInt(s); System.out.println("Number: " + num); } catch (NumberFormatException e) { System.out.println("Invalid number: " + s); } }); // 8. Use final or effectively final variables final String prefix = "Hello "; names.forEach(name -> System.out.println(prefix + name)); // 9. Avoid side effects in streams List<String> collected = new ArrayList<>(); names.stream() .filter(s -> s.length() > 3) .forEach(collected::add); // Bad - side effect List<String> collectedGood = names.stream() .filter(s -> s.length() > 3) .collect(Collectors.toList()); // Good // 10. Use composition for complex logic Function<String, String> trim = String::trim; Function<String, String> toUpper = String::toUpperCase; Function<String, String> addExclamation = s -> s + "!"; Function<String, String> process = trim.andThen(toUpper).andThen(addExclamation); System.out.println("Processed: " + process.apply(" hello ")); } }

Key Features Summary

Concise Syntax: Lambdas reduce boilerplate code
Functional Programming: Enable functional programming patterns in Java
Method References: Provide readable shorthand for common operations
Built-in Interfaces: Predicate, Function, Consumer, Supplier, etc.
Composition: Methods can be chained for complex operations
Lazy Evaluation: Suppliers enable lazy initialization
Parallel Processing: Work well with Streams for parallel operations

Lambda expressions and functional interfaces have revolutionized Java programming, making code more readable, maintainable, and expressive while enabling functional programming paradigms.