metodos - import arraylist java

Elementos comunes en dos listas

Question

Tengo dos listas de matrices con 3 enteros. Quiero encontrar una forma de devolver los elementos comunes de las dos listas. Tiene alguna idea, ¿cómo puedo lograr esto?

Answer 1

¿Por qué reinventar la rueda? Usar colecciones de Commons :

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

Answer 2

En caso de que quieras hacerlo tú mismo ..

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 3

Puede obtener los elementos comunes entre dos listas usando el método "retainAll". Este método eliminará todos los elementos no coincidentes de la lista a la que se aplica.

Ex.: list.retainAll(list1);

En este caso, de la lista, todos los elementos que no están en list1 se eliminarán y solo quedarán aquellos que son comunes entre list y 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);

Salida:

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

NOTA: Después de mantener todo aplicado en la lista, la lista contiene elementos comunes entre list y list1.

Answer 4

Puede usar establecer operaciones de intersección con sus objetos ArrayList .

Algo como esto:

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);
    System.out.println("l2 == "+l2);

Ahora, l3 debería tener solo elementos comunes entre l1 y l2 .

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

Answer 5

Usando el método Stream.filter() Java 8 en combinación con 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 6

            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 7

Use Collection#retainAll() .

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

Si desea evitar que los cambios se vean afectados en la listA , entonces necesita crear uno nuevo.

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

Answer 8

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