DEV Community: Priyank Bhardwaj

Best Practices & Pitfalls

Priyank Bhardwaj — Sat, 04 Apr 2026 05:24:24 +0000

Welcome to Part 8 of the Java Streams series!
In this article, we’ll go beyond syntax and dive into how to use streams effectively in real-world applications.

We’ll cover:

Ordering operations for performance
When not to use streams

Ordering Operations for Efficiency

The order of operations matters a lot in streams.

Bad Example:

numbers.stream()
    .map(n -> {
        System.out.println("Mapping: " + n);
        return n * 2;
    })
    .filter(n -> n > 5)
    .forEach(System.out::println);

Better Example:

numbers.stream()
    .filter(n -> n > 2)
    .map(n -> {
        System.out.println("Mapping: " + n);
        return n * 2;
    })
    .forEach(System.out::println);

Why is this better?

filter reduces the number of elements early
map runs on fewer elements → less computation
Rule of thumb: filter early, map later

Another Optimization Tip

Use short-circuiting operations like:

findFirst()
anyMatch()
limit()

Example:

numbers.stream()
    .filter(n -> n > 2)
    .findFirst();

Stops processing as soon as a match is found.

When NOT to Use Streams

Streams are powerful—but not always the best choice.

1 When Logic is Too Complex

If your stream looks like this:

list.stream()
    .filter(x -> complexCondition(x))
    .map(x -> transform(x))
    .flatMap(x -> anotherComplexStep(x))
    .collect(Collectors.toList());

It might hurt readability.

Prefer a simple loop if:

Logic involves multiple conditions
Debugging is important

2 When You Need Side Effects

Streams are designed for functional-style programming.

Bad practice:

List<Integer> result = new ArrayList<>();

numbers.stream()
    .forEach(n -> result.add(n * 2)); // side effect

Better:

List<Integer> result = numbers.stream()
    .map(n -> n * 2)
    .collect(Collectors.toList());

3 When Performance is Critical (Sometimes)

Streams can be slightly slower than loops due to:

Object creation
Lambda overhead

In tight loops (e.g., millions of iterations), consider traditional loops.

When You Need Indexed Access

Streams don’t provide direct indexing.

for (int i = 0; i < list.size(); i++) {
    // easier with loop
}

Use loops when index matters.

Debugging Difficulty

Debugging streams can be tricky compared to loops.

✔ Tip: Use .peek() for debugging

numbers.stream()
    .peek(n -> System.out.println("Before: " + n))
    .map(n -> n * 2)
    .peek(n -> System.out.println("After: " + n))
    .collect(Collectors.toList());

Final Thoughts

Java Streams are powerful—but like any tool, they should be used wisely.

Best Practices Recap:

Use lazy evaluation to your advantage
Filter early, map later
Prefer immutability and avoid side effects
Use short-circuit operations when possible

Avoid Streams When:

Logic becomes unreadable
You need indexing or mutation
Performance is ultra-critical

What’s Next?

In the next part, we’ll explore:

Streams with Optional & File I/O.

Advanced Stream Techniques in Java 8

Priyank Bhardwaj — Sat, 14 Mar 2026 08:53:47 +0000

Java 8 introduced Streams API, which changed the way developers process collections. Instead of writing long loops and temporary variables, streams allow us to write declarative, functional-style code.

Most developers are comfortable with basic operations like filter, map, and collect. However, Java Streams offer many advanced techniques that can make code more expressive, efficient, and readable.

In this article, we will explore some advanced stream techniques every Java developer should know.

Understanding Lazy Evaluation

One of the most powerful characteristics of streams is lazy evaluation.

Intermediate operations like filter, map, and sorted are not executed until a terminal operation is called.

List<String> names = Arrays.asList("John", "Jane", "Jack", "Doe");

names.stream()
     .filter(name -> {
         System.out.println("Filtering: " + name);
         return name.startsWith("J");
     })
     .map(name -> {
         System.out.println("Mapping: " + name);
         return name.toUpperCase();
     })
     .findFirst();

Output

Filtering: John
Mapping: John

Even though there are multiple elements, only the first match is processed due to short-circuiting.

Why this matters

Lazy evaluation improves performance because the stream processes only what is necessary.

Using flatMap for Nested Collections

When working with nested collections, flatMap is extremely useful.

Example Problem

Suppose we have a list of students and each student has multiple courses.

class Student {
    String name;
    List<String> courses;
}

We want a single list of all courses.

List<Student> students = getStudents();

List<String> courses =
    students.stream()
            .flatMap(student -> student.getCourses().stream())
            .collect(Collectors.toList());

What flatMap does

Instead of producing:

Stream<List<String>>

It flattens the structure into:

Stream<String>

This is extremely powerful when working with nested data structures.

Parallel Streams

Streams can be parallelized easily using parallelStream().

List<Integer> list = Arrays.asList(10, 20, 60, 30, 80, 90);

list.parallelStream()
    .filter(n -> n > 50)
    .map(n -> n * 2)
    .forEach(System.out::println);

Output

160
120
180

Parallel streams use the ForkJoinPool internally.

When to use parallel streams

Good for:

CPU intensive tasks
Large datasets
Independent operations

Avoid when:

Operations involve shared mutable state
Tasks are very small
Order matters heavily

Avoiding Common Stream Mistakes

1 Modifying external variables

Bad practice:

List<Integer> result = new ArrayList<>();

list.stream().forEach(n -> result.add(n * 2));

Better

List<Integer> result =
    list.stream()
        .map(n -> n * 2)
        .collect(Collectors.toList());

2 Overusing Streams

Streams are powerful, but sometimes simple loops are more readable.

Always prioritize clarity over cleverness.

Combining Streams

You can concatenate streams easily.

Stream<Integer> stream1 = Stream.of(1,2,3);
Stream<Integer> stream2 = Stream.of(4,5,6);

Stream<Integer> combined = Stream.concat(stream1, stream2);

combined.forEach(System.out::println);

Output:

1 2 3 4 5 6

Conclusion

Java 8 Streams introduced a powerful functional programming model to Java. While basic operations are widely used, mastering advanced techniques can greatly improve your code quality and performance.

Key takeaways:

Streams use lazy evaluation
flatMap helps flatten nested collections
Advanced collectors enable powerful data transformations
Parallel streams can improve performance for large workloads
Custom collectors provide flexibility for specialized tasks
When used correctly, streams allow you to write clean, concise, and expressive code.

What's next?

In the next part we will see the best practices and some short comings of java streams.

A Complete Guide to Collectors in Java 8 Streams - Part 2

Priyank Bhardwaj — Wed, 04 Mar 2026 06:41:26 +0000

In the last part we saw,

What is a Collector?
How collect() Works Internally
Commonly Used Built-in Collectors
Grouping and Partitioning

