அப்பாச்சி காமன்ஸில் இருந்து CollectionUtils வகுப்பு

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 Collections 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}

இந்த முறைகளை நீங்களே பரிசோதனை செய்யலாம்.

மாற்ற முடியாத சேகரிப்பு() முறை

சில சமயங்களில் நமது பொருட்களின் அகத் தரவுகளின் சேகரிப்புகளைத் திரும்பப் பெற வேண்டிய இடைமுக முறைகளை நாம் செயல்படுத்த வேண்டும். மேலும் தரவு அகமாக இருப்பதால், அதை எங்காவது யாரும் மாற்றுவதை நாங்கள் விரும்பவில்லை.

அல்லது மாற்ற வேண்டிய தேவையில்லாத ஒரு தொகுப்பை எங்காவது பெற்றுள்ளோம், ஆனால் அதை மூன்றாம் தரப்பு முறைக்கு அனுப்ப வேண்டிய கட்டாயத்தில் உள்ளது. மாற்ற மாட்டார் என்பதற்கு எங்கே உத்தரவாதம்?

நிம்மதியாக தூங்குவதற்காக, சேகரிப்பை ஒரு சிறப்பு ரேப்பரில் சுற்றலாம், இது சேகரிப்பை மாற்ற முயற்சிக்கும் போது விதிவிலக்கு அளிக்கும்.

உதாரணமாக:

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() methods என்று அழைத்தால் , எல்லாம் வேலை செய்யும். இருப்பினும், add() , set() , remove() முறைகளை அழைக்கும் போது , ​​உங்களுக்கு விதிவிலக்கு கிடைக்கும்.

java.lang.UnsupportedOperationException
at org.apache.commons.collections.collection.UnmodifiableCollection.add(UnmodifiableCollection.java:75)

உண்மையில், இந்த முறை ஏற்கனவே தடுக்கப்பட்டதாகக் குறிக்கப்பட்டுள்ளது, அதற்குப் பதிலாக Collections.unmodifiableCollection(சேகரிப்பு<? நீட்டிக்கிறது T> c) ஐப் பயன்படுத்த பரிந்துரைக்கப்படுகிறது .

Collection<String> firstCollection = new ArrayList<String>();
Collection<String> secondCollection =
Collections.unmodifiableCollection(firstCollection);