Apache Commons कडून संकलनUtils वर्ग

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

Apache Commons CollectionUtils साठी मार्गदर्शक

सेटवर ऑपरेशन्स

जर तुम्हाला सेट थेअरीचा सामना करायचा असेल, तर तुम्हाला माहीत आहे की सेट्सवर 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}

या पद्धतींचा तुम्ही स्वतः प्रयोग करू शकता.

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