Java Stream Classes: Functional Data Processing Guide
Java Stream Classes: Functional Data Processing Guide
अगर आप Java programming सीख रहे हैं और modern coding style समझना चाहते हैं, तो Java Stream Classes एक ऐसा topic है जिसे अच्छे से समझना बहुत जरूरी है। Streams Java 8 के साथ introduce किए गए थे ताकि data processing को आसान, readable और functional तरीके से किया जा सके। इस guide में हम detail में समझेंगे कि Java Stream क्या है, कैसे काम करता है, और exam में कौन से points सबसे important हैं।
Introduction to Streams
Stream Java की java.util.stream package का हिस्सा है। यह एक sequence of elements को represent करता है जो data source (जैसे list, array या collection) से लिए जाते हैं और उन पर operations perform किए जाते हैं। Stream का main use होता है data को filter, map, sort या collect करना — वो भी बिना ज्यादा code लिखे।
Simple words में, Stream एक pipeline की तरह काम करता है — जहाँ data एक source से निकलता है, बीच में कुछ transformations होते हैं, और अंत में output generate होता है।
Key Features of Stream
- Stream elements sequential या parallel दोनों तरीके से process हो सकते हैं।
- Stream खुद data store नहीं करता — वो सिर्फ data को process करता है।
- Stream operations functional style में लिखे जाते हैं (जैसे map(), filter(), reduce())।
- Stream reusable नहीं होते — एक बार process होने के बाद दोबारा use नहीं किया जा सकता।
Stream Architecture
Stream API का architecture तीन main steps में divide होता है:
- 1. Source: जहाँ से data आता है — जैसे Array, Collection, या File।
- 2. Intermediate Operations: जो transformation करते हैं जैसे filter(), map(), sorted()।
- 3. Terminal Operations: जो result produce करते हैं जैसे forEach(), collect(), count()।
आइए इसे एक diagram के रूप में समझते हैं:
| Step | Operation Type | Example Methods |
|---|---|---|
| Source | Data Input | Collection.stream() |
| Intermediate | Transformation | filter(), map(), distinct(), sorted() |
| Terminal | Result Output | collect(), forEach(), count(), reduce() |
Creating Streams
Java में Stream को कई तरीकों से create किया जा सकता है। सबसे common तरीका है Collections या Arrays से Stream बनाना।
Example: Creating Stream from List
import java.util.*;
import java.util.stream.*;
public class StreamExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream();
stream.forEach(System.out::println);
}
}
इस example में, numbers.stream() list को Stream में convert करता है और फिर हर element को print करता है।
Intermediate Operations
Intermediate operations वो होते हैं जो Stream को transform करते हैं लेकिन result immediately नहीं देते। ये हमेशा एक new Stream return करते हैं।
1. filter()
filter() method का use किसी condition के अनुसार elements को select करने के लिए किया जाता है।
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
2. map()
map() method elements को transform करता है। Example के लिए, हर number को double करना:
List<Integer> doubled = numbers.stream()
.map(n -> n * 2)
.collect(Collectors.toList());
3. sorted()
sorted() method Stream के elements को sort करता है।
List<Integer> sortedList = numbers.stream()
.sorted()
.collect(Collectors.toList());
4. distinct()
distinct() duplicates remove करने के लिए use किया जाता है।
List<Integer> unique = numbers.stream()
.distinct()
.collect(Collectors.toList());
Terminal Operations
Terminal operations वो होते हैं जो Stream को consume करके final result produce करते हैं।
1. forEach()
हर element पर action perform करने के लिए:
numbers.stream().forEach(System.out::println);
2. collect()
collect() का use Stream result को Collection में convert करने के लिए होता है।
List<Integer> result = numbers.stream()
.filter(n -> n > 2)
.collect(Collectors.toList());
3. count()
count() Stream में elements की संख्या return करता है।
long count = numbers.stream().count();
4. reduce()
reduce() Stream elements को एक single result में combine करता है (जैसे sum या multiplication)।
int sum = numbers.stream()
.reduce(0, (a, b) -> a + b);
Parallel Streams
Parallel Streams multiple threads में data process करते हैं ताकि performance improve हो। इन्हें use करने के लिए बस parallelStream() method call किया जाता है।
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8);
list.parallelStream()
.filter(n -> n % 2 == 0)
.forEach(System.out::println);
Parallel streams large data sets पर तेज performance देते हैं लेकिन small data के लिए ये unnecessary overhead ला सकते हैं।
Stream Pipeline Example
अब एक complete Stream pipeline example देखें जहाँ filter, map और collect तीनों operations use किए गए हैं:
List<String> names = Arrays.asList("Ravi", "Amit", "Suresh", "Anil", "Rahul");
List<String> result = names.stream()
.filter(name -> name.startsWith("A"))
.map(String::toUpperCase)
.sorted()
.collect(Collectors.toList());
System.out.println(result);
Output होगा: [AMIT, ANIL] — यानी सिर्फ वो names जिनका पहला letter “A” है और वो uppercase व sorted format में हैं।
Primitive Stream Classes
Java में performance improve करने के लिए तीन special Stream classes होती हैं जो primitive data types पर काम करती हैं:
| Stream Class | Data Type | Methods |
|---|---|---|
| IntStream | int | sum(), average(), range(), mapToObj() |
| LongStream | long | sum(), min(), max(), rangeClosed() |
| DoubleStream | double | average(), mapToInt(), filter() |
Example using IntStream
import java.util.stream.IntStream;
public class IntStreamExample {
public static void main(String[] args) {
int sum = IntStream.range(1, 6).sum();
System.out.println("Sum = " + sum);
}
}
Difference between Stream and Collection
| Aspect | Stream | Collection |
|---|---|---|
| Storage | Data store नहीं करता | Data store करता है |
| Nature | Functional & Lazy | Eager & Imperative |
| Reuse | Reused नहीं हो सकता | बार-बार use हो सकता है |
| Processing | One time pipeline based | Multiple iterations allowed |
Real World Usage of Streams
- Data filtering जैसे किसी student list में सिर्फ पास students को select करना।
- Transformation जैसे salary list को annual income में convert करना।
- Aggregation जैसे total marks या average निकालना।
- Sorting जैसे names alphabetical order में arrange करना।
Exam-Oriented Notes
- Stream API Java 8 में introduce हुआ था।
- Stream data को functional तरीके से process करता है।
- filter(), map(), reduce(), collect() — ये चार methods सबसे ज्यादा पूछे जाते हैं।
- Stream lazy evaluation follow करता है यानी result तभी generate होता है जब terminal operation call किया जाए।
- Primitive Streams: IntStream, LongStream, DoubleStream performance improve करते हैं।
- parallelStream() multiple threads में data process करने के लिए use होता है।
- Stream और Collection में main difference — Stream data store नहीं करता।
- reduce() operation हमेशा एक single result देता है (जैसे sum या max)।
- Streams chaining allow करते हैं, जिससे readable code लिखा जा सकता है।
- Stream once consumed, दोबारा use नहीं किया जा सकता।
