Stream API in java in Hindi

by

Last Updated on December 31, 2022 by RAJENDRAPRASAD

Stream API in Java in Hindi – Hello दोस्तों rajhindime.in में आपका स्वागत है |

दोस्तों, पिछले post Functional Interface and Lambda expression in java in Hindi में आपने Lambda Expression क्या है, उसे कैसे use करते हैं और Lambda Expression में Functional Interface का क्या योगदान है, इत्यादि के बारे में विस्तार से जाना |

आज के इस post Stream API in Java in Hindi में आप Stream API के बारे में विस्तार से जानेंगे जो, java 8 से available है |

Stream API के बारे में जानने से पहले आइए जाने Collection क्या होता है |

Collection:

दोस्तों, आप कभी न कभी किसी संगीत समारोह अथवा movie theatre (सिनेमाघर) में जरूर गए होंगे | क्या आप बता सकते हैं कि वहाँ पर जो भीड़ (group of people) होती है, उसे क्या कहते हैं ?

उस भीड़(group of people) को हम श्रोतागण (audience) कहते हैं |

कहने का मतलब यहाँ हमने, group of peple को एक name दे दिया है, जिसे हम आवश्यकता पड़ने पर बार-बार बोल सकते हैं |

ठीक उसी तरह, java में यदि हम किसी object के group को, एक single entity के रूप में प्रस्तुत करना चाहते हैं तो collection का use करते हैं |

Collection के बारे में हम आने वाले किसी post में विस्तार से जानेंगे |

Collection और Stream:

Group of objects को, एक single entity के रूप में प्रस्तुत करने के लिए collection का use करते हैं | और उसी collection के objects को अगर process करना हो तो हम stream का use करते हैं |

General उदाहरण कि बात करें तो, जैसे हमें जानना हो कि उपस्थित audience में से कितने male हैं और कितने female, किन-किन लोगों ने नीले रंग के कपडे पहने हैं, इत्यादि इत्यादि, इसे हम stream की सहायता से कर सकते हैं |

Stream API in java:

Stream यह एक Interface है जो Collection Framework से related है | इसे java 1.8 में introduce किया गया |

यह java.util.stream package में उपलब्ध है | इसमें बहुत सारे default और static methods हैं |

इसका main कार्य collection/groups के object को process करना तथा उस object पर bulk operation perform करना है |

Stream का use करने से program की code length बहुत कम हो जाती है |

Stream का use करने से program का execution fast हो जाता है, जिससे application का performance बढ़ जाता है |

आइए अब देखते हैं कि stream के पहले हम collection को कैसे process करते थे और stream के साथ कैसे process करते हैं |

Program without stream:

Program 1 :

import java.util.ArrayList;
import java.util.List;

public class StreamDemo1 {

	public static void main(String[] args) {
		List<Integer> list1 = new ArrayList<>();
		list1.add(20);
		list1.add(22);
		list1.add(27);
		list1.add(16);
		list1.add(34);
		list1.add(57);
		list1.add(78);
		System.out.println("Whole list is " + list1);
		List<Integer> listEven = new ArrayList<>();
		for (Integer i : list1) {
			if (i % 2 == 0) {
				listEven.add(i);
			}
		}
		System.out.println("Even List is " + listEven);
	}
}

OutPut:

Whole list is [20, 22, 27, 16, 34, 57, 78]
Even List is [20, 22, 16, 34, 78]

Explanation:

ऊपर के program 1 में, हमने ArrayList का object create किया है, जिसे List interface के reference variable list1 में store किया है | उसके बाद add() method का use करके उसके अंदर values को store किया है |

हमने एक और ArrayList object बनाया है जो सिर्फ even number (सम संख्या) को store करता है |

List1 में से even number को निकालने के लिए हमने for loop का use किया है जो एक -एक करके list1 के सभी elements को check करता है, और अगर वह element even number है तो उसे listEven में add करते जाता है |

अंत में हमने evenList को print कर दिया है |

