Functional Programming in Java is a style of writing code where you focus on functions and immutability (not changing things). It is a way of programming that treats computation like a mathematical function and avoids changing data or using variables that can change over time.. Java introduced functional programming features in Java 8, including lambdas, streams, and functional interfaces.

Video Explanation​

Watch

Table of Contents​

• Introduction
• Key Concepts
  • Immutability
  • Higher-Order Functions
  • Pure Functions
• Java Functional Programming Features
  • Lambda Expressions
  • Streams API
• Conclusion

Introduction​

Functional programming focuses on using functions to process data, avoid side effects, and work with immutable data. Java 8 introduced lambda expressions, streams for a more functional approach to programming.

Key Concepts​

Immutability​

Immutability means that once an object is created, it cannot be modified. Functional programming encourages immutable data to avoid side effects and make code more predictable.

public final class Person {
    private final String name;
    private final int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // No setters, only getters
}

Higher Order Functions​

Functions that take other functions as arguments or return functions are called higher-order functions.

Function<Integer, Integer> add = x -> x + 1;
Function<Integer, Integer> multiply = x -> x * 2;

Pure Functions​

A function is pure if it always produces the same output for the same input and has no side effects.

public int add(int a, int b) {
    return a + b;  // Always returns the same result
}

Java Functional Programming Features​

Lambda Expressions​

Lambda expressions enable you to pass behavior as arguments to methods, making your code more readable and flexible, especially in contexts like streams and event handling.

Syntax of a Lambda Expression in Java:​

(parameters) -> expression

Example​

(a, b) -> a + b  // A lambda expression that adds two numbers

Streams API​

The Streams API in Java, introduced in Java 8, is a powerful and flexible feature that enables functional-style operations on sequences of elements, such as collections (e.g., List, Set, Map). It allows you to process collections of data in a declarative way, making the code more readable, concise, and expressive.

Syntax​

// From a collection
Stream<T> stream = collection.stream();

Example​

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
int sum = numbers.stream()
                  .filter(n -> n % 2 == 0)   // Filter even numbers
                  .map(n -> n * 2)           // Double each number
                  .reduce(0, (a, b) -> a + b);  // Sum them up

Next Steps​

For a complete guide with detailed examples on lambda syntax, method references, filtering, mapping, and DSA-style stream patterns, see Java Streams API and Lambda Expressions.

Conclusion​

Java's functional programming features such as lambda expressions and the Streams API allow for more concise and readable code.