Blog

System Design Interview: java streams api all topics usage and explanation for interview prepration

Posted on by mujeeb1238

“`html



Java Streams API Best Practices

Java Streams API: Best Practices and Improvements

The provided Java code is generally good at demonstrating various applications of Java Streams API; however, there are some improvements and considerations that can be made for best practices, accuracy, and efficiency:

  1. Reuse of Streams: The code attempts to reuse the stringStream which will throw an IllegalStateException because streams cannot be reused once a terminal operation has been invoked.
  2. Method Naming: The method stringTop50 could have a more descriptive name reflecting its functionality, such as filterAndLimitStrings.
  3. Parallel Streams: While using parallel streams, it’s essential to understand the overhead associated with parallelization. It’s usually beneficial for large datasets, and unnecessary use, especially on small data, can degrade performance.
  4. Stateful Operations: The comment regarding stateful vs. stateless operations is slightly misleading in the context provided. While sorted() and distinct() are indeed stateful operations, the comment could provide more clarity on the implications (like performance impacts in parallel processing).
  5. Stream Creation from Array: For the array of Integers, directly using Arrays.stream is an efficient approach, but using IntStream might be more appropriate if dealing with primitive types to avoid boxing and unboxing overhead.
  6. Error and Exception Handling: There should be considerations on error handling in streams, especially when dealing with external operations that might throw exceptions (not applicable in this static context but good for completeness in practical scenarios).
  7. Resource Management: In real-world applications involving streams from I/O operations, ensuring streams are closed properly to free resources is crucial.

Here's the revised and enhanced version of the code:

        
import java.util.*;
import java create List filteredStrings = filterStringsByPrefix(stringList, "b");
        System.out.println("Filtered Strings Starting with 'b': " + filteredStrings);

        /* Stream creation from an array and demonstration of reduce operation */
        int sum = sumArrayElements(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
        System.out.println("Sum of Array Elements: " + sum);

        /* Demonstration of conversion from IntStream to List */
        List integerList = convertStreamToList();
        displayParallelMax(integerBoxed());

        /* Sorting and removing duplicates in a large dataset */
        List uniqueSorted = sortAndDistinct(integerList);
        System.out.println("Distinct and Sorted: " + uniqueSorted.size());
    }

    private static List filterStringsByPrefix(List stringList, String prefix) {
        return stringList.stream()
                         .filter(s -> s.length() > 4)
                         .filter(s -> s.startsWith(prefix))
                         .limit(50) 
                         .collect(Collectors.toList());
    }

    private static int sumArrayElements(int[] array) {
        return Arrays.stream(array).sum();
    }

    private static List convertStreamToList() {
        return IntStream.rangeClosed(1, 100).boxed().collect(Collectors.toList());
    }

    private static void displayParallelMax(List data) {
        Optional max = data.parallelStream().reduce(Integer::max);
        max.ifPresent(maxValue -> System.out.println("Maximum value (Parallel Stream): " + maxValue));
    }

    private static List sortAndDistinct(List data) {
        return data.stream().distinct().sorted().collect(Collectors.toList());
    }

    private static List integerBoxed() {
        return IntStream.rangeClosed(1, 100).boxed().collect(Collectors.toList());
    }

Modifications and Enhancements:

  • Method Extraction: Splitting responsibilities into smaller functions enhances modularity and readability.
  • Stream Reuse Issue: Addressed by ensuring that each stream operation set is fresh and not reused.
  • Primitive Streams: Used int[] with IntStream directly to avoid unnecessary boxing in sum calculation.
  • Error Handling and Resource Management: Not directly applicable in this synthetic example but noted for real-world scenarios.
  • Parallel Stream Consideration: Provided in context where it makes a difference (displayParallelMax), and caution is advised.



```

mujeeb1238

Leave a Reply