ध्यान दो, यहाँ हमने even number निकालने के लिए 3 से 5 lines का code लिखा है, आइए, अब देखे कि हम same इसी program को stream की सहायता से कैसे लिखते हैं |

Program with stream:

Program 2:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo2 {

	public static void main(String[] args) {
		List<Integer> list1 = new ArrayList<>();
		list1.add(20);
		list1.add(22);
		list1.add(27);
		list1.add(16);
		list1.add(34);
		list1.add(57);
		list1.add(78);
		System.out.println("Whole list is " + list1);
		
		Stream<Integer> stream = list1.stream();
		List<Integer> listEven =stream.filter(i->i%2==0).collect(Collectors.toList());
		System.out.println("Even list is "+listEven);
	}
}

OutPut:

Whole list is [20, 22, 27, 16, 34, 57, 78]
Even list is [20, 22, 16, 34, 78]

Explanation:

ऊपर के program 2 में हमने, सबसे पहले list1 को stream में बदला, उसके बाद filter() method तथा lambda function का use किया और result को listEven में store करके print कर दिया |

ध्यान दो, यहाँ हमने 2 lines के code में ही सारा काम कर लिया |

हम चाहे तो ऊपर वाले code को एक line में भी लिख सकते हैं जैसे,

System.out.println("Even list is "+list1.stream().filter(i->i%2==0).collect(Collectors.toList()));

Stream में बहुत सारे methods हैं और यह lambda function को भी support करता है, इस तरह stream का use करके हम code length को कम कर सकते हैं | कम line का code मतलब debug में आसानी और error के chances भी कम |

Stream object कैसे get करें:

चूँकि, Stream यह एक Interface है, इसलिए हम direct इसका object नहीं create कर सकते, परन्तु हम इसके implementation class के object को create कर सकते हैं |

Java में stream object get करने के बहुत सारे तरीके हैं परन्तु, यहाँ हम कुछ important तरीकों को ही जानेंगे |

1. Stream.of(parameter) का use करके:

इस method का use करके हम किसी भी group से stream object को get कर सकते हैं |

Program 3:

import java.util.stream.Stream;

public class StreamObject {

	public static void main(String[] args) {
		Stream<Integer> stream1 = Stream.of(2, 5, 7, 8, 9);
		stream1.forEach(e -> System.out.println(e));

		System.out.println("-------------------");

		Stream<Object> stream2 = Stream.of(2, "dfg", 7.6, 8, 9);
		stream2.forEach(e -> System.out.println(e));
	}
}

OutPut:

2
5
7
8
9
-------------------
2
dfg
7.6
8
9

Explanation:

ऊपर के program 3 में, हमारे पास दो groups हैं, पहला (2,5,7,8,9) और दूसरा (2, “dfg”, 7.6, 8, 9)

यहाँ हमने Stream.of() method को use किया है, और इसके argument में (2,5,7,8,9) pass किया है, चूँकि ये sare elements Interger हैं इसलिए इसे,

ऐसे reference variable में store किया है जो कि Stream<Integer> type का है, जिसका name stream1 दिया है |

अब stream1 पर हमने forEach method call किया है और argument में lambda function का use करते हुए, इसके सारे values को print कराया है |

ठीक उसी तरह हमने दूसरे group (2, “dfg”, 7.6, 8, 9) जिसमे अलग-अलग type के values हैं जैसे int, String और float हैं, को ऐसे reference variable में store किया है जो कि Stream<Object> type का है, जिसका name stream2 दिया है |

ध्यान दो, Object class, java में available सारे classes का ultimate Parent class है, जो किसी भी value को store कर सकता है |

Stream.of(parameter) का use करके हम किसी भी Array से Stream object get कर सकते हैं |

Program 4:

import java.util.stream.Stream;

public class StreamObject {

	public static void main(String[] args) {
		String names[] = { "Ram", "Shyam", "Sita", "Gita", "Laxman" };
		Stream<String> stream = Stream.of(names);
		stream.forEach(e -> {
			System.out.println(e);
		});
	}
}

