పాఠాలు
ప్రారంభించండి
నేర్చుకోవడం ప్రారంభించండి
CodeGym /జావా కోర్సు /మాడ్యూల్ 1 /సేకరణలు — సహాయక తరగతి

సేకరణలు — సహాయక తరగతి

మాడ్యూల్ 1
స్థాయి , పాఠం
అందుబాటులో ఉంది

1. పద్ధతుల జాబితా

Arraysజావా సృష్టికర్తలు శ్రేణులతో పని చేస్తున్నప్పుడు మన సౌలభ్యం కోసం మొత్తం సహాయక తరగతిని వ్రాసినట్లు గుర్తుందా ?

కలెక్షన్ల విషయంలోనూ అదే పని చేశారు. java.util.Collectionsసేకరణలతో పని చేయడానికి ఉపయోగపడే అనేక పద్ధతులను కలిగి ఉన్న తరగతి జావాలో ఉంది . ఇక్కడ అత్యంత ఆసక్తికరమైనవి మాత్రమే ఉన్నాయి:

పద్ధతులు వివరణ 
addAll(colls, e1, e2, e3, ...)
 మూలకాలు e1, e2, e3, ... సేకరణకు collsజోడిస్తుంది 
fill(list, obj)
 ఆమోదించబడిన జాబితాలోని అన్ని మూలకాలను దీనితో భర్తీ చేస్తుందిobj 
nCopies(n, obj)
 వస్తువు nయొక్క కాపీల జాబితాను అందిస్తుందిobj 
replaceAll(list, oldVal, newVal)
 జాబితాలో oldValఉన్న అన్ని సందర్భాలను భర్తీ చేస్తుందిnewVallist 
copy(dest, src)
 జాబితా నుండి srcజాబితాకు అన్ని అంశాలను కాపీ చేస్తుందిdest 
reverse(list)
 జాబితాను రివర్స్ చేస్తుంది. 
sort(list)
 జాబితాను ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది 
rotate(list, n)
 మూలకాల listద్వారా జాబితా యొక్క మూలకాలను చక్రీయంగా మారుస్తుందిn 
shuffle(list)
 జాబితాలోని మూలకాలను యాదృచ్ఛికంగా షఫుల్ చేస్తుంది 
min(colls)
 collsసేకరణలో కనీస మూలకాన్ని కనుగొంటుంది 
max(colls)
 collsసేకరణలో గరిష్ట మూలకాన్ని కనుగొంటుంది 
frequency(colls, obj)
 సేకరణలో మూలకం ఎన్ని సార్లు objజరుగుతుందో నిర్ణయిస్తుందిcolls 
binarySearch(list, key)
 keyక్రమబద్ధీకరించబడిన జాబితాలో శోధిస్తుంది మరియు సంబంధిత సూచికను అందిస్తుంది. 
disjoint(colls1, colls2)
 trueసేకరణలలో ఉమ్మడి అంశాలు లేకుంటే తిరిగి వస్తుంది
ముఖ్యమైన:

ArrayListఈ పద్ధతుల్లో చాలా వరకు , HashSetమరియు తరగతులను ఉపయోగించవు HashMap, కానీ సంబంధిత ఇంటర్‌ఫేస్‌లతో: Collection<T>, List<T>, Map<K, V>.

ఇది సమస్య కాదు: ఒక పద్ధతిని అంగీకరిస్తే List<T>, మీరు దానిని ఎల్లప్పుడూ పాస్ చేయవచ్చు ArrayList<Integer>, కానీ అసైన్‌మెంట్ ఆపరేటర్ వ్యతిరేక దిశలో పని చేయదు.

2. సేకరణలను సృష్టించడం మరియు సవరించడం

Collections.addAll(Collection<T> colls, T e1, T e2, T e3, ...)పద్ధతి

పద్ధతి addAll()మూలకాలను జోడిస్తుంది e1, e2, e3, ... సేకరణకు collsఎన్ని మూలకాలనైనా పాస్ చేయవచ్చు.

కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5);

for (int i: list)
   System.out.println(i);
 
1
2
3
4
5

Collections.fill(List<T> list, T obj)పద్ధతి

పద్ధతి మూలకంతో సేకరణ fill()యొక్క అన్ని అంశాలను భర్తీ చేస్తుంది .listobj

కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);

Collections.fill(list, 10);

for (int i: list)
   System.out.println(i);
 
10
10
10

Collections.nCopies(int n, T obj)పద్ధతి

పద్ధతి మూలకం యొక్క కాపీల nCopies()జాబితాను అందిస్తుంది . తిరిగి వచ్చిన జాబితా మార్పులేనిదని గుర్తుంచుకోండి, అంటే మీరు దానిని మార్చలేరు! మీరు విలువలను చదవడానికి మాత్రమే దీన్ని ఉపయోగించవచ్చు:nobj

కోడ్ వివరణ 
List<String> immutableList = Collections.nCopies(5, "Hello");

ArrayList<String> list = new ArrayList<String>(immutableList);

for(String s: list)
   System.out.println(s);
 Hello5 స్ట్రింగ్‌ల మార్పులేని జాబితాను సృష్టించండి
మ్యూటబుల్‌ను సృష్టించండి listమరియు జాబితా నుండి విలువలతో దాన్ని పూరించండి immutableList.

కన్సోల్ అవుట్‌పుట్:
Hello
Hello
Hello
Hello
Hello

Collections.replaceAll (List<T> list, T oldValue, T newValue)పద్ధతి

