CollectionUtils चा परिचय
आणखी एक सामान्य उपयुक्तता वर्ग ज्यामध्ये अनेक उपयुक्त पद्धती आहेत:
addAll(संकलन<C> संकलन, C... घटक) | संग्रहामध्ये अॅरे C चे सर्व घटक जोडते |
AddIgnoreNull(संग्रह<T> संकलन, T ऑब्जेक्ट) | घटक शून्य नसल्यास जोडतो |
समाविष्टीत आहे सर्व(संग्रह<?> coll1, संग्रह<?> coll2) | संग्रह1 मध्ये संग्रह2 चे सर्व घटक आहेत हे तपासते |
समाविष्टीत आहे कांही(संग्रह<?> coll1, संग्रह<?> coll2) | संग्रह1 मध्ये संग्रह2 मधील किमान एक घटक आहे हे तपासते |
काउंट मॅचेस(इटेबल<C> इनपुट, प्रेडिकेट<? सुपर सी> प्रेडिकेट) | संग्रहातील किती घटक पूर्वनिर्धारित नियमाचे पालन करतात याची गणना करते |
विच्छेदन (पुनरावृत्ती करण्यायोग्य<? विस्तारित O> a, पुनरावृत्ती करण्यायोग्य<? विस्तारित O> b) | केवळ एकाच संग्रहात असलेल्या, परंतु दोन्ही नसलेल्या वस्तू मिळवते |
छेदनबिंदू(Iterable<? extends O> a, Iterable<? extensions O> b) | एकाच वेळी दोन्ही संग्रहांचा भाग असलेल्या वस्तूंचा संग्रह मिळवते |
union(Iterable<? extends O> a, Iterable<? विस्तार O> b) | कमीत कमी एका संग्रहाचा भाग असलेल्या वस्तूंचा संग्रह मिळवते |
रिक्त संग्रह() | एक विशेष रिक्त संग्रह परत करते |
emptyIfNull(संग्रह<T> संकलन) | संकलन == शून्य असल्यास रिक्त संग्रह परत करते |
अस्तित्वात आहे (इटेबल<C> इनपुट, प्रेडिकेट<? सुपर सी> प्रेडिकेट) | संग्रहात एखादा घटक आहे की नाही ते तपासते जे predicate नियम पूर्ण करते |
एक्स्ट्रॅक्ट सिंगलटन(संग्रह<E> संग्रह) | संग्रहातील एकमेव घटक मिळवते |
फिल्टर (इटेबल<T> कलेक्शन, प्रेडिकेट<? सुपर टी> प्रीडिकेट) | संकलनाचे घटक फिल्टर करते |
शोधा(Iterable<T> संग्रह, Predicate<? super T> predicate) | संग्रहातील घटक शोधत आहात |
isEmpty(संकलन<?> coll) | संग्रह रिकामा आहे का ते तपासते |
isEqualCollection(संकलन<?> a, कलेक्शन<?> b) | संग्रहांची तुलना करते |
isFull(संकलन<? ऑब्जेक्ट> कॉलचा विस्तार) | संग्रहात अद्याप घटक जोडला जाऊ शकतो का ते तपासते |
isNotEmpty(संग्रह<?> कॉल) | संग्रह रिकामा नाही का ते तपासा |
isSubCollection(संकलन<?> a, कलेक्शन<?> b) | संग्रह B संकलन A मध्ये आहे का ते तपासते |
जुळतेसर्व(पुन्हा करता येण्याजोगे<C> इनपुट, प्रेडीकेट<? सुपर सी> प्रीडिकेट) | संग्रहातील सर्व घटक पूर्वनिर्धारित नियमाचे पालन करतात हे तपासते |
सर्व काढून टाका(संग्रह<E> संग्रह, संग्रह<?> काढून टाका) | संग्रहातील सर्व घटक काढून टाकते |
सर्व राखून ठेवा(संग्रह<C> संग्रह, संग्रह<?> राखून ठेवा) | संग्रहाच्या सर्व घटकांचा समावेश असलेला संग्रह परत करतो जे राखून ठेवण्यामध्ये देखील समाविष्ट आहेत |
रिव्हर्स अॅरे(ऑब्जेक्ट[] अॅरे) | अॅरे मागे उलटते |
unmodifiable Collection(संकलन<? विस्तारित C> संग्रह) | संग्रहावर एक आवरण परत करते. संकलनात सुधारणा करण्याचा कोणताही प्रयत्न अपवाद ठरेल. |
चला काही पद्धती पाहू.
संकलन रिकामे आहे की नाही हे तपासण्याचे मार्ग
संग्रह रिकामा आहे हे निर्धारित करणे किती सोपे आहे ते येथे आहे:
CollectionUtils.isEmpty(null); // true
CollectionUtils.isEmpty(new LinkedList<>()); // true
CollectionUtils.isEmpty(Collections.singleton(new int[]{2, 1})); // false
संकलन रिकामे नाही हे तपासणे तितकेच सोपे आहे:
CollectionUtils.isNotEmpty(null); // false
CollectionUtils.isNotEmpty(new LinkedList<>()); // false
CollectionUtils.isNotEmpty(Collections.singleton(new int[]{2, 1})); // true
उदाहरणे:
User ivan = new User("Ivan", "ivan@email.com");
User petr = new User("Petr", "petr@email.com");
List<User> users = new ArrayList<>();
System.out.println(CollectionUtils.isEmpty(users)); // true
System.out.println(CollectionUtils.isNotEmpty(users)); // false
users.add(ivan);
users.add(petr);
System.out.println(CollectionUtils.isEmpty(users)); // false
System.out.println(CollectionUtils.isNotEmpty(users)); // true
users = null;
System.out.println(CollectionUtils.isEmpty(users)); // true
System.out.println(CollectionUtils.isNotEmpty(users)); // false
Apache Commons CollectionUtils साठी मार्गदर्शक
सेटवर ऑपरेशन्स
जर तुम्हाला सेट थेअरीचा सामना करायचा असेल, तर तुम्हाला माहीत आहे की सेट्सवर 4 मूलभूत ऑपरेशन्स आहेत: युनियन, इंटरसेक्शन, डिफरन्स आणि डिजंक्शन.
![](https://cdn.codegym.cc/images/article/33592357-0b07-4f2d-ac05-c336539da1cf/800.jpeg)
या ऑपरेशन्ससाठी, CollectionUtils क्लासमध्ये 4 पद्धती आहेत:
- संघ()
- छेदनबिंदू()
- वियोग()
- वजा()
खाली काही सोपी उदाहरणे आहेत:
एक संघटना
List<String> firstList = Arrays.asList("1", "2", "3", "4", "5", "6");
List<String> secondList = Arrays.asList("2", "3", "6", "7", "8", "9");
//combine two sets
Collection<String> result = CollectionUtils.union(firstList, secondList);
System.out.println(ArrayUtils.toString(result)); //[1, 2, 3, 4, 5, 6, 7, 8, 9]
छेदनबिंदू
List<String> firstList = Arrays.asList("A", "B", "C", "D", "E", "F");
List<String> secondList = Arrays.asList("B", "D", "F", "G", "H", "K");
//intersections of two sets
Collection<String> result = CollectionUtils.intersection(firstList, secondList);
System.out.println(ArrayUtils.toString(result)); //[B, D, F]
वियोग
List<String> firstList = Arrays.asList("1", "2", "3", "4", "5", "6");
List<String> secondList = Arrays.asList("2", "3", "6", "7", "8", "9");
//disjunction
Collection<String> result = CollectionUtils.disjunction(firstList, secondList);
System.out.println(ArrayUtils.toString(result)); //[1, 4, 5, 7, 8, 9]
फरक (वजावट)
List<String> firstList = Arrays.asList("1", "2", "3", "4", "5", "6");
List<String> secondList = Arrays.asList("2", "3", "6", "7", "8", "9");
//difference
Collection<String> result = CollectionUtils.subtract(firstList, secondList);
System.out.println(ArrayUtils.toString(result)); // [1, 4, 5]
सेटवर ऑपरेशन्स चालू राहिल्या
हे उदाहरण दोन संग्रहांसह कार्य करण्यासाठी वरील चार पद्धती कशा वापरायच्या हे दर्शविते:
List<Integer> firstList = Arrays.asList(1, 2, 3, 3, 4, 5);
List<Integer> secondList = Arrays.asList(3, 4, 4, 5, 6, 7);
Collection<Integer> union = CollectionUtils.union(firstList, secondList); // An association
Collection<Integer> intersection = CollectionUtils.intersection(firstList, secondList); // Intersection
Collection<Integer> disjunction = CollectionUtils.disjunction(firstList, secondList); // disjunction
Collection<Integer> subtract = CollectionUtils.subtract(firstList, secondList); // Difference
System.out.println("firstList: " + ArrayUtils.toString(firstList.toArray()));
System.out.println("secondList: " + ArrayUtils.toString(secondList.toArray()));
System.out.println("An association: " + ArrayUtils.toString(union.toArray()));
System.out.println("Intersection: " + ArrayUtils.toString(intersection.toArray()));
System.out.println("Disjunction: " + ArrayUtils.toString(disjunction.toArray()));
System.out.println("Difference: " + ArrayUtils.toString(subtract.toArray()));
आमचा निकाल:
firstList: {1,2,3,3,4,5}
secondList: {3,4,4,5,6,7}
An association: {1,2,3,3,4,4,5,6,7}
intersection: {3,4,5}
Disjunction: {1,2,3,4,6,7}
Difference: {1,2,3}
या पद्धतींचा तुम्ही स्वतः प्रयोग करू शकता.
unmodifiable Collection() पद्धत
कधीकधी आम्हाला इंटरफेस पद्धती लागू कराव्या लागतात ज्यांना आमच्या ऑब्जेक्ट्सच्या अंतर्गत डेटाचे संग्रह परत करणे आवश्यक असते. आणि डेटा अंतर्गत असल्याने, कोणीही तो कुठेतरी बदलू नये अशी आमची इच्छा आहे.
किंवा आम्हाला कोठेतरी एक संग्रह प्राप्त झाला आहे जो बदलण्याची आवश्यकता नाही, परंतु ते एखाद्या तृतीय-पक्षाच्या पद्धतीमध्ये पास करण्यास भाग पाडले आहे. तो बदलणार नाही याची शाश्वती कुठे आहे?
शांतपणे झोपण्यासाठी, संग्रह एका विशेष आवरणात गुंडाळला जाऊ शकतो जो संग्रह सुधारित करण्याचा प्रयत्न करताना अपवाद फेकून देईल.
उदाहरण:
Collection<String> firstCollection = new ArrayList<String>();
Collection<String> secondCollection = Collections.unmodifiableCollection(firstCollection);
firstCollection.add("hello");
firstCollection.add("from");
firstCollection.add("codeGym");
//secondCollection.add("have a error");
System.out.println(secondCollection); //[hello, from, codeGym]
Collections.unmodifiableCollection() पद्धत त्याला पास केलेल्या कलेक्शनवर रॅपर देते. जर तुम्ही त्याच्या get() , size() पद्धतींना कॉल केला तर सर्वकाही कार्य करेल. तथापि, add() , set() , remove() पद्धतींना कॉल करताना , तुम्हाला अपवाद मिळेल.
java.lang.UnsupportedOperationException
at org.apache.commons.collections.collection.UnmodifiableCollection.add(UnmodifiableCollection.java:75)
खरं तर, पद्धत आधीच नापसंत म्हणून चिन्हांकित केली आहे आणि त्याऐवजी Collections.unmodifiableCollection(Collection<? extensions T> c) वापरण्याची शिफारस केली जाते .
Collection<String> firstCollection = new ArrayList<String>();
Collection<String> secondCollection =
Collections.unmodifiableCollection(firstCollection);
GO TO FULL VERSION