OutPut:

Ram
Shyam
Sita
Gita
Laxman

Explanation:

ऊपर program 4 में, हमारे पास एक String array है, जिसका नाम names है | यहाँ हमने Stream.of() method के arguments में names को pass किया है |

2. Arrays.stream(parameter) का use करके :

Program 5:

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamObject {

	public static void main(String[] args) {
		int[] i = { 2, 4, 5, 7 };

		IntStream stream1 = Arrays.stream(i);
		stream1.forEach(e -> {
			System.out.println(e);
		});

		System.out.println("-----------------------");

		Stream<String> stream2 = Arrays.stream(new String[] { "yamuna", "ganga", "narmada", "kavery" });
		stream2.forEach(e -> {
			System.out.println(e);
		});
	}
}

OutPut:

2
4
5
7
-----------------------
yamuna
ganga
narmada
kavery

Explanation :

ऊपर के program 5 में, सबसे पहले हमने Arrays.stream() के argument में i को pass किया जो कि एक int[] array है |

दूसरी बार हमने Arrays.stream() के argument में anonymous array को pass किया है |

3. किसी भी Collection से stream object get करना:

यह सबसे ज्यादा use होने वाला तरीका है |

Syntax:

CollectionReferenceVariable.stream();

Program 6:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamObject {

	public static void main(String[] args) {
		List<Integer> studentMarks = new ArrayList<>();
		studentMarks.add(45);
		studentMarks.add(32);
		studentMarks.add(57);
		studentMarks.add(78);
		Stream<Integer> stream = studentMarks.stream();
		stream.forEach(i -> {
			System.out.println(i);
		});
	}
}

OutPut:

45
32
57
78

Explanation :

ऊपर के program 6 में, हमने ArrayList का object create किया है जिसे Interface List के reference variable studentMarks में store किया है |

ArrayList, List यह सब Collection के parts हैं, जिन्हे हम किसी separate post में विस्तार से जानेंगे |

फिर, add() method का use करके हमने अलग-अलग marks को store किया है |

उसके बाद studentMarks.stream() का use किया है |

ध्यान दो यहाँ, stream() method में कोई भी argument नहीं है, जो कि Arrays.stream() में था |

अब तक हमने stream के forEach() method को जाना, आगे कुछ और important method को जानने से पहले, आइए यह जाने कि किसी भी operation को करने के बाद processed stream की value /elements को कैसे store करे, जिसे हम बार-बार use कर सके |

Stream collectors:

Stream पर कोई भी operation perform करने के बाद processed stream के elements को हम दो तरीको से store कर सकते हैं |

1. Array में store करना

2. Collection में store करना

1. Array में store करना :

Processed steam के elements को Array में store करने के लिए हमेशा toArray() method का use करते हैं |

Program 7:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamObject {

	public static void main(String[] args) {
		List<Integer> studentMarks = new ArrayList<>();
		studentMarks.add(45);
		studentMarks.add(32);
		studentMarks.add(57);
		studentMarks.add(78);
		studentMarks.add(29);
		Stream<Integer> stream = studentMarks.stream();
		Object[] passStudentMarksArray = stream.filter(i -> i >= 35).toArray();
		for (int i = 0; i < passStudentMarksArray.length; i++) {
			System.out.println(passStudentMarksArray[i]);
		}
	}
}

OutPut:

45
57
78

Explanation:

ऊपर के program 7 में हमने, stream पर filter operation करने के बाद उसके result को array में बदलने के लिए toArray() method का use किया है, उसके बाद उस value को Object[] Array passStudentMarksArray में store किया है |

2. Collection में store करना :

Processed steam के elements को Collection में store करने के लिए हमेशा collect() method का use करते हैं |

Program 8:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamObject {

	public static void main(String[] args) {
		List<Integer> studentMarks = new ArrayList<>();
		studentMarks.add(45);
		studentMarks.add(32);
		studentMarks.add(57);
		studentMarks.add(78);
		studentMarks.add(29);
		Stream<Integer> stream = studentMarks.stream();
		List<Integer> passStudentMarksList = stream.filter(i -> i >= 35).collect(Collectors.toList());
		System.out.println(passStudentMarksList);
	}
}

OutPut:

[45, 57, 78]

Explanation:

ऊपर के program 8 में हमने, collect() method का use किया है, जिसके argument में Collectors.toList() pass किया है, क्योकि यहाँ हमे result (processed stream के elements) को List में बदलना था | उसके बाद उसे passStudentMarksList में store कर दिया जो कि एक List है |

ठीक इसी तरह हम processed stream के elements को Set, Map इत्यादि में भी store कर सकते हैं, जो कि Collection के ही parts हैं |

आइए अब Stream पर perform होने वाले कुछ operations को जानें |

Stream Operations/Important Stream methods:

अब तक हमने ऊपर के programs में कुछ methods जैसे Stream.of(), toArray(), forEach(), collect() को जाना, आइए अब कुछ अन्य important methods को जानें |

1. stream.filter(Predicate) और count():

किसी भी stream से data/elements को filter करने के लिए इस method का use करते हैं, इस method के argument में predicate को pass किया जाता है |

predicate और कुछ नहीं बल्कि ऐसा function है जो Boolean value return करता है अर्थात true या फिर false |

Stream के जिस भी element पर pass किया गया condition true होगा, वह result  में आ जाएगा, जिसे हम आवश्यकता के अनुसार आगे process, collect अथवा print कर सकते हैं |

count() का use stream में available total elements की संख्या को जानने के लिए किया जाता है |

Program 9:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class StreamMethods {

	public static void main(String[] args) {
		List<String> citiNames = new ArrayList<>();
		citiNames.add("Mumbai");
		citiNames.add("Delhi");
		citiNames.add("Bangalore");
		citiNames.add("Hyderabad");
		citiNames.add("Surat");
		citiNames.add("Pune");
		citiNames.add("Lucknow");
		citiNames.add("Meerut");

		long count = citiNames.stream().filter(i -> i.startsWith("M")).count();
		System.out.println("total count of citi name start with M is : " + count);
		List<String> newList = citiNames.stream().filter(i -> i.startsWith("M")).collect(Collectors.toList());
		System.out.println("citi name start with M : " + newList);
	}
}

OutPut:

total count of citi name start with M is : 2
citi name start with M : [Mumbai, Meerut]

2. stream.map(consumerFunction):

इस method का use stream में available प्रत्येक (each) element पर कोई भी operation करने के लिए किया जाता है | जैसे, किसी stream में vailable सभी interger का square निकलना, सभी students के marks में extra 5 marks add करना इत्यादि |

map के argument में हमेशा Consumer Function को pass किया जाता है |  

consumer Function का अर्थ है ऐसा function जो कुछ भी return न करता हो |

Program 10:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo2 {

	public static void main(String[] args) {
		List<Integer> list1 = new ArrayList<>();
		list1.add(2);
		list1.add(8);
		list1.add(4);
		list1.add(16);
		list1.add(55);
		list1.add(19);
		list1.add(41);
		System.out.println("Original list is " + list1);

		Stream<Integer> stream = list1.stream();
		List<Integer> squareList = stream.map(i -> i * i).collect(Collectors.toList());
		System.out.println("Square list is " + squareList);
	}
}

OutPut:

Original list is [2, 8, 4, 16, 55, 19, 41]
Square list is [4, 64, 16, 256, 3025, 361, 1681]

Explanation:

ऊपर के program 10 में, हमने stream.map() का use करके उसके सारे elements का square कर दिया है |

ध्यान दो, map() के बाद जो stream बनता है उसका total count, हमेशा original stream के count के बराबर ही होता है, जबकि filter() के case में original stream के count से कम अथवा बराबर होता है |

