JavaRush /جاوا بلاگ /Random-SD /اسٽريم API

سطح

28 February 2021
40 views
0 comments

اسٽريم API

اسٽريم API ڇا آهي؟

اسٽريم API هڪ فنڪشنل انداز ۾ ڊيٽا جي جوڙجڪ سان ڪم ڪرڻ جو هڪ نئون طريقو آهي. اسٽريم اين اي پي آئي (انهن طريقن جي وضاحت جنهن ۾ هڪ ڪمپيوٽر پروگرام ٻئي پروگرام سان رابطو ڪري سگهي ٿو) ان جي بنيادي طور تي، ڊيٽا جو هڪ وهڪرو آهي. اصطلاح "ڌاڳو" خود پروگرامنگ ۾ عام طور تي ۽ خاص طور تي جاوا ۾ بلڪل غير واضح آهي.

جاوا 8 جي اچڻ سان، اسٽريم API پروگرامرن کي وڌيڪ مختصر لکڻ جي اجازت ڏني، جيڪي اڳي ئي ڪوڊ جون ڪيتريون ئي لائينون کڻندا هئا، يعني ڊيٽا سيٽن سان ڪم ڪرڻ کي آسان ڪرڻ لاءِ، خاص طور تي، فلٽرنگ، ترتيب ڏيڻ ۽ ٻين ڊيٽا جي ڦيرڦار جي عملن کي آسان ڪرڻ لاءِ. جيڪڏهن توهان وٽ وچولي آپريشن نه آهي، توهان ڪري سگهو ٿا ۽ اڪثر ڪري سگهو ٿا بغير ڪنهن وهڪري کان، ٻي صورت ۾ ڪوڊ وڌيڪ پيچيده ٿي ويندو بغير وهڪرو کان.

ڪٿي، بلڪل، مون کي شروع ڪرڻ گهرجي؟ ھڪڙي اسٽريم مثال جي ٺاھڻ کان، جيڪو گڏ ڪرڻ، صف يا طريقي تي ٻڌل آھي جيڪو اسان کي گھربل آھي ۽ جتي ڊيٽا ان مطابق ورتو ويندو:

List<String> list = new ArrayList<String>();
       list.add("One");
       list.add("Two");
       list.add("Three");
       list.add("Four");
       list.add("Five");
       list.add("Six");
       list.add("Seven");
       list.add("Eight");
       list.add("Nine");
       list.add("Ten");
       Stream stream = list.stream();

جيئن مٿي ذڪر ڪيو ويو آهي، وهڪرو API توهان کي اجازت ڏئي ٿو ته ڪوڊ جي لائينن جو تعداد گهٽائڻ. هڪ وهڪرو سان مثال:

IntStream.of(50, 60, 70, 80, 90, 100, 110, 120).filter(x -> x < 90).map(x -> x + 10)
.limit(3).forEach(System.out::print);

ڌاڳو کان سواءِ مثال:

int[] arr = {50, 60, 70, 80, 90, 100, 110, 120
	int count = 0;
	for (int x : arr) {
	    if (x >= 90) continue;
	    x += 10;
	    count++;
	    if (count > 3) break;
	    System.out.print(x);
	}

اسٽريم ٺاهڻ جا ممڪن طريقا:

خالي وهڪرو:Stream.empty()
فهرست مان وهڪرو:list.stream()
نقشي مان وهڪرو:map.entrySet().stream()
سيريز مان وهڪرو:Arrays.stream(array)
بيان ڪيل عناصر مان وهڪرو:Stream.of("1", "2", "3")

ان کان علاوه، اتي هڪ اهڙي شيء آهي جيئن آپريٽرز (لازمي طور تي اسٽريم ڪلاس جا طريقا). آپريٽرز کي ٻن گروپن ۾ ورهائي سگهجي ٿو:

وچولي (جنهن کي "سست" پڻ سڏيو ويندو آهي) - ايندڙ عناصر کي پروسيس ڪريو ۽ وهڪرو واپس ڪريو. عنصر پروسيسنگ زنجير ۾ ڪيترائي وچولي آپريٽر ٿي سگھن ٿا.
ٽرمينل ("ٽرمينل"، جنهن کي "ايجر" پڻ سڏيو ويندو آهي) - عناصر کي پروسيس ڪري ٿو ۽ وهڪرو کي ختم ڪري ٿو، تنهنڪري اتي صرف هڪ ٽرمينل آپريٽر ٿي سگهي ٿو زنجير ۾.

مثال:

1.List<String> list = new ArrayList<String>();
2.list.add("One");
…
11.list.add("Ten");
12.Stream stream = list.stream();
13.stream.filter(x-> x.toString().length() == 3).forEach(System.out::println);

هتي ڇا ٿي رهيو آهي:

1 - هڪ فهرست ٺاهيو list؛
2-11 - ان کي ٽيسٽ ڊيٽا سان ڀريو؛
12 - هڪ اعتراض ٺاهيو Stream؛
13 - طريقو filter(فلٽر) - وچولي آپريٽر، xڳڻپ لاءِ مجموعي جي ھڪڙي عنصر جي برابر آھي (جيئن سان for each) ۽ بعد ۾ -> اسان ظاھر ڪريون ٿا ته اسان جو مجموعو ڪيئن فلٽر ڪيو ويو آھي ۽ جيئن ته ھي ھڪڙو وچولي آپريٽر آھي، فلٽر ٿيل مجموعو اڳتي وڌندو آھي طريقو، forEachجيڪو بدلي ۾ ڳڻپيوڪر جو ٽرمينل (فائنل) اينالاگ آهي for each(اظهار System.out::printlnمختصر لاءِ:، x-> System.out.println(x))جنهن جي نتيجي ۾ مجموعي جي سڀني عنصرن مان گذري ٿو جيڪو ان ڏانهن ويو ۽ ان کي ڏيکاري ٿو)