Now we will continue and take a dive into

Downstream Collectors (Advanced)
collectingAndThen()
Creating a custom collector
Parallel streams and collectors
And more

Downstream Collectors (Advanced)

Collectors can be chained.

Example: Group by department and calculate average salary.

Map<String, Double> avgSalary =
    employees.stream()
             .collect(Collectors.groupingBy(
                 Employee::getDepartment,
                 Collectors.averagingInt(Employee::getSalary)
             ));

Assuming we have the following employee list

List<Employee> employees = Arrays.asList(
    new Employee("Amit", "IT", "Developer", 60000),
    new Employee("Neha", "IT", "Tester", 50000),
    new Employee("Raj", "HR", "Recruiter", 40000),
    new Employee("Simran", "HR", "Manager", 70000),
    new Employee("Karan", "Sales", "Executive", 45000)
);

Output

{
  IT=55000.0,
  HR=55000.0,
  Sales=45000.0
}

Breakdown

IT → (60000 + 50000) / 2 = 55000.0
HR → (40000 + 70000) / 2 = 55000.0
Sales → (45000) / 1 = 45000.0

mapping() Collector

Map<String, List<String>> namesByDept =
    employees.stream()
             .collect(Collectors.groupingBy(
                 Employee::getDepartment,
                 Collectors.mapping(
                     Employee::getName,
                     Collectors.toList()
                 )
             ));

Output

{
  IT=[Amit, Neha],
  HR=[Raj, Simran],
  Sales=[Karan]
}

How It Works

groupingBy(Employee::getDepartment) → Groups employees by department.

mapping(Employee::getName, toList()) → Instead of collecting full Employee objects, it extracts only the name.

Result type: Map<String, List<String>>

`collectingAndThen()`

Applies finishing transformation.

Example: Make result immutable.

List<String> names =
    employees.stream()
             .map(Employee::getName)
             .collect(Collectors.collectingAndThen(
                 Collectors.toList(),
                 Collections::unmodifiableList
             ));

Output

[Amit, Neha, Raj, Simran, Karan]

Creating a Custom Collector

Sometimes built-in collectors are not enough.

You can create one using:

Collector.of(
    supplier,
    accumulator,
    combiner,
    finisher
);

Example: Collect into a StringBuilder.

Collector<String, StringBuilder, String> customCollector =
    Collector.of(
        StringBuilder::new,
        StringBuilder::append,
        StringBuilder::append,
        StringBuilder::toString
    );

Usage:

String result =
    Stream.of("A", "B", "C")
          .collect(customCollector);

Output

ABC

How It Works

1 Supplier

Creates a new StringBuilder

2 Accumulator

Appends each element to the StringBuilder:

Append "A" → "A"
Append "B" → "AB"
Append "C" → "ABC"

3 Combiner

Used only in parallel streams to merge partial results.
In sequential streams, it’s effectively not needed.

4 Finisher

Converts StringBuilder to String.

Parallel Streams & Collectors

Collectors must be:

Associative
Non-interfering
Stateless

If you use parallel streams:

stream.parallel().collect(...)

The combiner becomes critical.

Avoid shared mutable state outside collector.

Bad code:

List<String> list = new ArrayList<>();
stream.forEach(list::add); // Not thread-safe

Good code:

stream.parallel().collect(Collectors.toList());

Performance Considerations

groupingByConcurrent() is better for parallel streams

Avoid unnecessary boxing (mapToInt() when possible)

Prefer primitive collectors (summingInt) over reduce()

Best Practices

✔ Prefer built-in collectors
✔ Use downstream collectors effectively
✔ Handle duplicate keys in toMap()
✔ Avoid side effects
✔ Use collectingAndThen() for immutability
✔ Use primitive streams when possible

When to Use `collect()` vs `reduce()`

Use:

reduce() → For immutable reduction

collect() → For mutable accumulation (most real-world cases)

Conclusion

Collectors are not just about converting streams into lists.

They allow you to:

Transform
Group
Aggregate
Partition
Summarize
Build custom reduction logic

Mastering Collectors means mastering the real power of Java 8 Streams.

What's next?

This concludes collectors in depth, next we will see Advanced Stream Techniques.

A Complete Guide to Collectors in Java 8 Streams - Part 1

Priyank Bhardwaj — Sun, 22 Feb 2026 07:04:19 +0000

In the last few parts we covered intermediate and terminal functions, now we will deep dive into collectors.

If map() and filter() transform your data,
collect() is what turns it into something meaningful.

In this article, we’ll go deep into:

What Collectors are
How collect() works internally
Built-in collectors (with real-world examples)
Downstream collectors
Custom collectors
Performance considerations
Best practices

Let’s dive in.

What is a Collector?

In Java 8, a Collector is a mechanism used to accumulate elements of a stream into a final result.

It is defined in:

java.util.stream.Collectors

The collect() method is a terminal operation, meaning it produces a result and closes the stream.

Example:

List<String> names = 
    Stream.of("Priyank", "Rahul", "Ram")
          .collect(Collectors.toList()); // [Priyank,Rahul,Ram]

Here:

Stream elements → Collected into a List
Collectors.toList() → defines how accumulation happens

How `collect()` Works Internally

The collect() method takes a Collector, which internally consists of:

Supplier → Creates a new mutable container
Accumulator → Adds elements into the container
Combiner → Merges two containers (used in parallel streams)
Finisher → Final transformation (optional)
Characteristics → Optimization hints

Conceptually:

<R> R collect(Collector<T, A, R> collector)

Where:

T = Stream element type
A = Intermediate accumulation type
R = Final result type

Commonly Used Built-in Collectors

Let’s explore the most important ones.

1 toList()

List<Integer> list = 
    Stream.of(1, 2, 3)
          .collect(Collectors.toList()); // {1,2,3}

Note:
Collectors.toList() does not guarantee the type (could be ArrayList, but not specified).

If you need a specific type:

.collect(Collectors.toCollection(LinkedList::new));

2 toSet()

Set<String> uniqueNames =
    Stream.of("A", "B", "A")
          .collect(Collectors.toSet()); // [A,B]

Removes duplicates automatically.

3 toMap()
Very powerful — and very dangerous if used incorrectly.

Map<String, Integer> map =
    Stream.of("Java", "Python", "Go")
          .collect(Collectors.toMap(
              s -> s,
              s -> s.length()
          ));

Duplicate keys will throw:

IllegalStateException: Duplicate key

Safe version:

Collectors.toMap(
    keyMapper,
    valueMapper,
    (existing, replacement) -> existing
)

This tells Java what to do when a duplicate key occurs.

existing → value already present in the map
replacement → new value being added for the same key

Returning existing means:

“Ignore the new value and keep the old one.”

