UNIT 5
ADVANCED STREAM FEATURES
AND
REGULAR EXPRESSIONS
Importance and Use Cases of Advanced Stream Features
• Efficiency and Performance: Streams allow for efficient data processing by
enabling operations like filtering, mapping, and reducing without the need for
explicit loops.
• Parallel Processing: Streams support parallel execution, which can
significantly improve performance for large datasets by leveraging multi-core
processors.
• Functional Programming
: Streams promote a functional programming style, which can lead to more
predictable and maintainable code by avoiding mutable state and side effects
• Expressiveness:
The Stream API provides a rich set of operations that can be combined in a fl
uent manner,
making the code more expressive and easier to understand
Use Cases of Advanced Stream Features
• Data Transformation: Streams can be used to
transform data from one form to another. For example,
converting a list of stings to uppercase:
List<String> upperCaseNames = names.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
• Filtering Data: Streams make it easy to filter data based on certain criteria.
For instance, filtering out even numbers from a list:
List<Integer> oddNumbers = numbers.stream()
.filter(n -> n % 2 != 0)
.collect(Collectors.toList());
• Aggregation Operations: Streams support aggregation operations like
sum, average, and count. For example, calculating the sum of a list of
integers:
int sum = numbers.stream()
.mapToInt(Integer::intValue)
.sum();
• Parallel Processing: Streams can be processed in parallel to improve
performance. For example, summing a large list of integers in parallel:
int parallelSum = numbers.parallelStream()
.mapToInt(Integer::intValue)
.sum();
• Complex Data Pipelines: Streams can be used to create complex data processing
pipelines. For example, filtering, mapping, and collecting data in a single pipeline:
List<String> result = data.stream()
.filter(d -> d.startsWith("A"))
.map(String::toLowerCase)
.collect(Collectors.toList());
Java's stream API
• Simplified Data Processing
Importance: Advanced stream features simplify complex data processing tasks, making the code more readable and
maintainable by abstracting away the boilerplate code.
Use Cases:
Data Transformation: Converting a list of objects into another form, such as mapping user entities to DTOs (Data
Transfer Objects).
Filtering Data: Easily filtering large datasets based on specific criteria, such as finding all active users or filtering
transactions above a certain threshold.
• Parallel Processing
Importance: Streams can be processed in parallel to leverage multi-core processors, which improves performance
when dealing with large data sets.
Use Cases:
Batch Processing: Handling large batches of data, such as processing millions of records in a database.
Big Data: Performing complex computations over large datasets, like summing up values or aggregating
statistics.
• Functional Programming Integration
Importance: Streams provide a functional programming approach to data processing,
which allows for more expressive and concise code.
Use Cases: Event Handling: Using streams in event-driven systems to handle and
process events functionally.
Custom Collectors: Creating custom collectors for complex data aggregations, such as
grouping and partitioning data.
• Enhanced Debugging and Testing
Importance: Advanced stream features, such as peek and custom collectors, help in
debugging and testing stream operations by providing intermediate operation insights.
Use Cases: Logging: Using peek() to log stream elements as they are processed, which
aids in debugging complex streams.
Testable Pipelines: Breaking down stream operations into smaller, testable units,
making it easier to verify the correctness of each stage.
• Stream Customization and Extension
Importance: Java allows customization and extension of stream
behavior through custom collectors, spliterators, and more, which
increases the flexibility of the stream API.
• Use Cases:
Custom Collectors: Implementing custom collectors for specific
aggregation needs, such as collecting statistics with custom rules.
Spliterators: Creating custom spliterators for non-standard data
sources, like iterating over data structures that aren't inherently
sequential.
Creating Custom Streams
Creating custom streams in Java involves defining a stream from
non-standard data sources or operations that are not directly
supported by the standard Stream API.
This process typically involves the use of
• Spliterator
• Stream.Builder
• Stream.generate methods.
Steps to Create Custom Streams in Java
1. Using Stream.of() and Stream.Builder()
Stream.of(): Creates a stream from a specified set of
elements.
Stream.Builder: Useful when you need to build a stream step
by step.
Stream<String> stream = Stream.of("apple", "banana",
"cherry");
Stream<String> builtStream =
2. Using Stream.generate()
Stream.generate(): Creates an infinite stream where each element
is generated using a Supplier function.
Stream<Double>randomNumbers=Stream.generate(Math::random).li
mit(10);
3. Using Stream.iterate()
Stream.iterate(): Creates an infinite stream where each element is
produced by applying a function to the previous element.
Stream<Integer> evenNumbers = Stream.iterate(0, n -> n +
2).limit(10);
4. Creating Streams from Custom@Override
Data Structures public boolean
class CustomSpliterator implementstryAdvance(Consumer<? super
Spliterator<Integer> { Integer> action) {
private final int[] array; if (index < array.length) {
private int index = 0; action.accept(array[index++]);
public CustomSpliterator(int[] array) return true;
{ }
this.array = array; return false;
} }
@Override @Override
public Spliterator<Integer> trySplit() { public int characteristics() {
int length = array.length - index; return SIZED | SUBSIZED | ORDERED;
if (length <= 1) return null; }
int splitIndex = length / 2 + index; }
Spliterator<Integer> spliterator = new public class CustomStream {
CustomSpliterator(Arrays.copyOfRange(array, public static void main(String[] args) {
index, splitIndex)); int[] array = {1, 2, 3, 4, 5};
index = splitIndex; Spliterator<Integer> spliterator = new
return spliterator; CustomSpliterator(array);
} Stream<Integer> stream =
@Override StreamSupport.stream(spliterator, false);
public long estimateSize() { stream.forEach(System.out::println);
• }
return array.length - index; • }
}
INFINITE STREAMS
