Intermediate and Terminal operations In Hindi
जावा प्रोग्रामिंग लैंग्वेज में, जावा स्ट्रीम एपीआई यूजर डिफाइन प्रोग्राम डेटा टाइप एलिमेंट को क्लियर और इजीली आर्डर में रीड करने लायक फॉर्मेट में प्रोसेस और मैनेज करने के लिए कई बिल्ट-इन स्ट्रीम एपीआई ऑपरेशन मेथड प्रोवाइड करता है।
Stream operations in Java are primarily divided into two categories.
- इंटरमीडिएट स्ट्रीम एपीआई डाटा ऑपरेशन।
- टर्मिनल स्ट्रीम एपीआई डाटा ऑपरेशन।
A typical stream pipeline in Java looks like this.
प्रोग्राम डाटा टाइप सोर्स
↓
इंटरमीडिएट डाटा ऑपरेशन
↓
इंटरमीडिएट डाटा ऑपरेशन
↓
टर्मिनल डाटा ऑपरेशन
↓
फाइनल आउटपुट
Example of Stream operations.
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(2, 7, 9, 11, 17, 23, 77);
integers.stream()
.filter(integer -> integer > 7)
.map(integer -> integer + 4)
.forEach(System.out::println);
}
}
So let’s explore the Stream operations in Java programming in detail.
- filter() → इंटरमीडिएट स्ट्रीम डाटा ऑपरेशन।
- map() → इंटरमीडिएट स्ट्रीम डाटा ऑपरेशन।
- forEach() → टर्मिनल स्ट्रीम डाटा ऑपरेशन।
Intermediate Stream Data Operation with Java.
जावा स्ट्रीम में इंटरमीडिएट डाटा ऑपरेशन वे यूजर डिफाइन प्रोग्राम ऑपरेशन होते हैं, जो किसी स्ट्रीम के डाटा वैल्यूज एलिमेंट को प्रोसेस, फ़िल्टर, या यूजर डिफाइन कंडीशन एक्सप्रेशन को ट्रांसफ़ॉर्म करते हैं।
Special features of intermediate stream data.
- इंटरमीडिएट डाटा ऑपरेशन अन्य स्ट्रीम वैल्यू को रिटर्न करते हैं।
- ये डाटा ऑपरेशन लेज़ी नेचर के होते हैं।
- जावा यूजर इंटरमीडिएट डाटा ऑपरेशन को एक साथ चेन कर सकता है।
- ये अपने आप से फ़ाइनल रिज़ल्ट नहीं डिस्प्ले करते हैं।
- इंटरमीडिएट डाटा ऑपरेशन तभी एग्जीक्यूट होते हैं, जब मौजूदा प्रोग्राम में कोई टर्मिनल ऑपरेशन कॉल किया जाता है।
Some common intermediate stream data operation methods in Java.
| # | Common Operation | Intermediate Operations Description |
| 1. | filter() function | This function used to filter elements data base on a specific user define condition |
| 2. | map()function | This function used to convert each element into another data value element |
| 3. | flatMap()function | This function used to convert and flattens multiple streams data element |
| 4. | sorted()function | This function used to sort a give particular data elements value in specific order or sequence |
| 5. | distinct()function | This function used to remove duplicate double data elements values |
| 6. | limit()function | This function used to limit the number of data elements values |
| 7. | skip()function | This function used to skip a specified number of data elements values |
| 8. | peek()function | This function used to perform an action during data element values processing |
filter() intermediate stream data operation.
जावा स्ट्रीम प्रोग्राम में filter() फंक्शन मेथड का यूज़ उन डाटा एलिमेंट को सलेक्ट करने में किया जाता है, जो किसी यूजर डिफाइन एक कस्टम कंडीशन को कम्पलीट करते हैं।
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(4, 9, 29, 48, 59, 69, 78);
integers.stream()
.filter(integer -> integer > 30)
.forEach(System.out::println);
}
}
यहां, इस एक्साम्प्ल में केवल 30 से बड़े इन्टिजर वैल्यू नंबर सलेक्ट कर आउटपुट में डिस्प्ले किए जाते हैं।
map() intermediate stream data operation.
जावा स्ट्रीम प्रोग्राम में map() फंक्शन मेथड का यूज़ हर डाटा प्रोग्राम एलिमेंट वैल्यू को मॉडिफाई करने में किया जाता है।
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(5, 15, 35, 50, 60, 70, 89, 99);
integers.stream()
.map(integer -> integer / 5)
.forEach(System.out::println);
}
}
The original stream data values are modified.
5 → 1
15 → 3
35 → 7
50 → 10
60 → 12
70 → 14
89 → 17
99 → 19
distinct() intermediate stream data operation.
जावा स्ट्रीम प्रोग्राम में distinct() फंक्शन मेथड का यूज़ मौजूदा प्रोग्राम में डुप्लीकेट डाटा एलिमेंट वैल्यू को हटाने में किया जाता है।
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(7, 9, 8, 9, 21, 7, 33, 44, 7);
integers.stream()
.distinct()
.forEach(System.out::println);
}
}
sorted() intermediate stream data operation.
जावा स्ट्रीम प्रोग्राम में sorted() फंक्शन मेथड डाटा एलिमेंट्स को नेचुरल ऑर्डर में सॉर्ट कर असेंन्डिंग आर्डर में अरेंज या मैनेज करता है।
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(99, 1, 33, 3, 77, 55, 66, 2, 7);
integers.stream()
.sorted()
.forEach(System.out::println);
}
}
Intermediate stream data operation in descending order.
import java.util.Arrays;
import java.util.List;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(99, 1, 33, 3, 77, 55, 66, 2, 7);
integers.stream()
.sorted(Comparator.reverseOrder())
.forEach(System.out::println);
}
}
limit() intermediate stream data operation.
जावा स्ट्रीम प्रोग्राम में limit() फंक्शन मेथड उन प्रोग्राम डाटा एलिमेंट्स के नंबर्स वैल्यू को लिमिट कर डिस्प्ले करता है।
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(99, 1, 33, 3, 77, 55, 66, 2, 7, 11, 17);
integers.stream()
.limit(5)
.forEach(System.out::println);
}
}
skip() intermediate stream data operation.
जावा स्ट्रीम प्रोग्राम में skip() फंक्शन मेथड एक फिक्स्ड नंबर में कुछ डाटा एलिमेंट्स वैल्यू को छोड़ देता है।
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(99, 1, 33, 3, 77, 55, 66, 2, 7, 11, 17);
integers.stream()
.skip(7)
.forEach(System.out::println);
}
}
Terminal Operations with Java.
जावा प्रोग्रामिंग लैंग्वेज में टर्मिनल ऑपरेशन्स वे ऑपरेशन्स होते हैं, जो आउटपुट के रूप में एक फाइनल रिजल्ट को डिस्प्ले करते हैं, या मौजूदा प्रोग्राम में एक फाइनल एक्शन को परफॉर्म करते हैं।
Essential features of Terminal Operations with Java.
- टर्मिनल ऑपरेशन्स एक फाइनल रिजल्ट या साइड इफ़ेक्ट को डिस्प्ले करते हैं।
- टर्मिनल ऑपरेशन्स बीच के ऑपरेशन को स्टार्ट करते हैं।
- जावा प्रोग्राम में टर्मिनल ऑपरेशन के बाद, स्ट्रीम डाटा को सामान्य रूप से दोबारा यूज़ नहीं किया जा सकता है।
- जावा में एक स्ट्रीम पाइपलाइन सामान्य रूप से एक टर्मिनल ऑपरेशन के साथ टर्मिनेट होती है।
Common Terminal stream data Operations
| # | Terminal Operation | Common Terminal stream data Description |
| 1. | forEach() function | This method used to perform an action for each data element values |
| 2. | collect()function | This method used to collect data elements into a collection/result output |
| 3. | count()function | This method used to return the number of data elements |
| 4. | reduce()function | This method used to combine elements data into one value |
| 5. | min()function | This method used to find a minimum stream data element |
| 6. | max()function | This method used to find maximum stream data element |
| 7. | findFirst()function | This method used to return the first of data element |
| 8. | findAny()function | This method used to return any data element |
| 9. | anyMatch()function | This method used to check whether any element matches or not n group data element |
| 10. | allMatch()function | This method used to check whether all data elements match or not |
| 11 | noneMatch()function | This method used to check whether no elements match |
forEach() Terminal Operations with Java.
जावा स्ट्रीम प्रोग्राम में forEach() फंक्शन मेथड हर डाटा एलिमेंट पर एक एक्शन को परफॉर्म करता है।
List<String> aeroplane =
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> aeroplane = Arrays.asList(“Airbus A380”, “Boeing 747”, “Boeing 777”, “Airbus A350”);
aeroplane.stream()
.forEach(System.out::println);
}
}
यहाँ ऊपर दिए गए प्रोग्राम में forEach() एक टर्मिनल स्ट्रीम डाटा ऑपरेशन अप्लाई मेथड है।
collect() Terminal Operations with Java.
जावा स्ट्रीम प्रोग्राम में collect() फंक्शन मेथड का यूज़ स्ट्रीम डाटा एलिमेंट्स को कलेक्शन या किसी दूसरे अन्य रिज़ल्ट में कलेक्ट करने में किया जाता है।
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(99, 1, 33, 3, 77, 55, 66, 2, 7, 11, 17);
List<Integer> output = integers.stream()
.filter(integer -> integer > 33)
.collect(Collectors.toList());
System.out.println(output);
}
}
In newer Java versions, Java users can also create it like this.
List<Integer> output =
integers.stream()
.filter(integer -> integer > 37)
.toList();
count() Terminal Operations with Java.
जावा स्ट्रीम प्रोग्राम में count() फंक्शन मेथड एलिमेंट्स का नंबर डिस्प्ले करता है।
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(3, 7, 10, 18, 21, 33, 77);
long count = integers.stream()
.filter(integer -> integer > 9)
.count();
System.out.println(count);
}
}
reduce() Terminal Operations with Java.
जावा स्ट्रीम प्रोग्राम में reduce() फंक्शन मेथड सभी डाटा एलिमेंट्स को एक सिंगल रिज़ल्ट में कंबाइन कर डिस्प्ले करता है।
reduce() Terminal Operations Example: Finding the sum.
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(3, 7, 10, 18, 21, 33, 77);
int total = integers.stream()
.reduce(0, (p, q) -> p + q);
System.out.println(total);
}
}
Its output.
169
जावा में कैलकुलेशन कॉन्सेप्चुअली इस प्रकार है.
3 + 7 + 10 + 18 + 21 + 33 + 77 = 169
min() and max() are terminal operations in Java.
ये जावा स्ट्रीम प्रोग्राम ऑपरेशन मिनिमम और मैक्सिमम वैल्यू को एक्सट्रेक्ट कर डिस्प्ले करता हैं।
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(3, 7, 10, 18, 21, 33, 77);
Optional<Integer> min =
integers.stream().min(Integer::compareTo);
Optional<Integer> max =
integers.stream().max(Integer::compareTo);
System.out.println(min.get());
System.out.println(max.get());
}
}
Its output.
3
77
यहाँ इस एक्साम्प्ल में min() और max() फंक्शन एक Optional वैल्यू को रिटर्न करते हैं, क्योंकि यह एक एम्प्टी स्ट्रीम हो सकती है।
findFirst() terminal operations in Java.
जावा स्ट्रीम प्रोग्राम में findFirst() फंक्शन मेथड पहला एक डाटा एलिमेंट वैल्यू को रिटर्न करता है।
List<Integer> integers =
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class Main {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(3, 7, 10, 18, 21, 33, 77);
Optional<Integer> output = integers.stream().findFirst();
System.out.println(output.get());
}
}
Its output.
3
findAny() terminal operations in Java.
जावा स्ट्रीम प्रोग्राम में findAny() फंक्शन मेथड स्ट्रीम से कोई भी एलिमेंट डाटा वैल्यू को रिटर्न करता है।
Optional<Integer> output =
integers.stream().findAny();
System.out.println(output.get());
यहाँ इस एक्साम्प्ल में स्पेशल रूप से पैरेलल स्ट्रीम के साथ यह यूज़फुल है, जहाँ रिटर्न किया गया डाटा एलिमेंट ज़रूरी नहीं कि पहला हो।
Matching terminal operations in Java.
जावा प्रोग्राम में यूजर डिफाइन कंडीशन को चेक करने के लिए तीन यूज़फुल टर्मिनल ऑपरेशन प्रोवाइड करता है।
anyMatch() terminal operations in Java.
यह मौजूदा प्रोग्राम में चेक करता है कि कम से कम एक डाटा एलिमेंट कंडीशन को कम्पलीट करता है, या नहीं है।
boolean output =
integers.stream()
.anyMatch(integer -> integer > 11);
System.out.println(output);
Its output.
true
allMatch() terminal operations in Java.
यह जावा प्रोग्राम में चेक करता है कि सभी डाटा एलिमेंट वैल्यू कंडीशन को कम्पलीट करते हैं, या नहीं है।
boolean output =
integers.stream()
.allMatch(integer -> integer > 0);
System.out.println(output);
Its output.
true
noneMatch()
यह मौजूदा जावा प्रोग्राम में चेक करता है कि कोई डाटा एलिमेंट कंडीशन को कम्पलीट करता है, या नहीं है।
boolean output =
integers.stream()
.noneMatch(integer ->integer < 0);
System.out.println(output);
Its output.
true
Difference Between Intermediate and Terminal Operations
| # | Intermediate Data Operations | Terminal Data Operations |
| 1. | Intermediate data operations return a stream data output | Terminal stream data operations return a final result or void value |
| 2. | Intermediate data operations are lazy in nature to work | Terminal stream data operations trigger stream data for processing |
| 3. | Intermediate data operations can be chained as nature | Terminal stream data operations usually ends the pipeline system |
| 4. | Intermediate data used for transformation/filtering data or values element | Terminal stream data used to produce final output or result |
| 5. | We used filter() with intermediate data operations | We can used foreach() with terminal data operations |
| 6. | We used map() with intermediate data operations | We can used collect() with terminal data operations |
| 7. | We used sorted() with intermediate data operations | We can used count() with terminal data operations |
| 8. | We used distinct() with intermediate data operations | We can used reduce() with terminal data operations |
| 9. | We used limit() with intermediate data operations | We can used min() / max() with terminal data operations |
| 10. | We used skip() with intermediate data operations | We can used findfirst() with terminal data operations |
A complete example.
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> integers =
Arrays.asList(3, 7, 10, 18, 21, 33, 77);
List<Integer> result =
integers.stream()
.filter(integer -> integer > 21)
.map(integer -> integer * 3)
.sorted()
.collect(Collectors.toList());
System.out.println(result);
}
}
Its output.
[99, 231]
Execution Flow with Stream Data Operations.
Original list data elements
↓
3, 7, 10, 18, 21, 33, 77
↓
filter(integer > 21)
↓
33, 77
↓
map(integer * 3)
↓
99, 231
↓
sorted()
↓
99, 231
↓
collect()
↓
Final list
Here in this example.
- filter() → इंटरमीडिएट
- map() → इंटरमीडिएट
- sorted() → इंटरमीडिएट
- collect() → टर्मिनल
Conclusion of Intermediate and Terminal operations.
जावा प्रोग्राम में इंटरमीडिएट ऑपरेशन प्रोसेसिंग पाइपलाइन को क्रिएट करते हैं, जबकि टर्मिनल ऑपरेशन प्रोसेसिंग को स्टार्ट करता है, और उसे प्रोड्यूस करता है.
As the final result.
डाटा एलिमेंट सोर्स
↓
फ़िल्टर() ← फंक्शन इंटरमीडिएट ऑपरेशन
↓
मैप() ← फंक्शन इंटरमीडिएट ऑपरेशन
↓
सॉर्टेड() ← फंक्शन इंटरमीडिएट ऑपरेशन
↓
कलेक्ट() ← टर्मिनल ऑपरेशन
↓
फाइनल रिज़ल्ट
