C'è un modo per trovare elementi comuni in più elenchi?

Question

Ho una lista di array interi. Ho bisogno di trovare gli elementi comuni tra quelli. Quello che mi viene in mente è un'estensione di ciò che è elencato in Common elements in two lists

Example would be 
[1,3,5], 
[1,6,7,9,3], 
[1,3,10,11] 

should result in [1,3] 

ci sono duplicati nelle matrici così.

C'è un modo semplice per farlo?

Answer 1

È possibile trasformare le liste ai set, e quindi utilizzare metodo per intersezione tra i diversi set. Una volta intersecati tutti i set, vi rimangono gli elementi comuni e potete trasformare il set risultante in un elenco.

Answer 2

Se siete alla ricerca di una funzione che restituisce gli elementi che esistono in tutte le liste,

allora il modo semplice & semplice sta costruendo una statistica {< membro, avvenimenti>}

La condizione qui è duplicati tra la stessa lista,

private Set<Integer> getCommonElements(ArrayList<Integer[]> idList) 
{ 

    MapList<Integer,Short> stat = new MapList<Integer,Short>(); 

    // Here we count how many times each value occur 
    for (int i = 0; i < idList.size(); i++) 
    { 
     for (int j = 0; j < idList.get(i).size; j++) 
     { 
      if (stat.containsKey(idList.get(i)[j])) 
      { 
       stat.set(idList.get(i)[j], stat.get(idList.get(i)[j])+1); 
      } 
      else 
      { 
       stat.add(idList.get(i)[j], 1); 
      } 
     } 
    } 

    // Here we only keep value that occured in all lists 
    for (int i = 0; i < stat.size(); i++) 
    { 
     if (stat.get(i) < idList.size()) 
     { 
      stat.remove(i); 
      i--; 
     } 
    } 

    return stat.keySet(); 
} 

Answer 3

È possibile utilizzare il metodo di intersezione del set offerto da Guava, Ecco un piccolo esempio:

public <T> Set<T> intersection(List<T>... list) { 
    Set<T> result = Sets.newHashSet(list[0]); 
    for (List<T> numbers : list) { 
     result = Sets.intersection(result, Sets.newHashSet(numbers)); 
    } 
    return result; 
} 

speranza che potrebbe aiutare a

Answer 4

public class ArrayListImpl{ 
    public static void main(String s[]){ 
    ArrayList<Integer> al1=new ArrayList<Integer>(); 
    al1.add(21);al1.add(23);al1.add(25);al1.add(26); 
    ArrayList<Integer> al2=new ArrayList<Integer>(); 
    al2.add(15);al2.add(16);al2.add(23);al2.add(25); 
    ArrayList Al3=new ArrayList<Integer>(); 
    al3.addAll(al1); 
     System.out.println("Al3 Elements :"+al3); 
    al3.retainAll(al2); //Keeps common elements of (al1 & al2) & removes remaining elements 
     System.out.println("Common Elements Between Two Array List:"+al3); 
} 
} 

Answer 5

Possiamo usare retainAll method of Collections. Ho inizializzato il mio arrayylist commons con il primo elenco di array e lo ho chiamato per ogni arraylist rimanente.

List<List<Integer>> lists = new ArrayList<List<Integer>>(); 
    lists.add(new ArrayList<Integer>(Arrays.asList(1, 3, 5))); 
    lists.add(new ArrayList<Integer>(Arrays.asList(1, 6, 7, 9, 3))); 
    lists.add(new ArrayList<Integer>(Arrays.asList(1, 3, 10, 11))); 

    List<Integer> commons = new ArrayList<Integer>(); 
    commons.addAll(lists.get(1)); 
    for (ListIterator<List<Integer>> iter = lists.listIterator(1); iter.hasNext();) { 
     commons.retainAll(iter.next()); 
    } 

    System.out.println(commons); 
    System.out.println(lists.get(1));