Apache Commons నుండి 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);