జావాలో కలెక్టర్లు

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() );

స్ట్రీమ్‌ను a కు మార్చడానికి ప్రతిదీ కోడ్‌కి చాలా పోలి ఉంటుంది 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(", ") );