اهم نقطا:

پروسيسنگ شروع نه ٿيندي جيستائين ٽرمينل آپريٽر کي سڏيو وڃي. list.stream().filter(s -> s > 5)(فهرست مان هڪ به عنصر نه کڻندو)؛
هڪ وهڪرو جو هڪ مثال هڪ ڀيرو کان وڌيڪ استعمال نٿو ڪري سگهجي =( ;

تنهن ڪري، هر وقت اهو نئون آهي:

list.stream().filter(x-> x.toString().length() == 3).forEach(System.out::println);
list.stream().forEach(x -> System.out.println(x));

اتي ڪيترائي وچولي آپريٽر ٿي سگھن ٿا جن کي ھڪڙي اسٽريم تي سڏيو ويندو آھي، جڏھن ته رڳو ھڪڙو ٽرمينل آپريٽر آھي:
```
stream.filter(x-> x.toString().length() == 3).map(x -> x + " - the length of the letters is three").forEach(x -> System.out.println(x));
```

اڳيون، اچو ته ڪجهه وچولي آپريٽرز کي ڏسو:

filter(Predicate predicate)وهڪرو کي فلٽر ڪري ٿو، صرف انهن عنصرن کي پاس ڪري ٿو جيڪي شرط پاس ڪن ٿا (Predicate هڪ بلٽ ان فنڪشنل انٽرفيس آهي جيڪو جاوا SE 8 ۾ پيڪيج ۾ شامل ڪيو ويو آهي. ” سچ “ ۽ ” غلطjava.util.function “ لاءِ قدر چيڪ ڪري ٿو )؛
map(Function mapper)اهو هڪ فنڪشن ٺاهڻ ممڪن بڻائي ٿو جنهن سان اسان هر عنصر کي تبديل ڪنداسين ۽ ان کي اڳتي وڌايو (فنڪشنل انٽرفيس Function<T,R>هڪ قسم جي اعتراض کان آر قسم جي اعتراض ڏانهن منتقلي جي فنڪشن کي نمائندگي ڪري ٿو)
flatMap(Function<T, Stream<R>> mapper)- جيئن ته صورت ۾ map، اهي استعمال ڪيا ويندا آهن هڪ ابتدائي وهڪرو ۾ تبديل ڪرڻ لاء.

جڏهن ڪم ڪري رهيو آهي، مثال طور، اسٽريم جي هڪ صف سان (اريز، فهرست، وغيره)، اهو انهن کي هڪ وهڪرو ۾ تبديل ڪري ٿو (صف، فهرست، وغيره [stream1,stream2,stream3,stream4] => stream:

String[] array = {"Java", "Ruuuuussshhh"};
Stream<String> streamOfArray = Arrays.stream(array);
streamOfArray.map(s->s.split("")) //Convert the word to an array of letters
        .flatMap(Arrays::stream).distinct() //aligns each generated thread into a single thread
        .collect(Collectors.toList()).forEach(System.out::println);

جڏهن ته mapاهو موضوعن جي هڪ فهرست ۾ بدلجي ٿو (وڌيڪ واضح طور تي <Stream>موضوع) [stream1,stream2,stream3,stream4] =>Stream.of(stream1,stream2,stream3,stream4):

String[] array = {"Java", "Ruuuuussshhh"};
Stream<String> streamOfArray = Arrays.stream(array);
streamOfArray.map(s->s.split("")) //Convert the word to an array of letters
        .map(Arrays::stream).distinct() //Make the array into a separate thread
        .collect(Collectors.toList()).forEach(System.out::println);

جي مقابلي ۾ هڪ ٻيو فرق map، توهان هڪ عنصر کي صفر، هڪ يا ڪيترن ئي ٻين ۾ تبديل ڪري سگهو ٿا. ھڪڙي عنصر کي صفر عناصر ۾ تبديل ڪرڻ لاء، توھان کي واپس ڪرڻ جي ضرورت آھي null، يا ھڪڙو خالي وهڪرو. ھڪڙي عنصر ۾ تبديل ڪرڻ لاء، توھان کي ھڪڙي عنصر مان ھڪڙو وهڪرو واپس ڪرڻ جي ضرورت آھي، مثال طور، ذريعي Stream.of(x). ڪيترن ئي عناصر کي واپس ڪرڻ لاء، توهان ڪنهن به طريقي سان انهن عناصر سان هڪ وهڪرو ٺاهي سگهو ٿا. ساڳيو فليٽ ميپ طريقو، پر ڊبل، انٽيجر ۽ ڊگھو لاءِ:

flatMapToDouble (فنڪشن ميپر)
flatMapToInt (فنڪشن ميپر)
flatMapToLong (فنڪشن ميپر)

۽ مقابلي لاءِ ٻيو مثال، flatMap:

Stream.of(2, 3, 0, 1, 3)
        .flatMapToInt(x -> IntStream.range(0, x))
        .forEach(System.out::print);// 010120012

IntStream.range(0,x) - 0 (شامل) کان x (شامل نه) تائين عناصر کي ٻاھر ڪڍي ٿو.

نقشو:

Stream.of(2, 3, 0, 1, 3)
        .map(x -> IntStream.range(0, x))
        .forEach(System.out::print);//list of streams (streams);

حد (ڊگهو وڌ ۾ وڌ سائز) - عناصر جي تعداد جي ذريعي وهڪرو کي محدود ڪري ٿو:
```
stream.limit(5).forEach(x -> System.out.println(x));
```
اسڪيپ (ڊگهو n) - n عناصر کي ڇڏي ڏيو:
```
stream.skip(3).forEach(x -> System.out.println(x));
```
ترتيب ڏنل()
ترتيب ڏنل (مقابلي ڪندڙ comparator) - وهڪري کي ترتيب ڏئي ٿو (ترتيب ڪرڻ جهڙو TreeMap):
```
stream.sorted().forEach(x -> System.out.println(x));
```
distinct() - عناصر جي انفراديت لاءِ وهڪرو چيڪ ڪري ٿو (عناصر جي ورهاڱي کي هٽائي ٿو)؛
dropWhile(Predicate predicate) - عناصر کي ڇڏي ٿو جيڪي شرط کي پورو ڪن ٿا (جاوا 9 ۾ ظاهر ٿيو، Predicate<T> فنڪشنل انٽرفيس چيڪ ڪري ٿو ته ڇا ڪا خاص شرط ملي ٿي. جيڪڏهن اها ملي ٿي، پوء صحيح واپس اچي ٿو. lambda ايڪسپريس هڪ اعتراض وٺي ٿو. ٽائيپ ٽي پيراميٽر طور:
```
Predicate<Integer> isPositive = x -> x > 0;
       System.out.println(isPositive.test(3)); // true
       System.out.println(isPositive.test(-9)); // false
```

ٽرمينل آپريٽرز:

forEach(صارف جي عمل) - هر هڪ لاءِ هڪجهڙائي سان (صارف<T> ڪنهن به شيءِ کي واپس ڪرڻ کان سواءِ T قسم جي اعتراض تي ڪجهه عمل انجام ڏئي ٿو)؛
شمار () - وهڪرو عناصر جو تعداد واپس ڏئي ٿو:

System.out.println(stream.count());
گڏ ڪرڻ (ڪليڪٽر ڪليڪٽر) - طريقو سڀني عناصر کي لسٽ ۾ گڏ ڪري ٿو، سيٽ يا ٻيو مجموعو، گروپ عناصر کي ڪجهه معيار جي مطابق، هر شيء کي هڪ تار ۾ گڏ ڪري ٿو، وغيره.
```
List<String> list = Stream.of(“One”, “Two”, “Three”).collect(Collectors.toList());
```
collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner)— ساڳيءَ طرح، collect(collector)صرف پيراميٽر ٽوڙيا ويا آهن سهولت لاءِ ( supplierنئين شين جي فراهمي (ڪنٽينر)، مثال طور، new ArrayList()ڪنٽينر accumulator۾ هڪ عنصر شامل ڪري ٿو، combinerوهڪري جي حصن کي گڏ ڪري ٿو؛
گھٽ (T identity, BinaryOperator accumulator) - وهڪري جي سڀني عنصرن کي ھڪڙي شئي ۾ بدلائي ٿو (سڀني عنصرن جو مجموعو ڳڻيو، يا گھٽ ۾ گھٽ عنصر ڳولھيو)، پھريائين اعتراض identity۽ وهڪرو جو پھريون عنصر ورتو وڃي ٿو، فعل لاڳو ٿئي ٿو. accumulator۽ identityان جو نتيجو ٿيندو. پوء سڀڪنھن شيء کي باقي عناصر لاء جاري آهي.
```
int sum = Stream.of(1, 2, 3, 4, 5).reduce(10, (acc, x) -> acc + x);// = 25
```
reduce(BinaryOperator accumulator)- ساڳيو طريقو جيئن مٿي آهي پر ابتدائي هڪ غائب آهي identity، اهو وهڪرو جو پهريون عنصر آهي

Optional min(Comparator comparator)
اختياري وڌ ۾ وڌ (Comparator comparator) ڳولهي ٿو گھٽ ۾ گھٽ / وڌ ۾ وڌ عنصر جي بنياد تي پاس ڪيل موازنہ؛
findFirst()- وهڪرو جو پهريون عنصر ڪڍي ٿو:
```
Stream.of(1, 2, 3, 4, 9).findFirst();
```
allMatch(Predicate predicate)- واپسي صحيح آھي جيڪڏھن وهڪرو جا سڀئي عنصر شرط کي پورو ڪن. جيڪڏهن ڪو عنصر سامهون اچي ٿو جنهن لاءِ پريڊيڪيٽ فنڪشن کي ڪال ڪرڻ جو نتيجو غلط آهي ، پوءِ آپريٽر عناصر کي اسڪين ڪرڻ بند ڪري ٿو ۽ غلط موٽائي ٿو :
```
Stream.of(1, 2, 3, 4, 9).allMatch(x -> x <= 7);//false
```
anyMatch(Predicate predicate)- سچي موٽندو جيڪڏهن وهڪرو جو گهٽ ۾ گهٽ هڪ عنصر شرط کي پورو ڪري ٿو predicate:
```
Stream.of(1, 2, 3, 4, 9).anyMatch(x -> x >= 7);//true
```
noneMatch(Predicate predicate)- سچي موٽندو ، جيڪڏهن، وهڪري جي سڀني عنصرن جي ذريعي وڃڻ کان پوء، انهن مان ڪنهن به شرط کي مطمئن نه ڪيو predicate:
```
Stream.of(1, 2, 3, 4, 9).noneMatch(x -> x >= 7);//false
```

۽ آخر ۾ آئون ڪجهه طريقن کي ڏسڻ چاهيندس Collectors:

toList()- عناصر کي گڏ ڪري ٿو List:

List<Integer> list = Stream.of(99, 2, 3).collect(Collectors.toList());

toSet()- عناصر کي سيٽ ۾ گڏ ڪري ٿو:

Set<Integer> set = Stream.of(99, 2, 3).collect(Collectors.toSet());

counting()- عناصر جو تعداد شمار ڪري ٿو:

Long count = Stream.of("1", "2", "3", "4").collect(Collectors.counting());

joining()
joining(CharSequence delimiter)

joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)- عناصر کي ھڪڙي لائن ۾ گڏ ڪري ٿو. اضافي طور تي، توهان هڪ جدا ڪندڙ بيان ڪري سگهو ٿا، انهي سان گڏ هڪ اڳڀرائي ۽ لاڳاپو سڄي ترتيب لاء:

String a = Stream.of("s", "u" ,"p", "e", "r").collect(Collectors.joining());
       System.out.println(a); // super

       String b = Stream.of("s", "u", "p", "e", "r").collect(Collectors.joining("-"));
       System.out.println(b); // s-u-p-e-r

       String c = Stream.of("s", "u", "p", "e", "r").collect(Collectors.joining(" -> ", "[ ", " ]"));
       System.out.println(c);  // [ s -> u -> p -> e -> r ]

summingInt(ToIntFunction mapper)
summingLong(ToLongFunction mapper)
summingDouble(ToDoubleFunction mapper)- هڪ ڪليڪٽر جيڪو شيون تبديل ڪري ٿو int/long/double ۽ حساب ڪري ٿو رقم.

مفيد لنڪس:

پي ايس: اسان کي پسند ڪرڻ ۾ شرم نه ڪر ^ : ^

تبصرا

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION