సేకరణలు

జావా కలెక్షన్స్
స్థాయి , పాఠం
అందుబాటులో ఉంది

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

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

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

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

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

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

కోడ్ వివరణ
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)
ఈ సేకరణను సమకాలీకరించబడిన ప్రతిరూపంలో వ్రాప్ చేస్తుంది.
జాబితా, మ్యాప్, సెట్ మరియు క్రమబద్ధీకరించబడిన సెట్ కోసం ఇలాంటి పద్ధతులు ఉన్నాయి.

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

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

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

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

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

వ్యాఖ్యలు
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION