Panimula sa CollectionUtils
Isa pang generic na klase ng utility na naglalaman ng maraming kapaki-pakinabang na pamamaraan:
addAll(Collection<C> collection, C...elements) | Idinaragdag ang lahat ng elemento ng array C sa koleksyon |
addIgnoreNull(Collection<T> collection, T object) | Nagdaragdag ng elemento kung hindi ito null |
naglalaman ngLahat(Collection<?> coll1, Collection<?> coll2) | Sinusuri kung ang collection1 ay naglalaman ng lahat ng elemento ng collection2 |
naglalaman ng Any(Collection<?> coll1, Collection<?> coll2) | Sinusuri kung ang collection1 ay naglalaman ng kahit isang elemento mula sa collection2 |
countMatches(Iterable<C> input, Predicate<? super C> predicate) | Binibilang kung gaano karaming mga elemento sa isang koleksyon ang nakakatugon sa isang tuntunin ng panaguri |
disjunction(Iterable<? extend O> a, Iterable<? extend O> b) | Ibinabalik ang mga bagay na nasa isang koleksyon lang, ngunit hindi pareho |
intersection(Iterable<? extend O> a, Iterable<? extend O> b) | Ibinabalik ang isang koleksyon ng mga bagay na bahagi ng parehong mga koleksyon nang sabay-sabay |
unyon(Iterable<? extend O> a, Iterable<? extend O> b) | Ibinabalik ang isang koleksyon ng mga bagay na bahagi ng hindi bababa sa isang koleksyon |
emptyCollection() | Nagbabalik ng espesyal na walang laman na koleksyon |
emptyIfNull(Collection<T> collection) | Nagbabalik ng walang laman na koleksyon kung koleksyon == null |
umiiral(Iterable<C> input, Predicate<? super C> predicate) | Sinusuri kung mayroong elemento sa koleksyon na nakakatugon sa tuntunin ng panaguri |
extractSingleton(Collection<E> collection) | Ibinabalik ang tanging elemento ng koleksyon |
filter(Iterable<T> collection, Predicate<? super T> predicate) | Sinasala ang mga elemento ng isang koleksyon |
find(Iterable<T> collection, Predicate<? super T> predicate) | Naghahanap ng mga elemento ng isang koleksyon |
isEmpty(Collection<?> coll) | Tinitingnan kung walang laman ang koleksyon |
isEqualCollection(Collection<?> a, Collection<?> b) | Inihahambing ang mga koleksyon |
isFull(Collection<? extends Object> coll) | Sinusuri kung ang isang elemento ay maaari pa ring idagdag sa koleksyon |
isNotEmpty(Collection<?> coll) | Tingnan kung walang laman ang koleksyon |
isSubCollection(Collection<?> a, Collection<?> b) | Sinusuri kung ang koleksyon B ay nasa koleksyon A |
matchesAll(Iterable<C> input, Predicate<? super C> predicate) | Sinusuri kung ang lahat ng elemento ng isang koleksyon ay nakakatugon sa isang tuntunin ng panaguri |
removeAll(Collection<E> collection, Collection<?> remove) | Tinatanggal ang lahat ng elemento ng koleksyon |
retainAll(Collection<C> collection, Collection<?> retain) | Nagbabalik ng koleksyon na naglalaman ng lahat ng elemento ng koleksyon na nakapaloob din sa retain |
reverseArray(Object[] array) | Binabaliktad ang isang array pabalik |
unmodifiableCollection(Collection<? extend C> collection) | Ibinabalik ang isang wrapper sa koleksyon. Anumang pagtatangka na baguhin ang koleksyon ay magbibigay ng pagbubukod. |
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.
![](https://cdn.codegym.cc/images/article/33592357-0b07-4f2d-ac05-c336539da1cf/800.jpeg)
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);