कलेक्शन यूटिल्स का परिचय
एक अन्य सामान्य उपयोगिता वर्ग जिसमें कई उपयोगी विधियाँ हैं:
AddAll (संग्रह <सी> संग्रह, सी ... तत्व) | संग्रह में सरणी C के सभी तत्व जोड़ता है |
addIgnoreNull (संग्रह <टी> संग्रह, टी ऑब्जेक्ट) | एक तत्व जोड़ता है अगर यह शून्य नहीं है |
सम्मिलित है (संग्रह<?> col1, संग्रह<?> col2) | जांचता है कि संग्रह 1 में संग्रह 2 के सभी तत्व शामिल हैं |
containsAny(संग्रह<?> coll1, संग्रह<?> coll2) | जांचता है कि संग्रह 1 में संग्रह 2 से कम से कम एक तत्व है |
काउंटमैच (Iterable<C> input, Predicate<? Super C> Predicate) | गणना करता है कि संग्रह में कितने तत्व एक विधेय नियम को पूरा करते हैं |
संयोजन (Iterable<? विस्तार O> a, Iterable<? विस्तार O> b) | उन वस्तुओं को लौटाता है जो केवल एक संग्रह में हैं, लेकिन दोनों में नहीं |
चौराहा (Iterable<? O> a, Iterable<? O> b बढ़ाता है) | उन वस्तुओं का संग्रह लौटाता है जो एक साथ दोनों संग्रह का हिस्सा हैं |
संघ (पुनरावर्तनीय <? विस्तार ओ> ए, पुनरावर्तनीय <? विस्तार ओ> बी) | उन वस्तुओं का संग्रह लौटाता है जो कम से कम एक संग्रह का हिस्सा हैं |
खाली संग्रह () | एक विशेष खाली संग्रह लौटाता है |
emptyIfNull (संग्रह <टी> संग्रह) | संग्रह == शून्य होने पर एक खाली संग्रह लौटाता है |
मौजूद है (पुनरावर्ती <सी> इनपुट, विधेय <? सुपर सी> विधेय) | जाँचता है कि क्या संग्रह में कोई तत्व है जो विधेय नियम को संतुष्ट करता है |
निकालें सिंगलटन (संग्रह <ई> संग्रह) | संग्रह का एकमात्र तत्व लौटाता है |
फ़िल्टर (Iterable <टी> संग्रह, विधेय <? सुपर टी> विधेय) | संग्रह के तत्वों को फ़िल्टर करता है |
ढूँढें (पुनरावर्तनीय <टी> संग्रह, विधेय <? सुपर टी> विधेय) | एक संग्रह के तत्वों की तलाश में |
isEmpty(संग्रह<?> कॉल) | जाँचता है कि क्या संग्रह खाली है |
isEqualCollection(संग्रह <?> ए, संग्रह <?> बी) | संग्रह की तुलना करता है |
isFull(संग्रह<? विस्तार वस्तु> कॉल) | जांचता है कि संग्रह में अभी भी कोई तत्व जोड़ा जा सकता है या नहीं |
isNotEmpty(संग्रह<?> कॉल) | जांचें कि क्या संग्रह खाली नहीं है |
isSubCollection(Collection<?> a, Collection<?> b) | जांचता है कि संग्रह बी संग्रह ए में है या नहीं |
matchAll(Iterable<C> input, Predicate<? Super C> predicate) | जाँचता है कि संग्रह के सभी तत्व एक विधेय नियम को पूरा करते हैं |
सभी हटाएं (संग्रह <ई> संग्रह, संग्रह <?> हटाएं) | संग्रह के सभी तत्वों को हटा देता है |
सभी को बनाए रखें (संग्रह <सी> संग्रह, संग्रह <?> बनाए रखें) | एक संग्रह लौटाता है जिसमें संग्रह के सभी तत्व होते हैं जो बनाए रखने में भी शामिल होते हैं |
रिवर्सएरे (ऑब्जेक्ट [] सरणी) | एक सरणी को पीछे की ओर उलट देता है |
अपरिवर्तनीय चयन (संग्रह <? विस्तार सी> संग्रह) | संग्रह पर एक रैपर लौटाता है। संग्रह को संशोधित करने का कोई भी प्रयास अपवाद फेंक देगा। |
आइए कुछ तरीकों पर गौर करें।
यह जांचने के तरीके कि कोई संग्रह खाली है या नहीं
यह निर्धारित करना कितना आसान है कि संग्रह खाली है या नहीं:
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
अपाचे कॉमन्स कलेक्शंस कलेक्शन यूटिल्स के लिए एक गाइड
सेट पर संचालन
यदि आपको सेट थ्योरी से निपटना है, तो आप जानते हैं कि सेट पर 4 बुनियादी ऑपरेशन होते हैं: यूनियन, इंटरसेक्शन, डिफरेंस और डिसजंक्शन।
इन कार्यों के लिए, 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}
आप इन तरीकों को अपने दम पर आजमा सकते हैं।
अपरिवर्तनीय चयन () विधि
कभी-कभी हमें उन इंटरफ़ेस विधियों को लागू करने की आवश्यकता होती है जिन्हें हमारी वस्तुओं के आंतरिक डेटा के संग्रह को वापस करने की आवश्यकता होती है। और चूंकि डेटा आंतरिक है, इसलिए हम नहीं चाहते कि कोई इसे कहीं बदल दे।
या हमें कहीं ऐसा संग्रह प्राप्त हुआ है जिसे बदलने की आवश्यकता नहीं है, लेकिन इसे किसी तीसरे पक्ष के तरीके से पारित करने के लिए मजबूर किया जाता है। गारंटी कहां है कि वह इसे नहीं बदलेगा?
शांति से सोने के लिए, संग्रह को एक विशेष आवरण में लपेटा जा सकता है जो संग्रह को संशोधित करने का प्रयास करते समय अपवाद फेंक देगा।
उदाहरण:
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]
कलेक्शंस.अनमोडिफायेबल कोलेक्शन () मेथड पास किए गए कलेक्शन पर एक रैपर लौटाता है। यदि आप इसकी get() , size() विधियों को कॉल करते हैं , तो सब कुछ काम करेगा। हालाँकि, ऐड () , सेट () , रिमूव () विधियों को कॉल करते समय , आपको एक अपवाद मिलेगा।
java.lang.UnsupportedOperationException
at org.apache.commons.collections.collection.UnmodifiableCollection.add(UnmodifiableCollection.java:75)
वास्तव में, विधि को पहले से ही पदावनत के रूप में चिह्नित किया गया है और इसके बजाय Collections.unmodifyingCollection(Collection<? extends T> c) का उपयोग करने की अनुशंसा की जाती है ।
Collection<String> firstCollection = new ArrayList<String>();
Collection<String> secondCollection =
Collections.unmodifiableCollection(firstCollection);
GO TO FULL VERSION