So instead of throwing an exception, Java resolves the conflict gracefully.

4 joining()

Perfect for String concatenation.

String result =
    Stream.of("Java", "is", "awesome")
          .collect(Collectors.joining(" "));

Output

Java is awesome

With prefix and suffix:

String result =
    Stream.of("Java", "is", "awesome")
          .collect(Collectors.joining(", ", "[", "]"));

Output

[Java,is,awesome]

It behaves like:

prefix + element1 + delimiter + element2 + ... + suffix

5 counting()

Collectors.counting() is really powerful when it comes to grouping.

Example: Count students per department

Map<String, Long> result =
    students.stream()
            .collect(Collectors.groupingBy(
                Student::getDepartment,
                Collectors.counting()
            ));

Output

{
  "IT"=5,
  "HR"=3,
  "Finance"=4
}

6 summing/averaging/max/min

int total =
    employees.stream()
             .collect(Collectors.summingInt(Employee::getSalary));

Other variants:

summingLong
summingDouble
averagingInt
maxBy
minBy

Replace summingInt by other variants as required.

Grouping and Partitioning (Most Powerful Use Case)

This is where collectors shine.

groupingBy()

Example: Group employees by department.

Map<String, List<Employee>> grouped =
    employees.stream()
             .collect(Collectors.groupingBy(Employee::getDepartment));

Output

{
  "IT" → [emp1, emp2],
  "HR" → [emp3]
}

Multi-Level Grouping

Problem statement: For a given list of employees, find the employees in each department as per their roles.

Map<String, Map<String, List<Employee>>> result =
    employees.stream()
             .collect(Collectors.groupingBy(
                 Employee::getDepartment,
                 Collectors.groupingBy(Employee::getRole)
             ));

Considering the following Employee list

Employee("Aman", "IT", "Developer",50000)
Employee("Priya", "IT", "Developer",70000)
Employee("Rohit", "IT", "Manager",40000)
Employee("Neha", "HR", "Recruiter",80000)
Employee("Simran", "HR", "Manager",30000)

Output

{
  "IT" = {
      "Developer" = [
          Employee{name='Aman', department='IT', role='Developer',salary=50000},
          Employee{name='Priya', department='IT', role='Developer',salary=70000}
      ],
      "Manager" = [
          Employee{name='Rohit', department='IT', role='Manager',salary=40000}
      ]
  },

  "HR" = {
      "Recruiter" = [
          Employee{name='Neha', department='HR', role='Recruiter',salary=80000}
      ],
      "Manager" = [
          Employee{name='Simran', department='HR', role='Manager',salary=30000}
      ]
  }
}

Grouping with downstream collectors

Map<String, Long> countByDept =
    employees.stream()
             .collect(Collectors.groupingBy(
                 Employee::getDepartment,
                 Collectors.counting()
             ));

Output

{
"IT" = 3,
"HR" = 2
}

partitioningBy()

Used when condition is boolean.

Map<Boolean, List<Employee>> partitioned =
    employees.stream()
             .collect(Collectors.partitioningBy(
                 e -> e.getSalary() > 50000
             ));

Result

true → Salary of employees > 50000

false → Others

What's next?

In part 2 of Collectors in depth, we will see:

Downstream Collectors (Advanced)
collectingAndThen()
Creating a custom collector
Parallel streams and collectors
And more

Terminal Operations in Java Streams

Priyank Bhardwaj — Sat, 21 Feb 2026 06:18:19 +0000

Hi Everyone reading,

In the previous article, we explored Intermediate Operations in Java Streams — how they transform and prepare data.

Now it’s time to understand the final and most important step of stream processing:

Without a terminal operation, a stream does nothing.

Let’s understand why.

What are Terminal Operations?

Terminal operations:

Produce a result.
Trigger execution of intermediate operations.
Close the stream after execution.
Cannot be reused once executed.

Example

List<Integer> list = List.of(1,2,3,4,5);

list.stream()
    .filter(n -> n % 2 == 0)
    .forEach(System.out::println);   // Terminal operation

Here:

filter() → Intermediate

forEach() → Terminal (executes the stream)

Why Terminal Operations Are Important

Streams are lazy.

Intermediate operations build a pipeline, but execution starts only when a terminal operation is called.

No terminal operation → No processing.

Types of Terminal Operations

Terminal operations can be grouped into:

Iteration operations
Reduction operations
Collection operations
Matching operations
Finding operations

Let’s explore each.

1 forEach()

Used to iterate over elements.

List<String> names = List.of("Ram", "Amit", "Shyam");

names.stream()
     .forEach(System.out::println);

Output

Ram
Amit
Shyam

Note: Prefer forEachOrdered() when working with parallel streams and order matters.

2 collect()

Most powerful terminal operation.

Used to collect stream elements into:

List
Set
Map
String
Custom collections

Collect to List

List<Integer> evenNumbers = 
    List.of(1,2,3,4,5).stream()
        .filter(n -> n % 2 == 0)
        .collect(Collectors.toList()); // [2,4]

Collect to Map

Map<String, Integer> map =
    List.of("Ram", "Amit", "Shyam").stream()
        .collect(Collectors.toMap(
            name -> name,
            name -> name.length()
        )); // {Ram=3, Amit=4, Shyam=5}

3 reduce()

Used to combine elements into a single result.

Example: Sum of numbers

int sum = List.of(1,2,3,4)
              .stream()
              .reduce(0, (a,b) -> a + b);

System.out.println(sum);

Output

Used for:

Sum
Product
Custom aggregation

4 count()

Returns number of elements.

long count = List.of(1,2,3,4,5)
                 .stream()
                 .filter(n -> n > 2)
                 .count();

System.out.println(count);

Output

In the above example, we only count the numbers that are greater than 2.

5 anyMatch(), allMatch(), noneMatch()

Used for condition checking.

boolean anyEven =
    List.of(1,3,5,6).stream()
        .anyMatch(n -> n % 2 == 0); // true

boolean allPositive =
    List.of(1,2,3).stream()
        .allMatch(n -> n > 0); // true

boolean result = List.of(5, 10, 15, 20).stream()
                     .noneMatch(n -> n < 0); // true

These return boolean.

6 findFirst() and findAny()

Return an Optional.

Optional<Integer> first =
    List.of(10,20,30)
        .stream()
        .findFirst(); // Optional[10]

findAny() is useful with parallel streams.

Optional<Integer> result =
                List.of(10, 20, 30, 40, 50)
                    .parallelStream()
                    .findAny(); // Optional[30]

Note: In the output of findAny(), there could be any element within the provided list in the output. In this case it was Optional[30], but 30 could be 10,20,40 or 50. findAny() returns any one element in the given list.

7 min() and max()

Find minimum or maximum element.