ఈ replaceAll()పద్ధతి సేకరణలోని అన్ని మూలకాలను తో listసమానంగా భర్తీ చేస్తుంది .oldValuenewValue

కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);

Collections.replaceAll(list, 2, 20);

for (int i: list)
   System.out.println(i);
 
1
20
3

Collections.copy (List<T> dest, List<T> src)పద్ధతి

పద్ధతి copy()సేకరణలోని అన్ని అంశాలను srcసేకరణలోకి కాపీ చేస్తుంది dest.

సేకరణ కంటే ఎక్కువ కాలం సేకరణ destప్రారంభమైతే src, సేకరణలోని మిగిలిన అంశాలు destచెక్కుచెదరకుండా ఉంటాయి.

ముఖ్యమైన:
సేకరణ destకనీసం srcసేకరణ ఉన్నంత వరకు ఉండాలి (లేకపోతే, ఒక IndexOutOfBoundsExceptionవిసిరివేయబడుతుంది).
కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> srcList = new ArrayList<Integer>();
Collections.addAll(srcList, 99, 98, 97);

ArrayList<Integer> destList = new ArrayList<Integer>();
Collections.addAll(destList, 1, 2, 3, 4, 5, 6, 7);

Collections.copy(destList, srcList);

for (int i: destList)
   System.out.println(i);
 
99
98
97
4
5
6
7

3. మూలకాల క్రమం

Collections.reverse(List<T> list)పద్ధతి

reverse()ఆమోదించబడిన జాబితా యొక్క మూలకాల క్రమాన్ని పద్ధతి రివర్స్ చేస్తుంది .

కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5);

Collections.reverse(list);

for (int i: list)
   System.out.println(i);
 
5
4
3
2
1

Collections.sort(List<T> list)పద్ధతి

ఈ sort()పద్ధతి ఆమోదించబడిన జాబితాను ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది.

కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15);

Collections.sort(list);

for (int i: list)
   System.out.println(i);
 
2
4
11
15
23

Collections.rotate(List<T> list, int distance)పద్ధతి

ఈ rotate()పద్ధతి చక్రీయంగా ఉత్తీర్ణత పొందిన జాబితా యొక్క మూలకాలను distanceస్థానాల ద్వారా ముందుకు మారుస్తుంది.

కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9);

Collections.rotate(list, 3); // Shift by 3 positions

for (int i: list)
   System.out.println(i);
 
7
8
9
1
2
3
4
5
6

Collections.shuffle(List<T> list)పద్ధతి

ఈ shuffle()పద్ధతి యాదృచ్ఛికంగా ఆమోదించబడిన జాబితాలోని అన్ని అంశాలను షఫుల్ చేస్తుంది. ప్రతిసారీ ఫలితం భిన్నంగా ఉంటుంది.

కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5);

Collections.shuffle(list); // Shuffle the elements

for (int i: list)
   System.out.println(i);
 
5
2
4
3
1

4. సేకరణలలో మూలకాలను కనుగొనడం

Collections.min(Collection<T> colls)పద్ధతి

పద్ధతి min()సేకరణలో కనీస మూలకాన్ని అందిస్తుంది.

కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15);

int min = Collections.min(list);

System.out.println(min);
 
2

Collections.max(Collection<T> colls)పద్ధతి

పద్ధతి max()సేకరణలో గరిష్ట మూలకాన్ని అందిస్తుంది.

కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15);

int max = Collections.max(list);

System.out.println(max);
 
23

Collections.frequency(Collection<T> colls, T obj)పద్ధతి

సేకరణలో frequency()మూలకం ఎన్నిసార్లు objసంభవిస్తుందో పద్ధతి లెక్కించబడుతుందిcolls

కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15, 4, 2, 4);

int count = Collections.frequency(list, 4);

System.out.println(count);
 
3

Collections.binarySearch(Collection<T> colls, T obj)పద్ధతి

పద్ధతి సేకరణలోని మూలకం binarySearch()కోసం శోధిస్తుంది . కనుగొనబడిన మూలకం యొక్క సూచికను అందిస్తుంది. మూలకం కనుగొనబడకపోతే ప్రతికూల సంఖ్యను అందిస్తుంది.objcolls

ముఖ్యమైన:
పద్ధతిని కాల్ చేయడానికి ముందు binarySearch(), సేకరణ తప్పనిసరిగా క్రమబద్ధీకరించబడాలి (ఉపయోగించు Collections.sort()).
కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 5, 15, 4, 2, 4);

Collections.sort(list);  // 2, 2, 4, 4, 5, 11, 15, 23

int index = Collections.binarySearch(list, 5);    // 4
System.out.println(index);

int index2 = Collections.binarySearch(list, 15);  // 6
System.out.println(index2);

int index3 = Collections.binarySearch(list, 16); // The element doesn't exist
System.out.println(index3);
 
4
6
-8

Collections.disjoint(Collection<T> coll1, Collection<T> coll2)పద్ధతి

ఆమోదించబడిన సేకరణలలో ఉమ్మడి అంశాలు ఏవీ లేకుంటే పద్ధతి disjoint()తిరిగి వస్తుంది .true

కోడ్ కన్సోల్ అవుట్‌పుట్ 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7);

ArrayList<Integer> list2 = new ArrayList<Integer>();
Collections.addAll(list2, 99, 98, 97);

boolean isDifferent = Collections.disjoint(list, list2);
System.out.println(isDifferent);
 
true
వ్యాఖ్యలు
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION