Course జావా కలెక్షన్స్ - Lecture: సేకరణ ఇంటర్‌ఫేస్‌లు

"హాయ్, అమిగో!"

"హాయ్, ఎల్లీ!"

"ఈ రోజు మనం కలెక్షన్ల నిర్మాణంపై ఒక్కసారిగా తలలు చుట్టుకోబోతున్నాం."

"నేను దీని కోసం చాలా కాలం వేచి ఉన్నాను."

"సేకరణలు అంటే ఏమిటో మీకు ఇప్పటికే తెలుసు మరియు వాటితో ఎలా పని చేయాలో మీకు తెలుసు. మీ జ్ఞానాన్ని కఠినమైన వ్యవస్థగా నిర్వహించాల్సిన సమయం ఇది. అప్పుడు చాలా 'ఎందుకు' మరియు 'ఎలా' ప్రశ్నలు తొలగిపోతాయి మరియు చాలా విషయాలు స్పష్టంగా కనిపిస్తాయి."

" సేకరణ ఇంటర్‌ఫేస్‌లు . సేకరణ ఇంటర్‌ఫేస్‌ల వారసత్వ నిర్మాణం ఇలా కనిపిస్తుంది:"

రెండు విషయాలు గమనించండి.

మొదట, మీరు ఇక్కడ చూసే ప్రతిదీ ఇంటర్ఫేస్.

రెండవది, బాణాలు అంటే "వారసత్వం".

"మరో మాటలో చెప్పాలంటే, జాబితా, సెట్ మరియు క్యూలు సేకరణను వారసత్వంగా పొందుతాయి, కానీ మ్యాప్ చేయలేదా?"

"అవును. అబ్‌స్ట్రాక్ట్ క్లాస్‌లు ఈ ఇంటర్‌ఫేస్‌లను వారసత్వంగా పొందుతాయి మరియు క్రమంగా, మీకు తెలిసిన ఇంప్లిమెంటేషన్‌లు ఆ నైరూప్య తరగతులను వారసత్వంగా పొందుతాయి: ArrayList, Hashtable, TreeSet,... "

"మీరు చెప్పింది నిజమే."

"ఇప్పుడు ఈ ఇంటర్‌ఫేస్‌ల పద్ధతులు ఏమిటో చూద్దాం:"

ఇటరబుల్<E> యొక్క పద్ధతులు : ఇంటర్ఫేస్:

పద్ధతులు	వివరణ
`Iterator<T> iterator();`	ఇటరేటర్ ఆబ్జెక్ట్‌ను అందిస్తుంది.

"అది చాలదు."

"సరే, ఎంతమంది ఉన్నారు. ఇటరేటర్స్‌కి అంతే. మేము వాటిని ప్రస్తుతం కవర్ చేయము, అయితే త్వరలో వాటిని వివరంగా కవర్ చేస్తాము."

సేకరణ పద్ధతులు <E>: ఇంటర్ఫేస్:

పద్ధతులు	వివరణ
`boolean add(E e);`	సేకరణకు ఒక మూలకాన్ని జోడిస్తుంది
`boolean addAll(Collection<? extends E> c);`	సేకరణకు అంశాలను జోడిస్తుంది
`void clear();`	సేకరణ నుండి అన్ని అంశాలను తొలగిస్తుంది
`boolean contains(Object o);`	సేకరణలో మూలకం ఉందో లేదో తనిఖీ చేస్తుంది.
`boolean containsAll(Collection<?> c);`	సేకరణలో అంశాలు ఉన్నాయో లేదో తనిఖీ చేస్తుంది.
`boolean equals(Object o);`	కలెక్షన్లు సమానంగా ఉన్నాయో లేదో తనిఖీ చేస్తుంది
`int hashCode();`	హాష్ కోడ్‌ను అందిస్తుంది
`boolean isEmpty();`	సేకరణ ఖాళీగా ఉందో లేదో తనిఖీ చేస్తుంది.
`Iterator<E> iterator();`	ఇటరేటర్ ఆబ్జెక్ట్‌ను అందిస్తుంది
`boolean remove(Object o);`	సేకరణ నుండి ఒక మూలకాన్ని తీసివేస్తుంది
`boolean removeAll(Collection<?> c);`	సేకరణ నుండి మూలకాలను తొలగిస్తుంది
`boolean retainAll(Collection<?> c);`	c లో లేని అన్ని మూలకాలను తొలగిస్తుంది
`int size();`	సేకరణ పరిమాణాన్ని అందిస్తుంది
`Object[] toArray();`	సేకరణను శ్రేణికి మారుస్తుంది
`<T> T[] toArray(T[] a);`	సేకరణను శ్రేణికి మారుస్తుంది

"నేను ఇక్కడ ప్రతిదానిపై ఇప్పటికే దృఢంగా ఉన్నాను. నేను ఈ పద్ధతుల్లో సగం ఉపయోగించాను మరియు మిగిలిన సగం నేను ఎదుర్కొన్నాను."

"గ్రేట్, అప్పుడు కొనసాగిద్దాం."

జాబితా యొక్క పద్ధతులు <E>: ఇంటర్ఫేస్:

