Introduction to Functional Programming in Java

Advanced14 min read•Updated: 2025-01-15

🚀 Introduction to Functional Programming in Java

Introduction

Since Java 8, Java transitioned from being a purely Object-Oriented language into a multi-paradigm language that embraces Functional Programming (FP).

In traditional imperative programming, code focuses on how to achieve a task using explicit state mutation and loops. In functional programming, code focuses on what data transformations should occur using pure functions, declarative pipelines, and immutable state.

⚖️ Imperative vs Functional Style

Let's examine how to filter and sum odd numbers:

1. Imperative Style (State Mutation & Loops)

1List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
2int sumOfOdds = 0; // Mutable state
3 
4for (int n : numbers) {
5    if (n % 2 != 0) {
6        sumOfOdds += n; // Step-by-step state mutation
7    }
8}
9System.out.println("Sum: " + sumOfOdds);

2. Functional Declarative Style (Pipelines & Immutability)

1int sumOfOdds = numbers.stream()
2                       .filter(n -> n % 2 != 0)
3                       .mapToInt(Integer::intValue)
4                       .sum();
5System.out.println("Sum: " + sumOfOdds);

🏛️ Core Tenets of Functional Programming

1┌────────────────────────────────────────────────────────┐
2│             FUNCTIONAL PROGRAMMING PRINCIPLES          │
3├────────────────────────────────────────────────────────┤
4│ 1. First-Class Functions: Functions treated as values  │
5│ 2. Pure Functions: Same input yields same output       │
6│ 3. Side-Effect Free: Does not mutate external variables│
7│ 4. Immutability: Objects cannot change after creation  │
8└────────────────────────────────────────────────────────┘

Pure Functions vs Side Effects:

1// ❌ Impure Function: Mutates external variable
2int counter = 0;
3int incrementAndGet(int value) {
4    counter += value; // Side effect!
5    return counter;
6}
7 
8// ✅ Pure Function: Depends only on inputs, no side effects
9int add(int a, int b) {
10    return a + b;
11}

💼 Why Enterprise Systems Embrace FP in Java:

Thread Safety: Immutable data is inherently safe across concurrent threads without locks.
Maintainability: Short, declarative logic minimizes branching errors.
Composability: Small pure functions can be chained like building blocks.

Next Lesson

Functional Interfaces & the @FunctionalInterface Annotation

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Type Erasure and Bridge Methods Behind the Scenes	Functional Interfaces & the @FunctionalInterface Annotation

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates