"இதோ நான் இருக்கிறேன்."

"நான் உனக்காக ரொம்ப நாளா காத்துகிட்டு இருக்கேன்."

"நான் நம்புகிறேன், பிறகு தொடரலாம்."

"கலெக்ஷன்களுக்கான சூப்பர்-டூப்பர் ஃபுல் ஃபீச்சர் யூட்டிலிட்டி கிளாஸை உங்களுக்கு வழங்க நான் உங்களுக்கு அறிமுகப்படுத்தப் போகிறேன்."

"நான் ஏற்கனவே உற்சாகத்துடன் நடுங்குகிறேன்."

"அருமை. பிறகு ஆரம்பிக்கலாம். தொகுப்புகள் வகுப்பின் முறைகள் இதோ:"

குறியீடு விளக்கம்
boolean addAll(Collection<? super T> c, T... elements)
அனுப்பப்பட்ட கூறுகளை அனுப்பிய சேகரிப்பில் சேர்க்கிறது.
இந்த முறையை வசதியாக இப்படி அழைக்கலாம்: Collections.addList (பட்டியல், 10,11,12,13,14,15)
Queue<T> asLifoQueue(Deque<T> deque)
டிக்யூவிலிருந்து உருவாக்கப்பட்ட "சாதாரண வரிசையை" வழங்கும்.
int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
பட்டியலில் உள்ள முக்கிய உறுப்புக்கான பைனரி தேடலைச் செய்கிறது.
பட்டியல் வரிசைப்படுத்தப்பட வேண்டும்.
உறுப்புகளை ஒப்பிடுவதற்கு நீங்கள் ஒரு ஒப்பீட்டாளரைக் குறிப்பிடலாம்.
Collection<E> checkedCollection(Collection<E> c, Class<E> type)
சேகரிப்பு c இன் அனைத்து கூறுகளும் ஒரு குறிப்பிட்ட வகையைச் சேர்ந்ததா என்பதைச் சரிபார்க்கிறது.
இதே போன்ற முறைகள் பட்டியல், வரைபடம், தொகுப்பு மற்றும் வரிசைப்படுத்தப்பட்ட தொகுப்பு ஆகியவற்றிற்கு உள்ளன.
void copy(List<? super T> dest, List<? extends T> src)
src பட்டியலை dest பட்டியலில் நகலெடுக்கிறது.
boolean disjoint(Collection<?> c1, Collection<?> c2)
சேகரிப்புகளில் பொதுவான கூறுகள் இல்லை என்பதை சரிபார்க்கிறது
void fill(List<? super T> list, T obj)
obj என்ற உறுப்புடன் பட்டியலை நிரப்புகிறது
int frequency(Collection<?> c, Object o)
சேகரிப்பு c இல் எத்தனை முறை பொருள் o உள்ளது என்பதைக் கணக்கிடுகிறது
int indexOfSubList(List<?> source, List<?> target)
மூலப் பட்டியலில் உள்ள இலக்குப் பட்டியலின் முதல் நிகழ்வின் குறியீட்டைத் தீர்மானிக்கிறது.
கொள்கை String.indexOf ("சில சரம்") போன்றது
int lastIndexOfSubList(List<?> source, List<?> target)
மூலப் பட்டியலில் உள்ள இலக்குப் பட்டியலின் கடைசி நிகழ்வின் குறியீட்டைத் தீர்மானிக்கிறது.
String.lastIndexOf ("சில சரம்") போன்றது
T max(Collection<? extends T> coll)
தொகுப்பில் அதிகபட்ச எண்/மதிப்பைத் தேடுகிறது.
அதிகபட்சமாக 6 எண்களை எப்படி கண்டுபிடிப்பது?
Collections.max(Arrays.asList(51, 42, 33, 24, 15, 6));
T min(Collection<? extends T> coll)
தொகுப்பில் குறைந்தபட்ச மதிப்பைத் தேடுகிறது.
List<T>nCopies(int n, To)
o உறுப்பு n முறை தோன்றும் போலி சேகரிப்பை உருவாக்குகிறது.
boolean replaceAll(List<T> list, T oldVal, T newVal)
பட்டியலில் உள்ள அனைத்து பழைய வால் உறுப்புகளையும் புதிய வால் உறுப்புகளுடன் மாற்றுகிறது
void reverse(List<?> list)
பட்டியலை மாற்றுகிறது.
void shuffle(List<?> list)
பட்டியலின் கூறுகளை தோராயமாக மாற்றுகிறது.
List<T>singletonList(To)
அனுப்பப்பட்ட ஒரு உறுப்பைக் கொண்ட மாறாத பட்டியலை வழங்கும்.
Map, Set மற்றும் SortedSet ஆகியவற்றிலும் இதே போன்ற முறைகள் உள்ளன.
void sort(List<T> list)
பட்டியலை ஏறுவரிசையில் வரிசைப்படுத்துகிறது.
void swap(List<?> list, int i, int j)
பட்டியலின் கூறுகளை மாற்றுகிறது
Collection<T>synchronizedCollection(Collection<T> c)
இந்தத் தொகுப்பை ஒத்திசைக்கப்பட்ட இணையில் மடிக்கிறது.
இதே போன்ற முறைகள் பட்டியல், வரைபடம், தொகுப்பு மற்றும் வரிசைப்படுத்தப்பட்ட தொகுப்பு ஆகியவற்றிற்கு உள்ளன.

"ஆமாம், இது ஒரு முழு ஆயுதக் கிடங்கு, நான் அதில் எதையும் பயன்படுத்தவில்லை."

"உண்மையில், எனது பாடம் இன்று இங்கு முடிவடைகிறது."

"இந்த முறைகளைப் பாருங்கள், நீங்கள் அதிகம் பயன்படுத்தக்கூடியவற்றைக் கண்டறியவும்."

"அல்லது இன்னும் சிறப்பாக, அவற்றைப் படிக்கவும். அவை உங்களுக்கு பயனுள்ளதாக இருக்கும்."

"நன்றி ரிஷி. நான் போய் படிக்கிறேன்."