Apache Commons की CollectionUtils क्लास

कलेक्शन यूटिल्स का परिचय

एक अन्य सामान्य उपयोगिता वर्ग जिसमें कई उपयोगी विधियाँ हैं:

आइए कुछ तरीकों पर गौर करें।

यह जांचने के तरीके कि कोई संग्रह खाली है या नहीं

यह निर्धारित करना कितना आसान है कि संग्रह खाली है या नहीं:

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);