Stream creation Java In Hindi
जावा प्रोग्रामिंग लैंग्वेज में, जावा स्ट्रीम एपीआई को Java 8 वर्जन में ऐड या लांच किया गया था। जावा प्रोग्राम में यूजर डिफाइन एक स्ट्रीम एलिमेंट्स का एक पर्टिकुलर स्पेसिफिक कॉन्टिनियस सीक्वेंस या ग्रुप ऑफ़ डाटा टाइप एलिमेंट वैल्यूज है, जो जावा डेवलपर को डिक्लेरेटिव आर्डर में कलेक्शन जावा डेटा को फ़िल्टर करने, डाटा को मैप करने, डाटा स्पेसिफिक आर्डर में सीक्वेंस में सॉर्ट अरेंज करने और मिनिमम करने जैसे डाटा ऑपरेशन के फीचर्स प्रोवाइड करता है।
Important about the Stream API – याद रहे, जावा स्ट्रीम कोई डेटा स्ट्रक्चर फॉर्मेट नहीं है, और ये डेटा को स्टोर नहीं करता है। स्ट्रीम एपीआई कलेक्शन, ऐरे या जेनरेटेड डाटा सीक्वेंस जैसे सोर्स से डेटा को जरूरत के अनुसार प्रोसेस करता है।
Creating a stream from a collection in Java.
जावा प्रोग्राम में, स्ट्रीम डाटा टाइप क्रिएट करने का सबसे इजी मेथड के रूप में कलेक्शन डाटा टाइप मेथड पर stream() फंक्शन मेथड को कॉल करना है।
import java.util.*;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
List<String> cars = Arrays.asList(
“Tata Punch”, “Hyundai Creta”, “Mahindra Thar”, “Toyota Innova Hycross” , “Volkswagen Golf”
);
Stream<String> stream = cars.stream();
stream.forEach(System.out::println);
}
}
Here is the stream flow in this program.
लिस्ट डाटा टाइप मेथड
↓
stream() फंक्शन मेथड
↓
Stream<String>
↓
इंटरमीडिएट ऑपरेशन
↓
टर्मिनल ऑपरेशन
Example of stream method.
cars.stream()
.filter(cars -> cars.length() > 5)
.forEach(System.out::println);
Creating a stream from a Set data type in Java.
जावा प्रोग्राम में एक सेट डाटा टाइप से भी stream() फंक्शन मेथड का यूज़ करके एक स्ट्रीम डाटा टाइप एलिमेंट को क्रिएट कर सकते है।
import java.util.*;
public class Main {
public static void main(String[] args) {
Set<Integer> values = new HashSet<>();
values.add(12);
values.add(19);
values.add(29);
values.add(89);
values.add(17);
values.add(99);
values.stream()
.forEach(System.out::println);
}
}
यहाँ इस एक्साम्प्ल में एक Set डाटा टाइप सामान्य रूप से नई डाटा एलिमेंट इंसर्शन ऑर्डर की गारंटी नहीं प्रोवाइड करता है, इस वजह से आउटपुट का ऑर्डर एक स्पेसिफिक Set इम्प्लीमेंटेशन पर डिपेंड कर सकता है।
Creating Stream data from a Map in Java.
जावा प्रोग्राम में एक Map डाटा टाइप में अपने आप में कोई डायरेक्ट stream() फंक्शन मेथड नहीं होता है।
Instead, Java users can create streams from it.
- keySet() function
- values() function
- entrySet() function
A stream of keys in a Java program.
import java.util.*;
import java.util.stream.*;
public class Main {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<>();
map.put(1, “Hero Splendor Plus”);
map.put(2, “TVS Raider 125”);
map.put(3, “Bajaj Pulsar N160”);
map.put(4, “Yamaha MT-15 Version 2.0”);
map.put(5, “Royal Enfield Classic 350”);
// 1. Stream of map data keys
System.out.println(“Stream of map data type keys:”);
map.keySet()
.stream()
.forEach(System.out::println);
// 2. Stream of map data values
System.out.println(“\nStream of map data type values:”);
map.values()
.stream()
.forEach(System.out::println);
// 3. Number of Stream map data type of entries
System.out.println(“\nStream of map data type entries:”);
map.entrySet()
.stream()
.forEach(entry ->
System.out.println(
entry.getKey() + ” – ” + entry.getValue()
)
);
}
}
Creating Stream Data Type from Array in Java.
जावा प्रोग्रामिंग लैंग्वेज में, एक ऐरे डाटा टाइप से एक स्ट्रीम मेथड क्रिएट करने के लिए इसके यूजर को Arrays.stream() फंक्शन मेथड प्रोवाइड करता है।
Object Array Data Type Methods in Java.
import java.util.Arrays;
import java.util.stream.Stream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.DoubleStream;
public class Main {
public static void main(String[] args) {
// String of array data type
String[] course = {“Nielit O Level”, “Nielit A Level”, “Nielit B Level” , “Nielit C Level”};
System.out.println(“String of array data type stream method:”);
Stream<String> courseStream = Arrays.stream(course);
courseStream.forEach(System.out::println);
// Integer primitive array data type method
int[] integer = {23, 77, 98, 33, 44, 100};
System.out.println(“\nIntStream data type method:”);
IntStream intStream = Arrays.stream(integer);
intStream.forEach(System.out::println);
// Long integer primitive array data type method
long[] longinteger = {22L, 44L, 72L, 80L, 99L };
System.out.println(“\nLongStream data type method:”);
LongStream longStream = Arrays.stream(longinteger);
longStream.forEach(System.out::println);
// Double primitive data type array method
double[] decimalinteger = {8.7, 17.1, 33.3, 44.9, 89.2 };
System.out.println(“\nDoubleStream data type method:”);
DoubleStream doubleStream = Arrays.stream(decimalinteger);
doubleStream.forEach(System.out::println);
}
}
Creating a stream in Java using the Stream.of() function method.
जावा प्रोग्रामिंग लैंग्वेज में Stream.of() फंक्शन मेथड का तब यूज़ किया जाता है, जब जावा यूजर के पास पहले से कुछ वैल्यू डिफाइन हों।
Stream<String> stream =
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
Stream<String> stream = Stream.of(“Desktop”, “Laptop”, “Notebook” , “Palmtop”);
stream.forEach(System.out::println);
}
}
Java users can also use the Stream.of() method with integer data types.
Stream<Integer> stream =
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
Stream<Integer> stream = Stream.of(22, 33, 55, 69, 77, 99);
stream.forEach(System.out::println);
}
}
Stream.of() function method with Array data data type.
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
String[] programmig = {“Rust”, “Matlab”, “Pearl”, “Swift C”};
Stream<String> stream = Stream.of(programmig);
stream.forEach(System.out::println);
}
}
यहाँ यह एक्साम्प्ल एक ऐरे के एलिमेंट वाली एक स्ट्रीम डाटा वैल्यू क्रिएट करता है।
Creating an empty stream in Java.
जावा प्रोग्रामिंग में बिना किसी डाटा एलिमेंट वाली एक स्ट्रीम डाटा टाइप को क्रिएट करने के लिए Stream.empty() फंक्शन मेथड प्रोवाइड करता है।
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
Stream<String> stream = Stream.empty();
System.out.println(stream.count());
}
}
Its output.
0
जावा प्रोग्राम में Stream.empty() फंक्शन मेथड तब यूज़ किया जाता है, जब किसी मेथड को स्ट्रीम रिटर्न करने की ज़रूरत होती है. लेकिन रिटर्न करने के लिए कोई डेटा टाइप डिफाइन नहीं होता है।
Example of the Stream.of method.
import java.util.stream.Stream;
public class Main {
public static Stream<String> getCountry(boolean available) {
if (available) {
return Stream.of(“India”, “Usa” , “Uk” , “China”, “Australia”);
}
return Stream.empty();
}
public static void main(String[] args) {
System.out.println(“List of country:”);
getCountry(true).forEach(System.out::println);
System.out.println(“Unlisted country:”);
getCountry(false).forEach(System.out::println);
}
}
Creating a stream using the Stream.generate() function method in Java.
जावा प्रोग्राम में Stream.generate() फंक्शन मेथड एक सप्लायर मेथड का यूज़ करके एक स्ट्रीम क्रिएट करता है।
Stream<Integer> stream =
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
Stream<Integer> stream = Stream.generate(() -> 7);
stream.limit(7)
.forEach(System.out::println);
}
}
Why is the limit() function necessary in Stream.generate()?
यहाँ मौजूदा प्रोग्राम में Stream.generate() फंक्शन एक इनफिनिट स्ट्रीम को क्रिएट करता है।
According to the method above.
7 → 7 → 7 → 7 → 7 → 7 → 7 →7 →…
इस वजह से, जावा यूजर सामान्य रूप से limit() फंक्शन मेथड का यूज़ करते हैं।
Another example of the Stream.generate() function.
Stream<Double> randomNumbers =
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
Stream<Double> randomNumbers = Stream.generate(Math::random);
randomNumbers
.limit(8)
.forEach(System.out::println);
}
}
Creating a stream using the Stream.iterate() function method in Java.
जावा प्रोग्राम में Stream.iterate() फंक्शन मेथड एक फ़ंक्शन को बार-बार अप्लाई करके एक स्ट्रीम क्रिएट करता है।
Syntax of the Stream.iterate() function method.
Stream.iterate(seed, function)
Example of the Stream.iterate() function method.
Stream<Integer> numbers =
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
Stream<Integer> numbers = Stream.iterate(1, num -> num + 1);
numbers.limit(7)
.forEach(System.out::println);
}
}
Its output.
यहाँ इस एक्साम्प्ल में।
1
स्टार्टिंग वैल्यू है।
इसके बाद.
num -> num + 1
नेक्स्ट वैल्यू क्रिएट करता है।
कॉन्सेप्चुअली यह ऐसे काम करता है.
1 → 2 → 3 → 4 → 5 → 6 → 7 → …
इसके बाद, यह फ़ॉर्म एक इनफिनिट स्ट्रीम को क्रिएट करता है, इस वजह से limit() फंक्शन मेथड का यूज़ सामान्य रूप से किया जाता है।
The iterate() function method with a Predicate in Java 9.
Java 9 लैंग्वेज वर्जन ने iterate() फंक्शन मेथड का एक और वर्शन पेश किया है.
Stream.iterate(seed, predicate, function)
Example of the iterate() function method.
Stream<Integer> numbers =
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
Stream.iterate(
1,
num -> num <= 9,
num -> num + 1
).forEach(System.out::println);
}
}
numbers.forEach(System.out::println);
Its output.
इसमें।
1
इसकी स्टार्टिंग वैल्यू है।
num -> num <= 9
यहाँ यूजर डिफाइन कंडीशन है।
num -> num + 1
इसके बाद नेक्स्ट वैल्यू बनती है।
जावा में ये फीचर तब यूज़ किया जाता है, जब जावा डेवलपर चाहते हैं कि स्ट्रीम किसी कंडीशन के आधार पर रुक जाए।
Creating a primitive stream data type in Java with IntStream.
जावा प्रोग्रामिंग लैंग्वेज में प्रिमिटिव डेटा डाटा टाइप मेथड के लिए एक स्ट्रीम फंक्शन मेथड प्रोवाइड करता है.
- IntStream
- LongStream
- DoubleStream
Example of a primitive stream data type.
IntStream stream =
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
IntStream stream = IntStream.of(24, 34, 38, 41, 55, 66);
stream.forEach(System.out::println);
}
}
Creating a stream using the IntStream.range() function method in Java.
जावा में IntStream.range() फंक्शन मेथड एक स्टार्टिंग वैल्यू और एक लास्ट वैल्यू के बीच इंटीजर वैल्यू क्रिएट करता है।
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
IntStream.range(1, 9)
.forEach(System.out::println);
}
}
यहाँ ऊपर दिए गए प्रोग्राम में ध्यान दें कि इसमें 9 वैल्यू को हटा दिया गया है। इस वजह से,
IntStream.range(1, 9)
इसका मतलब है.
1, 2, 3, 4, 5, 6, 7, 8
IntStream.rangeClosed() function method in Java.
जावा प्रोग्राम में rangeClosed() फंक्शन मेथड में एंडिंग वैल्यू इन्क्लुड होती है।
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
IntStream.rangeClosed(1, 9)
.forEach(System.out::println);
}
}
The main difference is this.
range(1, 9)
→ 1 2 3 4 5 6 7 8
rangeClosed(1, 5)
→ 1 2 3 4 5 6 7 8 9
Creating a Stream from a String in Java.
जावा प्रोग्राम में एक स्ट्रिंग को chars() फंक्शन मेथड का यूज़ करके कैरेक्टर की एक स्ट्रीम में कन्वर्ट किया जा सकता है।
public class Main {
public static void main(String[] args) {
String Comp_name = “Vcanhelpsu”;
Comp_name.chars()
.forEach(c -> System.out.println((char) c));
}
}
यहाँ इस एक्साम्प्ल में chars() फंक्शन एक IntStream डाटा क्रिएट करता है, इस वजह से टेक्स्ट करैक्टर वैल्यू को प्रिंट करने के लिए इसे char टेक्स्ट में कन्वर्ट कर दिया जाता है।
Creating a stream from a Java file.
जावा प्रोग्राम में Files.lines() फंक्शन मेथड एक स्ट्रीम क्रिएट कर सकता है, जहाँ हर फाइल एलिमेंट फ़ाइल में एक लाइन को रिप्रेजेंट करता है।
import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) throws IOException {
try (Stream<String> lines = Files.lines(Paths.get(“sample.txt”))) {
lines.forEach(System.out::println);
}
}
}
यहाँ इस एक्साम्प्ल में, यह बड़ी टेक्स्ट फ़ाइलों को प्रोसेस करते समय स्पेशली रूप से तब यूज़ किया जाता है, क्योंकि पूरी फ़ाइल को एक बार में मेमोरी में लोड करने की ज़रूरत नहीं होती है। समान्य रूप से try-with-resources स्टेटमेंट को प्रायोरिटी दी जाती है.
try (Stream<String> lines =
{try (Stream<String> lines = Files.lines(Paths.get(“sample.txt”))) {
lines.forEach(System.out::println); }
Creating a parallel stream in Java.
जावा प्रोग्राम में एक कलेक्शन parallelStream() फंक्शन मेथड का यूज़ करके पैरेलल स्ट्रीम को क्रिएट कर सकते है।
List<Integer> numbers =
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> values = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
values.parallelStream()
.forEach(System.out::println);
}
}
यहाँ इस एक्साम्प्ल में एक पैरेलल स्ट्रीम से मल्टीप्ल थ्रेड्स का यूज़ करके डाटा एलिमेंट्स को प्रोसेस कर सकती है।
The main difference is.
numbers.stream();
यह एक सीक्वेंशियल स्ट्रीम क्रिएट करता है।
values.parallelStream();
यह एक पैरेलल स्ट्रीम क्रिएट करता है।
जावा प्रोग्राम में पैरेलल स्ट्रीम्स को ऑटोमैटिकली तेज़ नहीं माना जाना चाहिए। इनका यूज़ वर्कलोड, डेटा साइज़ और किए जा रहे ऑपरेशन पर टोटली डिपेंड करता है।
Creating a stream and processing it simultaneously in Java.
किसी जावा प्रोग्राम में एक बहुत ही बेसिक जावा स्ट्रीम पैटर्न है.
List<Integer> numbers =
Arrays.asList(9, 21, 33, 44, 89, 100);
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> integers =
Arrays.asList(9, 21, 33, 44, 89, 100);
List<Integer> output =
integers.stream()
.filter(num -> num > 40)
.map(num -> num / 2 )
.toList();
System.out.println(output);
}
}
The processing pipeline in Java streams is something like this.
Collection data type
↓
stream() function method
↓
filter() data function
↓
map() data function
↓
toList() data function
↓
Output
Essential stream concept in Java.
जावा में स्ट्रीम मेथड को सामान्य रूप से दोबारा यूज़ नहीं किया जा सकता है.
एक बार स्ट्रीम में टर्मिनल ऑपरेशन परफॉर्म हो जाने के बाद, स्ट्रीम को यूज़ किया हुआ माना जाता है।
Example of the Essential stream concept.
Stream<Integer> stream =
Stream.of(3, 7, 9, 12);
stream.forEach(System.out::println);
// इससे एक्सप्रेशन में एक एक्सेप्शन होता है
stream.forEach(System.out::println);
Here’s what you’ll get.
java.lang.IllegalStateException:
इसमें यूजर डिफाइन स्ट्रीम पर पहले ही काम किया जा चुका है, या उसे बंद कर दिया गया है
Instead, you create a new stream.
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
// First user define stream element
Stream<Integer> streamone = Stream.of(3, 7, 9, 11, 21);
streamone.forEach(System.out::println);
// Second user define stream element
Stream<Integer> streamtwo = Stream.of(3, 7, 9, 11, 21);
streamtwo.forEach(System.out::println);
}
}
Main Sources of Stream Data Creation — Detail Summary
| # | Collection data source | Apply stream function method | Stream data type method |
| 1. | Collection data types | Use for it collection.stream() function method | Use it for Stream<T> |
| 2. | Collection element | Use collection.parallelStream() function method | Use for it Stream<T> |
| 3. | Array homogenous data | Use Arrays.stream(array) function method | Use for it Stream<T> / primitive stream |
| 4. | Values data type | Use Stream.of(…)function method | You can use Stream<T> method |
| 5. | Empty data | We can use Stream.empty() function method | We apply for it Stream<T> |
| 6. | Generate stream data | We can use Stream.generate(…)function method | We ca apply Stream<T> |
| 7. | Iterate data method | We can use Stream.iterate(…) function method | We ca apply Stream<T> |
| 8. | Integers data type | We can use IntStream.of(…) function method | We ca apply IntStream |
| 9. | Integer range data type | We can use IntStream.range(…) function method | We ca apply IntStream |
| 10. | Integer range data type | We can use IntStream.rangeClosed(…) function method | We ca apply IntStream |
| 11. | String data type | We can use string.chars() function method | We ca apply IntStream |
| 12. | File data type | We can use Files.lines(…)function method | We ca apply Stream<String> |
| 13. | Map keys data type | We can use map.keySet().stream() function method | We ca apply Stream<K> |
| 14. | Map values data type | We can use map.values().stream() function method | We ca apply Stream<V> |
| 15. | Map entries data type | We can use map.entrySet().stream() function method | We ca apply Stream<Map.Entry<K,V>> |
Source and details of creating streams in the Java programming language—summary.
जावा प्रोग्राम में एक याद रखने के लिए सबसे ज़रूरी तरीके।
// कलेक्शन डाटा टाइप्स
list.stream();
// ऐरे डाटा टाइप एलिमेंट
Arrays.stream(array);
// अलग-अलग डाटा टाइप एलिमेंट वैल्यू
Stream.of(9, 11, 17, 20);
// खाली कलेक्शन डाटा टाइप एलिमेंट
Stream.empty();
// इनफिनिट डाटा टाइप जेनरेटेड स्ट्रीम
Stream.generate(() -> वैल्यू);
// इनफिनिट इटरेटिव स्ट्रीम डाटा
Stream.iterate(1, num -> num + 1);
// प्रिमिटिव डाटा टाइप एलिमेंट रेंज
IntStream.range(11, 21 );
// इनक्लूसिव प्रिमिटिव डाटा टाइप एलिमेंट रेंज
IntStream.rangeClosed(11, 21);
// पैरेलल डाटा टाइप एलिमेंट
list.parallelStream();
Stream creation in Java programming is basically as follows.
कलेक्शन डाटा टाइप सोर्स → स्ट्रीम → ऑपरेशन्स → टर्मिनल ऑपरेशन।
कलेक्शन लिस्ट / ऐरे / सेट / मैप / फ़ाइल डाटा टाइप
↓
स्ट्रीम क्रिएशन फंक्शन और मेथड
↓
फ़िल्टर / मैप / सॉर्टेड डाटा एलिमेंट
↓
forEach / कलेक्ट / रिड्यूस मेथड
↓
फाइनल आउटपुट