Optional<Integer> max =
    List.of(1,5,2,9,3)
        .stream()
        .max(Integer::compareTo); // 9

Optional<Integer> min =
    List.of(1,5,2,9,3)
        .stream()
        .min(Integer::compareTo); // 1

Important Characteristics of Terminal Operations

Feature	Description
Triggers Execution	Executes all intermediate operations
Produces Result	Returns value or side effect
Closes Stream	Stream cannot be reused
Non-lazy	Actually performs computation

Stream Cannot Be Reused

Stream<Integer> stream = Stream.of(1,2,3);

stream.forEach(System.out::println);

// This will throw IllegalStateException
stream.count();

Once a terminal operation is called, the stream is closed.

Real-World Example (Employee Processing)

Problem statement: For a given list of employees, find the average salary.

class Employee {
    String name;
    int salary;

    Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    public String toString() {
        return name + " : " + salary;
    }
}

public class Main {
    public static void main(String[] args) {

        List<Employee> employees = List.of(
                new Employee("Ram", 50000),
                new Employee("Amit", 70000),
                new Employee("Shyam", 40000),
                new Employee("Ankit", 90000)
        );

        // Get average salary
        double avgSalary = employees.stream()
                .mapToInt(e -> e.salary)
                .average()
                .orElse(0);

        System.out.println("Average Salary: " + avgSalary);
    }
}

Output

Average Salary: 62500.0

Intermediate vs Terminal Operations

Intermediate	Terminal
Returns Stream	Returns result
Lazy	Executes pipeline
Can chain	Ends stream
`filter()`, `map()`	`collect()`, `reduce()`, `count()`

Conclusion

Terminal operations are the final step in stream processing.

They:

Execute the pipeline
Produce meaningful results
Close the stream

Mastering terminal operations like collect(), reduce(), count(), and findFirst() makes you confident with Java Streams in real-world applications.

What’s Next?

In the next article, we will explore:
Collectors in depth

Intermediate Operations in Java Streams — A Complete Guide for Developers

Priyank Bhardwaj — Thu, 19 Feb 2026 05:46:49 +0000

In the previous article, we explored how to create streams in Java using:

Collections
Arrays
Stream.of()
Stream.generate()

Now that we know how to create streams, it’s time to understand the real power of Java Streams — Intermediate Operations.

Intermediate operations allow us to transform, filter, and manipulate data inside a stream before producing the final result.

Let’s dive deep into intermediate operations in Java Streams with practical examples.

What are Intermediate Operations?

Intermediate operations are operations that:

Transform a stream into another stream
Do NOT produce final results
Are lazy (they run only when a terminal operation is executed)
Can be chained together

Example

List<Integer> list = List.of(1, 2, 3, 4, 5);

list.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * 2)
    .forEach(System.out::println);

Here:

filter() → intermediate
map() → intermediate
forEach() → terminal operation

Without a terminal operation, intermediate operations won’t execute.

Why Intermediate Operations Are Lazy?

Streams use lazy evaluation to improve performance.

This means:

No processing happens until a terminal operation is called
Operations are applied only when needed
Helps optimize performance

Example

Stream<Integer> stream = Stream.of(1,2,3,4,5)
        .filter(n -> {
            System.out.println("Filtering: " + n);
            return n % 2 == 0;
        });

System.out.println("No terminal operation yet!");

Nothing prints because no terminal operation is present.

Add terminal operation:

stream.forEach(System.out::println);

Now filtering happens.

Common Intermediate Operations in Java Streams

Let’s explore the most important ones.

1. `filter()`

Used to filter elements based on condition.

Syntax
stream.filter(condition)

Example

List<String> names = List.of("Ram", "Shyam", "Amit", "Ankit");

names.stream()
     .filter(name -> name.startsWith("A"))
     .forEach(System.out::println);

Output

Amit
Ankit

2. `map()`

Transforms each element into another form.

Syntax
stream.map(function)

Example

List<Integer> numbers = List.of(1,2,3,4);

numbers.stream()
       .map(n -> n * n)
       .forEach(System.out::println);

Output

Used for:

Transforming data
Converting objects
Extracting fields

3. `flatMap()`

Used to flatten nested structures.

Example: List of lists

List<List<Integer>> list = List.of(
        List.of(1,2),
        List.of(3,4),
        List.of(5,6)
);

list.stream()
    .flatMap(l -> l.stream())
    .forEach(System.out::println);

Output

1 2 3 4 5 6

flatMap() converts Stream → Stream

4. distinct()

Removes duplicate elements.

Example

List<Integer> numbers = List.of(1,2,2,3,4,4,5);

numbers.stream()
       .distinct()
       .forEach(System.out::println);

Output

1 2 3 4 5

5. sorted()

Sorts stream elements.

Natural sorting

List<Integer> list = List.of(5,1,4,2,3);

list.stream()
    .sorted()
    .forEach(System.out::println);

Output

Custom sorting

List<String> names = List.of("Ram","Amit","Shyam");

names.stream()
     .sorted((a,b) -> b.compareTo(a))
     .forEach(System.out::println);

Output

Amit
Ram
Shyam

Note: The sorted() function first sorts the entire list and only after it finishes its operation, forEach() prints the list.

6. `limit()`

Limits number of elements.

Stream.iterate(1, n -> n + 1)
      .limit(5)
      .forEach(System.out::println);

Output

7. `skip()`

Skips first N elements.

List<Integer> list = List.of(1,2,3,4,5,6);

list.stream()
    .skip(3)
    .forEach(System.out::println);

Output

4 
5 
6

8. `peek()`

Used for debugging (not recommended for logic).

List<Integer> list = List.of(1,2,3);

list.stream()
    .peek(n -> System.out.println("Processing: " + n))
    .map(n -> n * 2)
    .forEach(System.out::println);

Output

Processing: 1
2
Processing: 2
4
Processing: 3
6

Used mainly for:

Debugging
Logging stream flow

Chaining Multiple Intermediate Operations

This is where streams make coding simpler and easier to comprehend.

List<String> names = List.of("Ram", "Amit", "Shyam", "Ankit", "Rahul");

names.stream()
     .filter(n -> n.startsWith("A"))
     .map(String::toUpperCase)
     .sorted()
     .forEach(System.out::println);

Output

AMIT
ANKIT

Key Characteristics of Intermediate Operations

Feature	Description
Lazy	Executes only after terminal operation
Returns Stream	Always returns another stream
Chainable	Multiple operations can be chained
Non-destructive	Original data remains unchanged

Real-World Example (Employee Processing)

Problem statement: Given a list of employees, print the names of all the employees with salary greater than 50000 in descending order of their salaries i.e employee with highest salary should be printed first.

