CollectionUtils klase mula sa Apache Commons

Panimula sa CollectionUtils

Isa pang generic na klase ng utility na naglalaman ng maraming kapaki-pakinabang na pamamaraan:

Tingnan natin ang ilang mga pamamaraan.

Mga paraan upang suriin kung walang laman ang isang koleksyon

Narito kung gaano kadaling matukoy kung walang laman ang isang koleksyon:

CollectionUtils.isEmpty(null); // true
CollectionUtils.isEmpty(new LinkedList<>()); // true
CollectionUtils.isEmpty(Collections.singleton(new int[]{2, 1})); // false

Ito ay kasingdali lamang na suriin kung ang isang koleksyon ay walang laman:

CollectionUtils.isNotEmpty(null); // false
CollectionUtils.isNotEmpty(new LinkedList<>()); // false
CollectionUtils.isNotEmpty(Collections.singleton(new int[]{2, 1})); // true

Mga halimbawa:

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

Isang Gabay sa Apache Commons Collections CollectionUtils

Mga operasyon sa mga set

Kung kailangan mong harapin ang set theory, alam mo na mayroong 4 na pangunahing operasyon sa mga set: unyon, intersection, difference at disjunction.

Para sa mga operasyong ito, ang klase ng CollectionUtils ay may 4 na pamamaraan:

• unyon()
• interseksyon()
• disjunction()
• ibawas()

Nasa ibaba ang ilang simpleng halimbawa:

Isang asosasyon

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]

interseksyon

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]

Disjunction

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]

Pagkakaiba (bawas)

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]

Ang mga operasyon sa mga set, ipinagpatuloy

Ipinapakita ng halimbawang ito kung paano gamitin ang apat na pamamaraan sa itaas upang gumana sa dalawang koleksyon:

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

Ang aming resulta:

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}

Maaari kang mag-eksperimento sa mga pamamaraang ito nang mag-isa.

unmodifiableCollection() Method

Minsan kailangan nating ipatupad ang mga pamamaraan ng interface na kailangang ibalik ang mga koleksyon ng panloob na data ng ating mga bagay. At dahil panloob ang data, ayaw naming baguhin ito ng sinuman saanman.

O nakatanggap kami sa isang lugar ng isang koleksyon na hindi kailangang baguhin, ngunit napipilitang ipasa ito sa ilang paraan ng third-party. Nasaan ang garantiya na hindi niya ito babaguhin?

Upang makatulog nang mapayapa, ang koleksyon ay maaaring balot sa isang espesyal na wrapper na maglalagay ng isang pagbubukod kapag sinusubukang baguhin ang koleksyon.

Halimbawa:

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]

Ang paraan ng Collections.unmodifiableCollection() ay nagbabalik ng isang wrapper sa koleksyon na ipinasa dito. Kung tatawagin mo ang get() , size() na mga pamamaraan , gagana ang lahat. Gayunpaman, kapag tumatawag sa add() , set() , remove() method , makakakuha ka ng exception.

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

Sa katunayan, ang pamamaraan ay minarkahan na bilang hindi na ginagamit at inirerekumenda na gamitin ang Collections.unmodifiableCollection(Collection<? extends T> c) sa halip .

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