Kelas CollectionUtils saka Apache Commons

Pambuka kanggo CollectionUtils

Kelas utilitas umum liyane sing ngemot akeh cara migunani:

Ayo goleki sawetara cara.

Cara kanggo mriksa yen koleksi kosong

Mangkene carane gampang kanggo nemtokake manawa koleksi kosong:

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

Gampang banget kanggo mriksa manawa koleksi ora kosong:

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

Tuladha:

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

Pandhuan kanggo Apache Commons Collections CollectionUtils

Operasi ing set

Yen sampeyan kudu menehi hasil karo teori set, sampeyan ngerti yen ana 4 operasi dhasar ing set: union, intersection, prabédan lan disjunction.

Kanggo operasi kasebut, kelas CollectionUtils duwe 4 metode:

• serikat()
• persimpangan ()
• disjunction()
• nyuda ()

Ing ngisor iki sawetara conto prasaja:

Asosiasi

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]

prapatan

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]

Bedane (deduksi)

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]

Operasi ing set, terus

Conto iki nuduhake carane nggunakake papat cara ing ndhuwur kanggo nggarap rong koleksi:

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

Hasil kita:

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}

Sampeyan bisa eksprimen karo cara iki dhewe.

unmodifiableCollection() Metode

Kadhangkala kita kudu ngetrapake metode antarmuka sing kudu ngasilake koleksi data internal obyek kita. Lan amarga data kasebut internal, kita ora pengin ana sing ngganti ing endi wae.

Utawa kita wis nampa nang endi wae koleksi sing ora perlu diganti, nanging dipeksa kanggo pass menyang sawetara cara pihak katelu. Endi jaminan yen dheweke ora bakal ngganti?

Supaya bisa turu kanthi tentrem, koleksi kasebut bisa dibungkus ing bungkus khusus sing bakal mbuwang pengecualian nalika nyoba ngowahi koleksi kasebut.

Tuladha:

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]

Cara Collections.unmodifiableCollection () ngasilake pambungkus liwat koleksi liwati menyang. Yen sampeyan nelpon cara get() , size() , banjur kabeh bakal bisa. Nanging, nalika nelpon add () , set () , mbusak () cara , sampeyan bakal entuk pangecualian.

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

Nyatane, cara kasebut wis ditandhani ora digunakake lan disaranake nggunakake Collections.unmodifiableCollection(Collection<? ngluwihi T> c) tinimbang .

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