Lớp CollectionUtils từ Apache Commons

Giới thiệu về CollectionUtils

Một lớp tiện ích chung khác chứa nhiều phương thức hữu ích:

Hãy xem xét một số phương pháp.

Các cách để kiểm tra xem một bộ sưu tập có trống không

Đây là cách dễ dàng để xác định xem một bộ sưu tập có trống không:

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

Thật dễ dàng để kiểm tra xem một bộ sưu tập có trống không:

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

Ví dụ:

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

Hướng dẫn về Bộ sưu tập Apache Commons CollectionUtils

Các phép toán trên tập hợp

Nếu bạn phải làm việc với lý thuyết tập hợp, thì bạn biết rằng có 4 phép toán cơ bản trên tập hợp: hợp, giao, hiệu và tách.

Đối với các thao tác này, lớp CollectionUtils có 4 phương thức:

• liên hiệp()
• ngã tư()
• phân ly()
• trừ ()

Dưới đây là một số ví dụ đơn giản:

một hiệp hội

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]

ngã tư

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]

Phân ly

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]

Chênh lệch (khấu trừ)

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]

Các phép toán trên tập hợp, tiếp tục

Ví dụ này cho thấy cách sử dụng bốn phương pháp trên để làm việc với hai bộ sưu tập:

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

Kết quả của chúng tôi:

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}

Bạn có thể tự mình thử nghiệm các phương pháp này.

Phương thức unmodifiableCollection()

Đôi khi chúng ta cần triển khai các phương thức giao diện cần trả về các bộ sưu tập dữ liệu nội bộ của các đối tượng của chúng ta. Và vì dữ liệu là nội bộ nên chúng tôi không muốn bất kỳ ai thay đổi nó ở đâu đó.

Hoặc chúng tôi đã nhận được ở đâu đó một bộ sưu tập không cần thay đổi nhưng buộc phải chuyển nó cho một số phương thức của bên thứ ba. Đâu là sự đảm bảo rằng anh ấy sẽ không thay đổi nó?

Để ngủ yên, bộ sưu tập có thể được bọc trong một trình bao bọc đặc biệt sẽ đưa ra một ngoại lệ khi cố gắng sửa đổi bộ sưu tập.

Ví dụ:

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]

Phương thức Collections.unmodifiableCollection() trả về một trình bao bọc trên bộ sưu tập được truyền cho nó. Nếu bạn gọi các phương thức get() , size() của nó thì mọi thứ sẽ hoạt động. Tuy nhiên, khi gọi các phương thức add() , set() , remove() , bạn sẽ gặp một ngoại lệ.

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

Trên thực tế, phương pháp này đã được đánh dấu là không dùng nữa và bạn nên sử dụng Collections.unmodifiableCollection(Collection<? extends T> c) thay thế .

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