ஜாவாவில் சேகரிப்பாளர்கள்

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