"నేను ఇక్కడ ఉన్నాను."

"నేను మీ కోసం చాలా కాలంగా ఇక్కడ వేచి ఉన్నాను."

"నేను ఆశిస్తున్నాను. అప్పుడు కొనసాగిద్దాం."

"సేకరణల కోసం మీకు సూపర్-డూపర్ ఫుల్-ఫీచర్ యుటిలిటీ క్లాస్‌ని అందించడానికి నేను మీకు పరిచయం చేయబోతున్నాను."

"నేను ఇప్పటికే ఉత్సాహంతో వణుకుతున్నాను."

"అద్భుతం. అప్పుడు ప్రారంభిద్దాం. ఇక్కడ కలెక్షన్స్ క్లాస్ పద్ధతులు ఉన్నాయి:"

కోడ్ వివరణ
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 సేకరణలో ఆబ్జెక్ట్‌ ఎన్నిసార్లు ఉందో లెక్కిస్తుంది
int indexOfSubList(List<?> source, List<?> target)
మూలాధార జాబితాలో లక్ష్య జాబితా యొక్క మొదటి సంఘటన యొక్క సూచికను నిర్ణయిస్తుంది.
సూత్రం String.indexOf("కొన్ని స్ట్రింగ్")ని పోలి ఉంటుంది
int lastIndexOfSubList(List<?> source, List<?> target)
మూలాధార జాబితాలో లక్ష్య జాబితా యొక్క చివరి సంఘటన యొక్క సూచికను నిర్ణయిస్తుంది.
String.lastIndexOf ("కొన్ని స్ట్రింగ్") లాగానే
max(Collection<? extends T> coll)
సేకరణలో గరిష్ట సంఖ్య/విలువ కోసం శోధిస్తుంది.
మేము గరిష్టంగా 6 సంఖ్యలను ఎలా కనుగొంటాము?
Collections.max(Arrays.asList(51, 42, 33, 24, 15, 6));
min(Collection<? extends T> coll)
సేకరణలో కనీస విలువ కోసం శోధిస్తుంది.
List<T>nCopies(int n, To)
o మూలకం n సార్లు కనిపించే డమ్మీ సేకరణను సృష్టిస్తుంది.
boolean replaceAll(List<T> list, T oldVal, T newVal)
కొత్తVal మూలకాలతో జాబితాలోని అన్ని పాతవాల్ మూలకాలను భర్తీ చేస్తుంది
void reverse(List<?> list)
జాబితాను రివర్స్ చేస్తుంది.
void shuffle(List<?> list)
జాబితా యొక్క మూలకాలను యాదృచ్ఛికంగా షఫుల్ చేస్తుంది.
List<T>singletonList(To)
ఆమోదించబడిన ఒక మూలకంతో కూడిన మార్పులేని జాబితాను అందిస్తుంది.
మ్యాప్, సెట్ మరియు సార్టెడ్‌సెట్ కోసం ఇలాంటి పద్ధతులు ఉన్నాయి.
void sort(List<T> list)
జాబితాను ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది.
void swap(List<?> list, int i, int j)
జాబితా మూలకాలను మారుస్తుంది
Collection<T>synchronizedCollection(Collection<T> c)
ఈ సేకరణను సమకాలీకరించబడిన ప్రతిరూపంలో వ్రాప్ చేస్తుంది.
జాబితా, మ్యాప్, సెట్ మరియు క్రమబద్ధీకరించబడిన సెట్ కోసం ఇలాంటి పద్ధతులు ఉన్నాయి.

"ఓహ్! అవును, ఇది మొత్తం ఆయుధాగారం, మరియు నేను దానిలో దేనినీ ఉపయోగించలేదు."

"వాస్తవానికి, ఈ రోజు నా పాఠం ఇక్కడే ముగుస్తుంది."

"ఈ పద్ధతులను పరిశీలించండి మరియు మీరు ఎక్కువగా ఉపయోగించే వాటిని కనుగొనండి."

"లేదా ఇంకా బాగా, వాటిని అధ్యయనం చేయండి. అవి మీకు ఉపయోగకరంగా ఉంటాయి."

"ధన్యవాదాలు రిషీ. నేను చదువుకుంటాను."