Các yếu tố chung trong hai danh sách

Tôi có hai ArrayListđối tượng với ba số nguyên mỗi đối tượng. Tôi muốn tìm cách trả về các phần tử chung của hai danh sách. Có ai biết cách tôi có thể đạt được điều này không?

Sử dụng Collection#retainAll().

listA.retainAll(listB);
// listA now contains only the elements which are also contained in listB.

Nếu bạn muốn tránh những thay đổi bị ảnh hưởng listA, thì bạn cần tạo một thay đổi mới.

List<Integer> common = new ArrayList<Integer>(listA);
common.retainAll(listB);
// common now contains only the elements which are contained in listA and listB.

Bạn có thể sử dụng các thao tác đặt giao nhau với các ArrayListđối tượng của mình .

Một cái gì đó như thế này:

List<Integer> l1 = new ArrayList<Integer>();

l1.add(1);
l1.add(2);
l1.add(3);

List<Integer> l2= new ArrayList<Integer>();
l2.add(4);
l2.add(2);
l2.add(3);

System.out.println("l1 == "+l1);
System.out.println("l2 == "+l2);

List<Integer> l3 = new ArrayList<Integer>(l2);
l3.retainAll(l1);

    System.out.println("l3 == "+l3);

Bây giờ, l3chỉ nên có các phần tử chung giữa l1và l2.

CONSOLE OUTPUT
l1 == [1, 2, 3]
l2 == [4, 2, 3]
l3 == [2, 3]

Tại sao phải phát minh lại bánh xe? Sử dụng Bộ sưu tập Commons :

CollectionUtils.intersection(java.util.Collection a, java.util.Collection b)

Sử dụng Stream.filter()phương pháp của Java 8 kết hợp với List.contains():

import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;

/* ... */

List<Integer> list1 = asList(1, 2, 3, 4, 5);
List<Integer> list2 = asList(1, 3, 5, 7, 9);

List<Integer> common = list1.stream().filter(list2::contains).collect(toList());

            List<String> lista =new ArrayList<String>();
            List<String> listb =new ArrayList<String>();

            lista.add("Isabella");
            lista.add("Angelina");
            lista.add("Pille");
            lista.add("Hazem");

            listb.add("Isabella");
            listb.add("Angelina");
            listb.add("Bianca");

            // Create an aplusb list which will contain both list (list1 and list2) in which common element will occur twice 
            List<String> listapluslistb =new ArrayList<String>(lista);    
            listapluslistb.addAll(listb);

            // Create an aunionb set which will contain both list (list1 and list2) in which common element will occur once
            Set<String> listaunionlistb =new HashSet<String>(lista);
            listaunionlistb.addAll(listb);

            for(String s:listaunionlistb)
            {
                listapluslistb.remove(s);
            }
            System.out.println(listapluslistb);

List<Integer> listA = new ArrayList<>();
    listA.add(1);
    listA.add(5);
    listA.add(3);
    listA.add(4);   

List<Integer> listB = new ArrayList<>();
    listB.add(1);
    listB.add(5);
    listB.add(6);
    listB.add(7);
System.out.println(listA.stream().filter(listB::contains).collect(Collectors.toList()));


Java 1.8 Stream API Solutions

Đầu ra [1, 5]

Bạn có thể lấy các phần tử chung giữa hai danh sách bằng cách sử dụng phương pháp "keepAll". Phương pháp này sẽ loại bỏ tất cả các phần tử không khớp khỏi danh sách mà nó áp dụng.

Ex.: list.retainAll(list1);

Trong trường hợp này khỏi danh sách, tất cả các phần tử không có trong list1 sẽ bị xóa và chỉ còn lại những phần tử phổ biến giữa list và list1.

List<Integer> list = new ArrayList<>();
list.add(10);
list.add(13);
list.add(12);
list.add(11);