పద్ధతులు	వివరణ
`void add(int index, E element);`	సేకరణ మధ్యలో మూలకాలను జోడిస్తుంది
`boolean addAll(int index, Collection<? extends E> c);`	సేకరణకు అంశాలను జోడిస్తుంది
`E get(int index);`	ఇండెక్స్ ద్వారా మూలకాన్ని అందిస్తుంది
`int indexOf(Object o);`	మూలకం యొక్క సూచిక (సంఖ్య)ని అందిస్తుంది
`int lastIndexOf(Object o);`	చివరి మూలకం యొక్క సూచికను అందిస్తుంది.
`ListIterator<E> listIterator();`	జాబితా కోసం ఇటరేటర్‌ని అందిస్తుంది
`ListIterator<E> listIterator(int index);`	జాబితా కోసం ఇటరేటర్‌ని అందిస్తుంది
`E remove(int index);`	ఒక మూలకాన్ని దాని సూచిక ద్వారా తొలగిస్తుంది
`E set(int index, E element);`	ఇండెక్స్ ద్వారా కొత్త విలువను సెట్ చేస్తుంది
`List<E> subList(int fromIndex, int toIndex);`	ఉపసంకలనాన్ని అందిస్తుంది

"ఇక్కడ కొత్తగా ఏమీ లేదు. కలెక్షన్ల గురించి నాకు ఇప్పటికే దాదాపు ప్రతిదీ తెలుసు, దాని గురించి నేను సంతోషంగా ఉండలేను."

"సరే, నేను మిమ్మల్ని ఆశ్చర్యపరిచేదాన్ని కనుగొనగలనని అనుకుంటున్నాను. అయితే ఇంటర్‌ఫేస్‌లను పరిశీలించడాన్ని కొనసాగిద్దాం:"

సెట్ యొక్క పద్ధతులు <E>: ఇంటర్ఫేస్:

పద్ధతులు	వివరణ
పద్ధతులు లేవు

"సెట్ ఇంటర్‌ఫేస్‌లో కొత్త పద్ధతులు ఏవీ లేవు — అది వారసత్వంగా పొందేవి మాత్రమే."

"అవును, ఇంటర్‌బుల్ ఇంటర్‌ఫేస్‌లో కూడా ఏమీ లేదని నేను చూశాను.

"మరోవైపు, తక్కువ పద్ధతులు అంటే గుర్తుంచుకోవడం తక్కువ!"

"మీ జీవితాన్ని ధృవీకరించే ఆశావాదం నన్ను సంతోషపరుస్తుంది."

"సెట్ ఇంటర్‌ఫేస్ పద్ధతులతో రెండు ఇంటర్‌ఫేస్‌ల ద్వారా సంక్రమించబడింది: క్రమబద్ధీకరించబడిన సెట్ మరియు నావిగేబుల్‌సెట్. కానీ నేను వాటిపైకి వెళ్లను లేదా మేము ఎప్పటికీ పూర్తి చేయలేము."

"బదులుగా, జావాలో సేకరణలను వివరించే తరగతులు మరియు ఇంటర్‌ఫేస్‌ల సాధారణ చిత్రాన్ని మీకు ఇస్తాను."

"దీన్ని తీసుకురండి."

"అప్పుడు గట్టిగా పట్టుకోండి:"

"వావ్, అది చాలా పెద్దది!"

"సరే, ఇది పెద్దది కాదు. అలాగే, వియుక్త తరగతులు పూర్తిగా ఐచ్ఛికమని గుర్తుంచుకోండి. కానీ ఏ తరగతి ఇంటర్‌ఫేస్‌లను అమలు చేస్తుందో గుర్తుంచుకోవడం మంచిది. అది చాలా తరచుగా ఉపయోగపడుతుంది."

"ఓహ్, కొన్ని సేకరణలు వాడుకలో లేనివిగా పరిగణించబడుతున్నాయని కూడా నేను గమనించాలనుకుంటున్నాను."

"అవి ఏవి?"

"నేను వెక్టర్, స్టాక్, డిక్షనరీ మరియు హ్యాష్‌టేబుల్ తరగతుల గురించి మాట్లాడుతున్నాను. ఇవి సాధారణ సేకరణల యొక్క సమకాలీకరించబడిన (థ్రెడ్-సేఫ్) వెర్షన్‌లు."

"కానీ జావా ఇతర థ్రెడ్‌ల నుండి యాక్సెస్ చేయడమే కాకుండా, మరింత సమర్థవంతమైన అమలును కలిగి ఉండే అనేక సేకరణలతో ప్రత్యేక కాన్కరెన్సీ లైబ్రరీని జోడించింది . ConcurrentHashMap Hashtable కంటే చాలా సమర్థవంతమైనది ."

"మీరు వెక్టర్, స్టాక్, డిక్షనరీ మరియు హ్యాష్‌టేబుల్ సేకరణలను ఉపయోగించవచ్చు, కానీ ఇది సిఫార్సు చేయబడదు."

"అర్థమైంది, నేను దానిని గుర్తుంచుకోవాలి."

"ధన్యవాదాలు, ఎల్లీ!"