जावा मधील कलेक्टर्स

1. घटक गोळा करणे

शेवटी, आम्ही वर्गातील सर्वात मनोरंजक पद्धती Stream, collect()पद्धतीपर्यंत पोहोचलो आहोत. हे प्रवाहांमधून आमच्या परिचित संग्रह — List<T>, Set<T>, Map<T, R>आणि इतरांकडे जाण्यासाठी वापरले जाते.

पद्धत वितर्क म्हणून collect()एक विशेष ऑब्जेक्ट घेते . collectorहा ऑब्जेक्ट प्रवाहातील सर्व डेटा वाचतो, त्याला विशिष्ट प्रकारच्या संग्रहामध्ये रूपांतरित करतो आणि तो परत करतो. आणि मग गोळा करण्याची पद्धत स्वतःच हा संग्रह परत करते.

हे सर्व काही चपखल पद्धतीने केले जाते: collectorऑब्जेक्टचा प्रकार आहे Collector<T, A, R>. जसे आपण पाहू शकता, त्यात तीन प्रकारचे पॅरामीटर्स आहेत. शेवटचा प्रकार पॅरामीटर ( R) हा सहसा सारखा प्रकार असतो List<T>. याचा अर्थ कंपाइलर या पद्धतीचा वापर करून योग्य रिटर्न प्रकार collect()स्वतः पद्धतीसाठी निर्धारित करू शकतो.

मला आशा आहे की तुम्ही खूप गोंधळलेले नाही. कोणत्याही परिस्थितीत, तुम्हाला स्वतः कलेक्टर ऑब्जेक्ट्स तयार करण्याची आवश्यकता नाही. वर्गाच्या स्थिर पद्धतींद्वारे परत केलेल्या तयार वस्तू Collectorsपुरेशा असतील.

कलेक्टर वर्ग

क्लासमध्ये Collectorsअनेक स्थिर पद्धती आहेत ज्या तयार कलेक्टर वस्तू परत करतात - प्रत्येक प्रसंगासाठी काहीतरी. येथे आम्ही सर्वात महत्वाचे विचार करू.

toList()

toSet()

toMap()

joining()

mapping()

groupingBy()

2. प्रवाहाचे सूचीमध्ये रूपांतर करणे

प्रवाहासोबत काम करण्याचे आणि निकालाला सूचीमध्ये रूपांतरित करण्याचे एक सामान्य उदाहरण खालीलप्रमाणे आहे

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");

List<String> result = list.stream()
   .filter( s -> Character.isUpperCase(s.charAt(0)) )
   .collect( Collectors.toList() );

आम्हाला संग्रहातून एक प्रवाह मिळाला. मग ज्यांचे पहिले अक्षर अप्परकेस आहे फक्त स्ट्रिंग्स ठेवून आम्हाला एक नवीन प्रवाह मिळाला. मग त्या प्रवाहातील सर्व डेटा एका संग्रहात गोळा केला जातो, जो नंतर परत केला जातो.

3. प्रवाहाला सेटमध्ये रूपांतरित करणे

प्रवाहासोबत काम करण्याचे आणि निकालाला सेटमध्ये रूपांतरित करण्याचे एक सामान्य उदाहरण खालीलप्रमाणे आहे

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");

Set<String> result = list.stream()
   .filter( s -> Character.isUpperCase(s.charAt(0)) )
   .collect( Collectors.toSet() );

प्रत्येक गोष्ट स्ट्रीममध्ये रूपांतरित करण्यासाठी कोड सारखीच असते List, फक्त आम्ही भिन्न कलेक्टर ऑब्जेक्ट वापरतो, जी पद्धतीद्वारे परत केली जाते toSet().

4. प्रवाहाचे नकाशामध्ये रूपांतर करणे

परंतु प्रवाहाचे नकाशामध्ये रूपांतर करणे थोडे कठीण आहे. नकाशातील प्रत्येक नोंदीमध्ये दोन घटक असतात: एक की आणि मूल्य. प्रवाहातील प्रत्येक घटकासाठी आपण की आणि मूल्य कसे परिभाषित करू हे आपल्याला शोधण्याची आवश्यकता आहे.

उदाहरण:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "a=2", "b=3", "c=4", "d==3");

Map<String, String> result = list.stream()
   .map( e -> e.split("=") )
   .filter( e -> e.length == 2 )
   .collect( Collectors.toMap(e -> e[0], e -> e[1]) );

येथे काय चालले आहे ते पाहूया.

पहिल्या ओळीत, आम्ही map(...)प्रत्येक स्ट्रिंगला स्ट्रिंगच्या अॅरेमध्ये रूपांतरित करण्यासाठी वापरतो. स्प्लिट पद्धत वापरून, आम्ही प्रत्येक स्ट्रिंगला दोन भागांमध्ये विभाजित करतो.

दुस-या ओळीत, आपण filter()फक्त तेच अॅरे ज्यात दोन घटक असतात त्या पद्धतीकडे जातो. स्ट्रिंग d==3तीन घटकांच्या अॅरेमध्ये विभाजित होते, जे फिल्टरशी जुळत नाही.

आणि शेवटी, शेवटच्या ओळीत, आम्ही प्रवाहाला a मध्ये रूपांतरित करतो Map<String, String>. पद्धतीमध्ये दोन कार्ये दिली जातात toMap(). प्रवाहाच्या प्रत्येक घटकासाठी, पहिल्या फंक्शनने की परत केली पाहिजे आणि दुसरे मूल्य परत करेल .

प्रत्येक अॅरेचा पहिला घटक ("a", "b", "c") आमची की असेल आणि प्रत्येक अॅरेचा दुसरा घटक ("2", "3", "4") आमची मूल्य असेल.

5. प्रवाहाला स्ट्रिंगमध्ये रूपांतरित करणे

आणखी एक मनोरंजक कलेक्टर ऑब्जेक्ट ने परत केला आहे Collectors.joining(). हे प्रवाहातील सर्व घटकांना Stringएका स्ट्रिंगमध्ये रूपांतरित करते आणि एकत्र करते. उदाहरण

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "a=2", "b=3", "c=4", "d==3");
String result = list.stream().collect( Collectors.joining(", ") );