List<Integer> list1 = new ArrayList<>();
list1.add(10);
list1.add(113);
list1.add(112);
list1.add(111);
//before retainAll
System.out.println(list);
System.out.println(list1);
//applying retainAll on list
list.retainAll(list1);
//After retainAll
System.out.println("list::"+list);
System.out.println("list1::"+list1);

Đầu ra:

[10, 13, 12, 11]
[10, 113, 112, 111]
list::[10]
list1::[10, 113, 112, 111]

LƯU Ý: Sau khi keepAll được áp dụng trên danh sách, danh sách chứa phần tử chung giữa list và list1.

public <T> List<T> getIntersectOfCollections(Collection<T> first, Collection<T> second) {
        return first.stream()
                .filter(second::contains)
                .collect(Collectors.toList());
    }

    // Create two collections:
    LinkedList<String> listA =  new LinkedList<String>();
    ArrayList<String> listB =  new ArrayList<String>();

    // Add some elements to listA:
    listA.add("A");
    listA.add("B");
    listA.add("C");
    listA.add("D");

    // Add some elements to listB:
    listB.add("A");
    listB.add("B");
    listB.add("C");

    // use 

    List<String> common = new ArrayList<String>(listA);
    // use common.retainAll

    common.retainAll(listB);

    System.out.println("The common collection is : " + common);

xem xét hai danh sách L1 ans L2

Sử dụng Java8, chúng ta có thể dễ dàng tìm ra

L1.stream().filter(L2::contains).collect(Collectors.toList())

Trong trường hợp bạn muốn tự làm ..

List<Integer> commons = new ArrayList<Integer>();

for (Integer igr : group1) {
    if (group2.contains(igr)) {
        commons.add(igr);
    }
}

System.out.println("Common elements are :: -");
for (Integer igr : commons) {
    System.out.println(" "+igr);
}

Một số câu trả lời ở trên tương tự nhưng không giống nhau vì vậy hãy đăng nó như một câu trả lời mới.

Giải pháp:
1. Sử dụng HashSet để giữ các phần tử cần được loại bỏ
2. Thêm tất cả các phần tử của list1 vào HashSet
3. lặp lại list2 và xóa các phần tử khỏi HashSet có trong list2 ==> có trong cả list1 và list2
4 . Bây giờ hãy lặp lại HashSet và xóa các phần tử khỏi list1 (vì chúng ta đã thêm tất cả các phần tử của list1 vào set), cuối cùng, list1 có tất cả các phần tử chung
Lưu ý: Chúng ta có thể thêm tất cả các phần tử của list2 và trong lần lặp thứ 3, chúng ta nên xóa các phần tử khỏi danh sách2.

Độ phức tạp về thời gian: O (n) Độ
phức tạp về không gian: O (n)

Mã:

import com.sun.tools.javac.util.Assert;
import org.apache.commons.collections4.CollectionUtils;

    List<Integer> list1 = new ArrayList<>();
    list1.add(1);
    list1.add(2);
    list1.add(3);
    list1.add(4);
    list1.add(5);

    List<Integer> list2 = new ArrayList<>();
    list2.add(1);
    list2.add(3);
    list2.add(5);
    list2.add(7);
    Set<Integer> toBeRemoveFromList1 = new HashSet<>(list1);
    System.out.println("list1:" + list1);
    System.out.println("list2:" + list2);
    for (Integer n : list2) {
        if (toBeRemoveFromList1.contains(n)) {
            toBeRemoveFromList1.remove(n);
        }
    }
    System.out.println("toBeRemoveFromList1:" + toBeRemoveFromList1);
    for (Integer n : toBeRemoveFromList1) {
        list1.remove(n);
    }
    System.out.println("list1:" + list1);
    System.out.println("collectionUtils:" + CollectionUtils.intersection(list1, list2));
    Assert.check(CollectionUtils.intersection(list1, list2).containsAll(list1));

đầu ra:

list1:[1, 2, 3, 4, 5]
list2:[1, 3, 5, 7]
toBeRemoveFromList1:[2, 4]
list1:[1, 3, 5]
collectionUtils:[1, 3, 5]