3. min(Comparator) और max(Comparator):

इसका use stream के सभी elements में से minimum number तथा maximum number जानने के लिए किया जाता है |

Program 11:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamDemo2 {

	public static void main(String[] args) {
		List<Integer> list1 = new ArrayList<>();
		list1.add(2);
		list1.add(8);
		list1.add(4);
		list1.add(16);
		list1.add(55);
		list1.add(19);
		list1.add(41);
		System.out.println("Original list is " + list1);

		Stream<Integer> stream = list1.stream();
		int minNum = stream.min((x, y) -> x.compareTo(y)).get();
		System.out.println("minimum number is " + minNum);

		Stream<Integer> stream1 = list1.stream();
		int maxNum = stream1.max((x, y) -> x.compareTo(y)).get();
		System.out.println("maximum number is " + maxNum);
	}
}

OutPut:

Original list is [2, 8, 4, 16, 55, 19, 41]
minimum number is 2
maximum number is 55

4. sorted()

इस method का use stream में available elements को sort करने के लिए किया जाता है |

यह method केवल ascending order में ही sort करता है |

Program 12:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo2 {

	public static void main(String[] args) {
		List<Integer> list1 = new ArrayList<>();
		list1.add(2);
		list1.add(8);
		list1.add(4);
		list1.add(16);
		list1.add(55);
		list1.add(19);
		list1.add(41);
		System.out.println("Original list is " + list1);

		Stream<Integer> stream = list1.stream();
		List<Integer> sortedList = stream.sorted().collect(Collectors.toList());
		System.out.println("sorted list is " + sortedList);
	}
}

OutPut:

Original list is [2, 8, 4, 16, 55, 19, 41]
sorted list is [2, 4, 8, 16, 19, 41, 55]

5. Sorted(Comparator)

इस method का use stream में available सभी elements को ascending अथवा descending दोनों में sort करने के लिए किया जाता है |

Program 13:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo2 {

	public static void main(String[] args) {
		List<Integer> list1 = new ArrayList<>();
		list1.add(2);
		list1.add(8);
		list1.add(4);
		list1.add(16);
		list1.add(55);
		list1.add(19);
		list1.add(41);
		System.out.println("Original list is " + list1);

		Stream<Integer> stream = list1.stream();
		List<Integer> squareListAscending = stream.sorted((x,y)->x.compareTo(y)).collect(Collectors.toList());
		System.out.println("sorted list Ascending is " + squareListAscending);
		
		Stream<Integer> stream1 = list1.stream();
		List<Integer> squareListDescending = stream1.sorted((x,y)->-x.compareTo(y)).collect(Collectors.toList());
		System.out.println("sorted list Descending is " + squareListDescending);
	}
}

OutPut:

Original list is [2, 8, 4, 16, 55, 19, 41]
sorted list Ascending is [2, 4, 8, 16, 19, 41, 55]
sorted list Descending is [55, 41, 19, 16, 8, 4, 2]

Explanation :

Ascending sort के लिए ((x,y)->x.compareTo(y) use किया है तथा Descending sort के लिए ((x,y)->-x.compareTo(y) use किया गया है (x के साथ minus symbol लगाया गया है)

Conclusion – आज आपने क्या सीखा

इस post में आपने जाना कि stream API क्या है, उसे कैसे use करते हैं , उसके results को कैसे store करते हैं और उसके बहुत सारे important methods जैसे filter(), map(), min(), max(), sorted() इत्यादि के बारे में जाना |

आशा है कि, आपको मेरा यह Blog Stream API in java in hindi, जरूर पसंद आया होगा |

अगर आप इस post से related कोई सवाल पूँछना चाहते हैं अथवा कोई सुझाव देना चाहते हैं तो comment करके जरूर बताएं, मैं उसका reply जरूर दूँगा |

इस post को अपना कीमती समय देने के लिए बहुत बहुत धन्यवाद् | फिर मिलेंगें |

Leave a Comment