class Employee {
    String name;
    int salary;

    Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    public String toString() {
        return name + " : " + salary;
    }
}

public class Main {
    public static void main(String[] args) {

        List<Employee> employees = List.of(
                new Employee("Ram", 50000),
                new Employee("Amit", 70000),
                new Employee("Shyam", 40000),
                new Employee("Ankit", 90000)
        );

        employees.stream()
                .filter(e -> e.salary > 50000)
                .sorted((a,b) -> b.salary - a.salary)
                .map(e -> e.name)
                .forEach(System.out::println);
    }
}

Output

Ankit
Amit

Conclusion

Intermediate operations are the backbone of Java Streams.

They help you:

Write clean functional code
Process data efficiently
Avoid complex loops
Improve readability and performance

Once you master intermediate operations like filter(), map(), flatMap(), and sorted(), you unlock the true power of Java Streams.

What’s Next?

In the next article, we’ll cover:

Terminal Operations in Java Streams

forEach()
collect()
reduce()
count()
findFirst()
anyMatch()

This is Part 4 of the Java Streams Series.

If you find it insightful, please share your feedback. Also let me know if you have used builder pattern in your projects.

Next Up: Terminal Operations!

Creating Java Streams

Priyank Bhardwaj — Sat, 08 Nov 2025 11:00:07 +0000

In the last part, we explored the Functional Interfaces — Predicate, Function, Consumer, Supplier and few more — that form the foundation of stream operations.

Now, it’s time to understand how streams are created. After all, before you can map, filter, or collect data, you need a stream source.

What Is a Stream Source?

A Stream in Java doesn’t store data itself. It’s a sequence of elements sourced from:

Collections
Arrays
Static factory methods (Stream.of())
Functions that generate infinite streams

1. From Collections

The most common way to get a stream is from a Collection (like List, Set, etc.).

Every collection in Java 8 and later comes with two methods:

stream() – creates a sequential stream

parallelStream() – creates a parallel stream for multi-threaded processing

import java.util.*;

public class StreamFromCollection {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Arjun", "Bhima", "Karna", "Nakul");

        // Sequential Stream
        System.out.println("Sequential Stream:");
        names.stream()
             .filter(name -> name.startsWith("K"))
             .forEach(System.out::println);

        // Parallel Stream
        System.out.println("\nParallel Stream:");
        names.parallelStream()
             .map(String::toUpperCase)
             .forEach(System.out::println);
    }
}

OUTPUT

Sequential Stream:
Karna

Parallel Stream:
ARJUN
BHIMA
KARNA
NAKUL

The order in parallel streams may vary depending on threads.

Takeaways:
Use stream() for predictable sequential processing, and parallelStream() when you can benefit from parallelism that is when performance matters over order and thread-safety.

2. From Arrays

The Arrays class provides a convenient stream() method:

import java.util.Arrays;
import java.util.stream.IntStream;

public class StreamFromArray {
    public static void main(String[] args) {
        String[] fruits = {"Apple", "Banana", "Cherry"};

        Arrays.stream(fruits)
              .map(String::toUpperCase)
              .forEach(System.out::println);

        int[] numbers = {1, 2, 3, 4, 5};
        IntStream intStream = Arrays.stream(numbers);
        intStream.forEach(System.out::println);
    }
}

OUTPUT

APPLE
BANANA
CHERRY
1
2
3
4
5

Why use Arrays.stream() instead of Stream.of() for arrays?
Because Stream.of(numbers) would create a stream of one element (the entire array), not a stream of its contents.

3. Using `Stream.of()`

Stream.of() can be used to create streams directly from values or object arrays.

import java.util.stream.Stream;

public class StreamOfExample {
    public static void main(String[] args) {
        Stream<String> gods = Stream.of("Indra", "Agni", "Vayu", "Varuna");
        gods.forEach(System.out::println);

        // Heterogeneous data
        Stream<Object> mixed = Stream.of("Hello", 42, true, 3.14);
        mixed.forEach(System.out::println);
    }
}

OUTPUT

Indra
Agni
Vayu
Varuna

Hello
42
true
3.14

When to use:
Use Stream.of() for small sets of elements or when you want a quick ad-hoc stream.

4. Infinite Streams — `iterate()` and `generate()`

Streams can also be infinite, producing values endlessly — unless you limit them using .limit(n).

Stream.iterate()

import java.util.stream.Stream;

public class IterateExample {
    public static void main(String[] args) {
        Stream.iterate(1, n -> n + 2)
              .limit(5)
              .forEach(System.out::println);
    }
}

OUTPUT

Explanation:

Stream.iterate(seed, f)

seed (1) → The initial value of the stream
f (n -> n + 2) → The function that computes the next element based on the previous one

So, the stream goes like:
1 → 3 → 5 → 7 → 9 → ... (infinite, but we limited it to 5)

Stream.generate()

import java.util.stream.Stream;
import java.util.Random;

public class GenerateExample {
    public static void main(String[] args) {
        Stream.generate(() -> new Random().nextInt(100))
              .limit(5)
              .forEach(System.out::println);
    }
}

OUTPUT

Explanation:

Stream.generate(supplier)

supplier → A function (no input, returns a value) that provides stream elements.
Here, we’re generating random integers continuously — .limit(5) ensures we only get 5 numbers.

💡 Important: Always use .limit() with iterate() or generate() — otherwise your program will run forever!

Summary

Source Type	Example	Stream Method	Notes
Collection	`list.stream()`	Sequential stream	Most common source
Array	`Arrays.stream(array)`	Converts array	Works for primitives too
Values	`Stream.of(…)`	Direct stream	Quick for literals
Infinite (iterate)	`Stream.iterate(1, n -> n + 1)`	Iterative stream	Takes seed & function
Infinite (generate)	`Stream.generate(Math::random)`	Supplier stream	Takes supplier only

What’s Next?

Now that we know how to create streams, in Part 4, we’ll dive into Intermediate Operations —
methods like map(), filter(), sorted() and more that transform your stream data step by step.

🔗 Next Up (Part 4): Intermediate Operations

Functional Interfaces You Must Know - The Backbone of Java Streams

Priyank Bhardwaj — Sat, 01 Nov 2025 11:58:27 +0000

Introduction

In the last part, we learned what Streams are and how they simplify working with data in Java. But behind every powerful stream operation like filter(), map(), or forEach(), there’s something magical happening — Functional Interfaces.

Think of them as the heart and soul of Java 8’s functional programming.
Without them, Streams wouldn’t even exist.

Let’s understand these step-by-step — in a simple way.

What Is a Functional Interface?

A Functional Interface is an interface that has exactly one abstract method. This is what allows us to use lambda expressions.

@FunctionalInterface
interface MyPrinter {
    void print(String message);
}

