धडे
सुरू करा
शिकायला सुरुवात करा
CodeGym /Java Course /मॉड्यूल 1 /संग्रह - एक मदतनीस वर्ग

संग्रह - एक मदतनीस वर्ग

मॉड्यूल 1
पातळी 18 , धडा 3
उपलब्ध

1. पद्धतींची यादी

Arraysलक्षात ठेवा की जावाच्या निर्मात्यांनी अ‍ॅरेसह काम करताना आमच्या सोयीसाठी कॉल केलेला संपूर्ण मदतनीस वर्ग लिहिला आहे ?

संग्रहासाठी त्यांनी तेच केले. Java मध्ये एक 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आणि वर्ग प्रति se वापरत नाहीत HashMap, परंतु संबंधित इंटरफेससह: Collection<T>, List<T>, Map<K, V>.

ही समस्या नाही: जर एखादी पद्धत a स्वीकारत असेल 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()संग्रहातील सर्व घटक घटकांसह पुनर्स्थित listकरते obj.

कोड कन्सोल आउटपुट 
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