两个列表中的共同元素

Question

我有两个

ArrayList

对象，每个对象都有三个整数。我想找到一种方法来返回两个列表的共同元素。有人知道我该如何实现这一目标吗？

Answer 1

使用

Collection#retainAll()

。

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

如果您想避免

listA

中的更改受到影响，那么您需要创建一个新的。

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

如果您是流媒体的粉丝，最好的办法就是在另一个列表的

Stream#filter()

上

Collection#contains()

。

List<Integer> common = listA.stream().filter(listB::contains).toList();
// common now contains only the elements which are contained in listA and listB.

仅慢至少两倍。

Answer 2

您可以对

ArrayList

对象使用集合交集运算。

类似这样的：

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

现在，

l3

应该只具有

l1

和

l2

之间的共同元素。

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

Answer 3

为什么要重新发明轮子？使用Commons Collections：

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

Answer 4

结合使用Java 8的

Stream.filter()

方法和

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

Answer 5

考虑两个列表 L1 和 L2

使用Java8我们可以轻松找到它

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

Answer 6

您可以使用以下方法获取两个列表之间的公共元素 “保留全部”。该方法将从列表中删除所有不匹配的元素它适用。

Ex.: list.retainAll(list1);

在这种情况下，从列表中，所有不在列表1中的元素都将被删除，仅保留 list 和 list 之间常见的那些列表1.

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

输出：

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

注意：在列表上应用retainAll后，列表包含之间的公共元素列表和列表1。

Answer 7

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

Answer 8

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

Answer 9

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

Answer 10

如果你想自己做..

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

Answer 11

上面的一些答案相似但不相同，因此将其发布为新答案。

解决方案：
1.使用HashSet来保存需要移除的元素
2.将list1的所有元素添加到HashSet中
3. 迭代list2并从HashSet中删除list2 ==>中存在的元素，这些元素同时存在于list1和list2中
4.现在迭代HashSet并从list1中删除元素（因为我们已经将list1的所有元素添加到集合中），最后，list1具有所有公共元素
注意：我们可以添加 list2 的所有元素，并且在第三次迭代中，我们应该从 list2 中删除元素。

时间复杂度：O(n)
空间复杂度：O(n)

代码：

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

输出：

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

Answer 12

public static <T> List<T> getCommonElements(
            java.util.Collection<T> a,
            java.util.Collection<T> b
            ) {
        if(a==null && b==null) return new ArrayList<>();
        if(a!=null && a.size()==0) return new ArrayList<>(b);           
        if(b!=null && b.size()==0) return new ArrayList<>(a);
        
        Set<T> set= a instanceof HashSet?(HashSet<T>)a:new HashSet<>(a);
        return b.stream().filter(set::contains).collect(Collectors.toList());
    }

为了更好的时间性能，请使用 HashSet（O(1) 次查找）而不是 List(O(n) 次查找）

时间复杂度 - O(b) 空间复杂度 - O(a)

Answer 13

以下代码删除列表中的公共元素

List<String> result =  list1.stream().filter(item-> !list2.contains(item)).collect(Collectors.toList());

检索共同元素

List<String> result = list1.stream()
                .distinct()
                .filter(list::contains)
                .collect(Collectors.toList());

Answer 14

问题涉及三个项目，许多建议建议使用retainAll。我认为必须指出的是，随着列表大小的增长，retainAll 似乎变得更加低效。

在我的测试中，我发现转换为 Sets 并循环比对包含 1000 个项目的列表使用 keepAll 快大约 60 倍

  List<Integer> common(List<Integer> biggerList, List<Integer> smallerList) {
    Set<Integer> set1 = new HashSet<>(biggerList);
    List<Integer> result = new ArrayList<>(smallerList.size());
    for (Integer i : smallerList) {
      if (set1.contains(i)) {
        result.add(i);
      }
    }
    return result;
  }

Answer 15

使用下面的Java 8解决方案

list1.stream()
    .filter(list2::contains)
    .collect(Collectors
    .toList()));

Answer 16

有几种方法可以实现这一目标：

使用“流”

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CommonNumbersStreams {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> list2 = Arrays.asList(3, 4, 5, 6, 7);

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

        System.out.println("Common numbers: " + commonNumbers);
    }
}

使用“For 循环”

public class CommonNumbers {
public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
    List<Integer> list2 = Arrays.asList(3, 4, 5, 6, 7);

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

    // Iterate through list1 and check if each element is present in list2
    for (Integer num : list1) {
        if (list2.contains(num)) {
            commonNumbers.add(num);
        }
    }

    System.out.println("Common numbers: " + commonNumbers);
}

}

两个列表中的共同元素

问题描述投票：0回答：16

16个回答

最新问题

两个列表中的共同元素

问题描述 投票：0回答：16

16个回答

最新问题

问题描述投票：0回答：16