public class Example {
    public static void main(String[] args) {
        // Using lambda
        MyPrinter printer = msg -> System.out.println(msg);
        printer.print("Hello Functional Interfaces!");
    }
}

Key rule: One abstract method = Functional Interface
Annotation: @FunctionalInterface (optional but recommended)

It is highly recommended that the annotation @FunctionalInterface is used to create functional interfaces as:

If you try to add another abstract method it will lead to a compilation error.
The whole reason lambdas work is because the compiler can map the lambda to that single abstract method.
Once there’s ambiguity (more than one abstract method), Java can’t infer what the lambda should implement — so it disallows it.

Note: You can still add default and static methods to your functional interfaces, only condition is that it should have exactly 1 abstract method.

Why Are They So Important?

Functional interfaces make it possible to pass behavior as data.
That’s why you can do things like:

list.stream()
    .filter(name -> name.startsWith("A"))   // Predicate
    .map(String::toUpperCase)               // Function
    .forEach(System.out::println);          // Consumer

Each of those methods (filter, map, forEach) expects a functional interface.

There are some core functional interfaces that are used in streams: Predicate, Function, Consumer , Supplier, Bifunction, UnaryOperator and BinaryOperator.

We will try and understand each of them now.

Predicate

Represents a boolean condition on a value.

Method: boolean test(T t)

Here T is a generic type parameter. It represents the type of the input value that the predicate will test.

Example

Predicate<Integer> isEven = n -> n % 2 == 0;

System.out.println(isEven.test(4));  // true
System.out.println(isEven.test(7));  // false

Used in Streams:
filter() uses a Predicate to decide which elements to keep.

List<Integer> evens = numbers.stream()
                             .filter(n -> n % 2 == 0)
                             .toList();

Function

Takes one value and returns another.

Method: R apply(T t)

Here T,R are generic type parameter. T represents the type of the input value that the Function will apply and R represents the output's return type.

Example

Function<String, Integer> lengthFinder = str -> str.length();
System.out.println(lengthFinder.apply("Java"));  // 4

map() uses a Function to transform data.

List<Integer> lengths = words.stream()
                             .map(String::length)
                             .toList();

Consumer

Takes a value and performs an action, but returns nothing.

Method: void accept(T t)

Example

Consumer<String> printer = msg -> System.out.println("Message: " + msg);
printer.accept("Hello, World!");

forEach() uses a Consumer to process elements.

names.stream()
     .forEach(name -> System.out.println("Hello, " + name));

Supplier

Supplies a value — takes nothing, just gives something back.

Method: T get()

Example:

Supplier<Double> randomValue = () -> Math.random();
System.out.println(randomValue.get());

Used when:
You want to provide values lazily (e.g., in factory methods or testing).

BiFunction

Takes two inputs, returns one output.

Method: R apply(T t, U u)

Here T,R,U are generic type parameter. T,U in BiFunction represents the type of the input value that the Function will apply and R represents the output's return type.

BiFunction<Integer, Integer, Integer> adder = (a, b) -> a + b;
System.out.println(adder.apply(5, 7)); // 12

UnaryOperator

A Function where input and output types are same.

UnaryOperator<Integer> square = n -> n * n;
System.out.println(square.apply(4)); // 16

BinaryOperator

A BiFunction where all types are same.

BinaryOperator<Integer> multiply = (a, b) -> a * b;
System.out.println(multiply.apply(3, 4)); // 12

Relationship in the functional interface hierarchy

Interface	Extends	Method	Use Case
`Function<T, R>`	–	`R apply(T t)`	Converts `T → R`
`UnaryOperator<T>`	`Function<T, T>`	`T apply(T t)`	Transforms an element (`T → T`)
`BiFunction<T, U, R>`	–	`R apply(T t, U u)`	Combines two different types (`T, U → R`)
`BinaryOperator<T>`	`BiFunction<T, T, T>`	`T apply(T t1, T t2)`	Combines two values of same type (`T, T → T`)

Why functional interface are the backbone of java streams?

Every Stream operation depends on these interfaces:

Stream Method	Functional Interface	Purpose
`filter()`	`Predicate<T>`	Keep elements matching a condition
`map()`	`Function<T, R>`	Transform elements
`forEach()`	`Consumer<T>`	Act on each element
`reduce()`	`BinaryOperator<T>`	Combine elements
`sorted()`	`Comparator<T>`	Compare elements

The table shows which stream method uses which functional interface to serve what purpose.

Conclusion

Functional Interfaces are like the grammar of Java 8 Streams.
Once you know their roles, you can easily read and write stream pipelines fluently — just like sentences in Java’s new functional language!

🔗 Next Up (Part 3): Creating Streams

Introduction to Streams

Priyank Bhardwaj — Sat, 11 Oct 2025 12:35:31 +0000

🚀 What Are Streams?

A Stream in Java is a sequence of data elements supporting sequential and parallel aggregate operations.

Simply put, Streams let you process data declaratively — what to do, not how to do it.

They bring a functional programming flavor to Java.

You can think of a Stream as a pipeline of operations that transform data step by step.

Key points:

Streams don’t store data — they operate on existing data sources (like Collections, Arrays, or I/O channels).
They are lazy — computation happens only when a terminal operation is invoked.
They are functional — once used, a Stream cannot be reused.

🆚 Collections vs Streams

Feature	Collections	Streams
Nature	Data structure (stores elements)	Data pipeline (processes elements)
Iteration	External (you control iteration with loops)	Internal (handled by Stream API)
Reusability	Can be reused	Consumed once
Evaluation	Eager (stores all elements)	Lazy (computes on demand)
Example	`List<Integer> list = Arrays.asList(1,2,3);`	`list.stream().filter(n -> n>1)`

👉 In short: Collections are about data storage, Streams are about data processing.

Lambda Notation Refresher

Before Streams, we’d typically write something like:

for (String name : names) {
    if (name.startsWith("A")) {
        System.out.println(name);
    }
}

With Lambdas and Streams, it becomes:

names.stream()
     .filter(name -> name.startsWith("A"))
     .forEach(System.out::println);

See the difference?
No loops, no boilerplate — just intent.

A lambda expression is essentially a short block of code that takes input and returns output, often used as an argument to Stream methods like filter(), map(), and forEach().

The Stream Pipeline

Every Stream operation flows through three main stages:

1. Source

Where data originates — e.g., a collection, array, or file.

Stream<String> stream = List.of("Java", "Python", "C++").stream();

2. Intermediate Operations

Transform or filter data.
These are lazy — they don’t do anything until a terminal operation is called.

Examples:
filter(), map(), sorted(), distinct(), limit()

stream.filter(lang -> lang.startsWith("J"))
      .map(String::toUpperCase);

3. Terminal Operations

Trigger the actual processing and produce a result.

