JavaRush /جاوا بلاگ /Random-UR /اسٹریم API

سطح

28 February 2021
43 views
0 comments

اسٹریم API

سٹریم API کیا ہے؟

Stream 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 میں پیکج میں شامل کیا جاتا ہے۔ " true " اور " falsejava.util.function " کی قدر چیک کرتا ہے )۔
map(Function mapper)ایک فنکشن بنانا ممکن بناتا ہے جس کے ساتھ ہم ہر عنصر کو تبدیل کریں گے اور اسے مزید چھوڑ دیں گے (فنکشنل انٹرفیس Function<T,R>قسم 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));
```

skip(long n) - n عناصر کو چھوڑیں:

stream.skip(3).forEach(x -> System.out.println(x));

ترتیب شدہ()
sorted(Comparator comparator) - اسٹریم کو ترتیب دیتا ہے (TreeMap کی طرح چھانٹنا):
```
stream.sorted().forEach(x -> System.out.println(x));
```
distinct() — عناصر کی انفرادیت کے لیے سلسلہ کو چیک کرتا ہے (عناصر کی تکرار کو ہٹاتا ہے)؛
dropWhile(Predicate predicate) - ایسے عناصر کو چھوڑتا ہے جو شرط کو پورا کرتے ہیں (جاوا 9 میں ظاہر ہوتا ہے، Predicate<T> فنکشنل انٹرفیس چیک کرتا ہے کہ آیا کوئی خاص شرط پوری ہوئی ہے یا نہیں، اگر یہ پوری ہو جاتی ہے، تو سچ واپس آ جاتا ہے۔ پیرامیٹر کے طور پر T ٹائپ کریں:
```
Predicate<Integer> isPositive = x -> x > 0;
       System.out.println(isPositive.test(3)); // true
       System.out.println(isPositive.test(-9)); // false
```

ٹرمینل آپریٹرز:

forEach(کنزیومر ایکشن) – ہر ایک کے لیے کا ینالاگ (صارف<T> T قسم کی کسی چیز پر کچھ بھی واپس کیے بغیر کچھ کارروائی کرتا ہے)۔
count() - اسٹریم عناصر کی تعداد لوٹاتا ہے:

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ندی کے حصوں کو ایک ساتھ جوڑتا ہے)؛
reduce(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)
اختیاری زیادہ سے زیادہ (کمپیریٹر کمپیریٹر) پاس شدہ کمپیریٹر کی بنیاد پر کم از کم/زیادہ سے زیادہ عنصر کی تلاش کرتا ہے۔
findFirst()- ندی کا پہلا عنصر نکالتا ہے:
```
Stream.of(1, 2, 3, 4, 9).findFirst();
```
allMatch(Predicate 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 میں تبدیل کرتا ہے اور رقم کا حساب لگاتا ہے۔

مفید لنکس:

PS: ہمیں پسندیدگیوں کی بارش کرنے میں شرم محسوس نہ کریں ^ : ^

تبصرے

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