Examples:
forEach(), collect(), count(), findFirst()

long count = List.of("Java", "Python", "C++")
                 .stream()
                 .filter(lang -> lang.startsWith("J"))
                 .count();
System.out.println(count); // Output: 1

Think of it as:

Source → Intermediate Operations → Terminal Operation

Simple Examples to Get Started

Example 1: Filtering and Printing

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);

numbers.stream()
       .filter(number -> number % 2 == 0)
       .forEach(System.out::println);

// Output: 2 4 6

Example 2: Mapping to Another Type

List<String> words = List.of("java", "stream", "api");

List<String> upper = words.stream()
                          .map(String::toUpperCase)
                          .toList();

System.out.println(upper); // [JAVA, STREAM, API]

Example 3: Combining Operations

List<String> names = List.of("Ayush", "Raj", "Anita", "Vikram");

long count = names.stream()
                  .filter(name -> name.startsWith("A"))
                  .map(String::toUpperCase)
                  .count();

System.out.println(count); // 2

Coming Up Next

In upcoming parts, we’ll deep dive into Intermediate Operations like:

filter(), map(), flatMap(), distinct(), sorted(), and more with real-world use cases and performance insights.

But before we go deeper into Stream operations, we need to understand the functional interfaces that make all this possible.

We'll explore:

Predicate, Function, Consumer, Supplier, and BiFunction
How they power Stream methods
When and how to create your own functional interfaces

Stay tuned and follow to get notified when the next part drops!

🔗 Next Up (Part 2): Functional Interfaces You Must Know

Composite Design Pattern — Simplify Tree Structures Like a Pro

Priyank Bhardwaj — Sat, 11 Oct 2025 12:02:05 +0000

Introduction

Have you ever worked with hierarchical structures like files and folders, or UI elements inside a layout?

If yes, you’ve already felt the need for the Composite Design Pattern — even if you didn’t know its name. The Composite Pattern lets you treat individual objects and compositions of objects uniformly.

In simple terms:
It allows clients to deal with a single object or a group of objects in the same way.

The core idea

          Component
         /         \
   Leaf              Composite
                      /     \
                 Leaf       Leaf

Component → defines the common interface for all objects.
Leaf → represents the end objects (no children).
Composite → contains child components (can be both leaves and composites).

Real life Example: File System (Files and Folders)

Let’s implement a simple example in Java.

Step 1: Create the FileSystemComponent interface

interface FileSystemComponent {
    void showDetails();
}

This acts as the common interface for both files and folders.

Step 2: Implement the File class (Leaf)

class File implements FileSystemComponent {
    private String name;

    public File(String name) {
        this.name = name;
    }

    @Override
    public void showDetails() {
        System.out.println("File: " + name);
    }
}

This is our Leaf — will not have any further nodes (refer the UML diagram).

Step 3: Implement the Directory class (Composite)

import java.util.ArrayList;
import java.util.List;

class Directory implements FileSystemComponent {
    private String name;
    private List<FileSystemComponent> children = new ArrayList<>();

    public Directory(String name) {
        this.name = name;
    }

    public void addComponent(FileSystemComponent component) {
        children.add(component);
    }

    public void removeComponent(FileSystemComponent component) {
        children.remove(component);
    }

    @Override
    public void showDetails() {
        System.out.println("Directory: " + name);
        for (FileSystemComponent component : children) {
            component.showDetails();
        }
    }
}

This is the Composite — it can hold both File and Directory objects.

Step 4: Demo — Build a File System Tree

public class CompositePatternDemo {
    public static void main(String[] args) {
        File file1 = new File("resume.pdf");
        File file2 = new File("photo.png");
        File file3 = new File("notes.txt");

        Directory documents = new Directory("Documents");
        Directory pictures = new Directory("Pictures");

        documents.addComponent(file1);
        pictures.addComponent(file2);
        pictures.addComponent(file3);

        Directory home = new Directory("Home");
        home.addComponent(documents);
        home.addComponent(pictures);

        home.showDetails();
    }
}

Output

Directory: Home
Directory: Documents
File: resume.pdf
Directory: Pictures
File: photo.png
File: notes.txt

How It Works

The magic here is polymorphism — both File and Directory implement FileSystemComponent.
This means the client (CompositePatternDemo) doesn’t care whether it’s working with a file or a folder — it just calls showDetails()!

Comparing this example to the component, leaf and composite analogy, here is summary

Role	Class in Example	Responsibility
Component	`FileSystemComponent`	Common interface
Leaf	`File`	Represents end object
Composite	`Directory`	Contains child components

Considerations

Composite can make the design too general, allowing you to add inappropriate objects.
Traversal or ordering logic can become complex if the hierarchy is deep.

When to Use It

You have objects organized in a tree structure (e.g., file systems, organizational charts, menus).
You want to perform operations on both single objects and groups in the same way.
You want to simplify client code that deals with complex hierarchies.

Key Benefits

Simplifies client code dealing with hierarchies
Encourages consistency across components
Makes it easy to add new types of components

This is Part 9 of the Java Design Patterns Series.

If you find it insightful, please share your feedback. Also let me know if you have used composite pattern in your projects.

Next Up: Bridge Design Patterns!

Java 8 Streams Simplified

Priyank Bhardwaj — Sat, 04 Oct 2025 12:13:06 +0000

Streams in java?

Java 8 was a game-changer for developers. It introduced functional programming features like lambdas and the Stream API, making our code cleaner, more readable, and easier to maintain.

But for many developers, Streams can feel a little tricky at first:

What exactly is a stream?
How is it different from a collection?
What are all these functional interfaces like Predicate, Function, Consumer?
When should I use Streams (and when not)?

That’s why I’m starting this series on Java 8 Streams. My goal is to make it concise, practical, and beginner-friendly, with small runnable examples that you can try out immediately.

🎯 What Will This Series Cover?

Here’s the roadmap we’ll follow together:

Part 1: Introduction to Streams

What are Streams?
Collections vs Streams
Stream pipeline (Source → Intermediate → Terminal)
Simple examples to get started

Part 2: Functional Interfaces You Must Know

Predicate, Function, Consumer, Supplier
Other useful ones: BiFunction, UnaryOperator, BinaryOperator
Why they are the backbone of Streams

Part 3: Creating Streams

From Collections and Arrays
Stream.of(), Arrays.stream()
Infinite streams (iterate, generate)
Fun example: Fibonacci sequence

Part 4: Intermediate Operations

map, filter, distinct, sorted, limit, skip, peek
When to use each, with examples

Part 5: Terminal Operations

forEach, collect, reduce
count, anyMatch, allMatch, findFirst, findAny
Real-world example: word frequency counter

Part 6: Collectors in Depth

toList, toSet, toMap
groupingBy, partitioningBy, joining
Example: grouping employees by department

Part 7: Advanced Stream Techniques

flatMap for nested collections
Parallel streams (pros & cons)
Custom collectors (brief overview)

Part 8: Best Practices & Pitfalls

Lazy evaluation explained
Ordering operations for efficiency
When not to use streams

Part 9: Streams with Optional & File I/O

Using Optional with Streams
Reading files using Files.lines()
Example: count unique words in a text file

Part 10: Real-World Use Cases

Employee management scenarios
Data transformation pipelines
Mini project: build a report using Streams

📌 Who Is This Series For?

Java developers who encounter functional programming concepts.
Beginners who find streams confusing or intimidating.
Anyone preparing for Java interviews, where Streams & functional interfaces are hot topics.

✅ What You’ll Gain

By the end of this series, you’ll:

Understand every essential concept of Streams.
Be comfortable using functional interfaces.
Write cleaner, more efficient, and modern Java code.
Have a handy cheat sheet you can refer back to for interviews or projects.

🔗 Next Up (Part 1): Introduction to Streams

Decorator Design Pattern: Adding Flexibility Without Changing Code!

Priyank Bhardwaj — Sat, 04 Oct 2025 09:46:46 +0000

What is decorator design pattern?

The Decorator Pattern is a structural design pattern that allows you to add new functionality to an existing object dynamically, without altering its structure. It’s a flexible alternative to subclassing.

Think of it as wrapping an object to enhance or modify its behavior.

Real-Life Example

Imagine a coffee shop:

A basic coffee costs ₹50.
You can add milk, sugar, or whipped cream as extra toppings.
Each topping adds to the cost without changing the base coffee class.

Java Implementation

Create a Coffee interface

public interface Coffee {
    double getCost();
    String getDescription();
}

Implement a basic coffee

public class SimpleCoffee implements Coffee {

    @Override
    public double getCost() {
        return 50.0;
    }

    @Override
    public String getDescription() {
        return "Simple Coffee";
    }
}

Create an abstract decorator

public abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;

    public CoffeeDecorator(Coffee coffee) {
        this.decoratedCoffee = coffee;
    }

    public double getCost() {
        return decoratedCoffee.getCost();
    }

    public String getDescription() {
        return decoratedCoffee.getDescription();
    }
}

Add concrete decorators

public class MilkDecorator extends CoffeeDecorator {

    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public double getCost() {
        return super.getCost() + 20.0;
    }

    @Override
    public String getDescription() {
        return super.getDescription() + ", Milk";
    }
}

public class SugarDecorator extends CoffeeDecorator {

    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public double getCost() {
        return super.getCost() + 10.0;
    }

    @Override
    public String getDescription() {
        return super.getDescription() + ", Sugar";
    }
}

Client class: Using the decorators

public class Main {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        System.out.println(coffee.getDescription() + " ₹ " + coffee.getCost());

        // Add Milk
        coffee = new MilkDecorator(coffee);
        System.out.println(coffee.getDescription() + " ₹ " + coffee.getCost());

        // Add Sugar
        coffee = new SugarDecorator(coffee);
        System.out.println(coffee.getDescription() + " ₹ " + coffee.getCost());
    }
}

Output

Simple Coffee ₹ 50.0
Simple Coffee, Milk ₹ 70.0
Simple Coffee, Milk, Sugar ₹ 80.0

Key Takeaways

Decorator allows behavior to be added dynamically.
Open/Closed Principle: You can extend functionality without modifying existing code.
Avoid creating complex inheritance trees for every combination of features.

Pros:

More flexible than static inheritance.
Can combine multiple decorators at runtime.
Encourages composition over inheritance.

Cons:

Can become complex with many decorators.
Debugging may be harder due to nested wrappers.

When to Use Decorator Pattern

When you want to add responsibilities to objects dynamically.
When subclassing would result in too many classes.
When you want to avoid modifying the original object’s code.

Summary

The Decorator Pattern is perfect when you need flexible, runtime-added behavior for objects. In our coffee example, toppings could be added in any order without touching the base coffee class.

This is Part 8 of the Java Design Patterns Series.

If you find it insightful, please share your feedback. Also let me know if you have used decorator pattern in your projects.

Next Up: Composite Design Patterns!

DEV Community: Priyank Bhardwaj

Best Practices & Pitfalls

Ordering Operations for Efficiency

Another Optimization Tip

When NOT to Use Streams

Final Thoughts

What’s Next?

Advanced Stream Techniques in Java 8

Understanding Lazy Evaluation

Using flatMap for Nested Collections

Parallel Streams

Avoiding Common Stream Mistakes

Combining Streams

Conclusion

What's next?

A Complete Guide to Collectors in Java 8 Streams - Part 2

Downstream Collectors (Advanced)

How It Works

collectingAndThen()

Creating a Custom Collector

How It Works

Parallel Streams & Collectors

Performance Considerations

When to Use collect() vs reduce()

Conclusion

What's next?

A Complete Guide to Collectors in Java 8 Streams - Part 1

What is a Collector?

How collect() Works Internally

Commonly Used Built-in Collectors

Grouping and Partitioning (Most Powerful Use Case)

What's next?

Terminal Operations in Java Streams

What are Terminal Operations?

Why Terminal Operations Are Important

Types of Terminal Operations

Important Characteristics of Terminal Operations

Stream Cannot Be Reused

Real-World Example (Employee Processing)

Intermediate vs Terminal Operations

Conclusion

What’s Next?

Intermediate Operations in Java Streams — A Complete Guide for Developers

What are Intermediate Operations?

Why Intermediate Operations Are Lazy?

Common Intermediate Operations in Java Streams

1. filter()

2. map()

3. flatMap()

4. distinct()

5. sorted()

6. limit()

7. skip()

8. peek()

Chaining Multiple Intermediate Operations

Key Characteristics of Intermediate Operations

Real-World Example (Employee Processing)

Conclusion

What’s Next?

Creating Java Streams

1. From Collections

2. From Arrays

3. Using Stream.of()

4. Infinite Streams — iterate() and generate()

Summary

What’s Next?

Functional Interfaces You Must Know - The Backbone of Java Streams

Introduction

What Is a Functional Interface?

Why Are They So Important?

Predicate

Function

Consumer

Supplier

BiFunction

UnaryOperator

BinaryOperator

Relationship in the functional interface hierarchy

Why functional interface are the backbone of java streams?

Conclusion

`collectingAndThen()`

When to Use `collect()` vs `reduce()`

How `collect()` Works Internally

1. `filter()`

2. `map()`

3. `flatMap()`

6. `limit()`

7. `skip()`

8. `peek()`

3. Using `Stream.of()`

4. Infinite Streams — `iterate()` and `generate()`