ArrayList contiene un altro ArrayList

Question

C'è probabilmente un semplice one-liner che sto semplicemente non trovando qui, ma questa è la mia domanda:

Come verificare se un ArrayList contiene tutti gli oggetti in un altro ArrayList. Sto cercando (se esiste) per qualcosa sulla falsariga di:

//INCORRECT EXAMPLE: 
if(one.contains(two)) 
{ 
    return true; 
} 
else 
{ 
    return false; 
} 

Ad esempio:

ArrayList one = {1, 2, 3, 4, 5} 

ArrayList two = {1, 2, 3} --> True 
ArrayList two = {} --> True 
ArrayList two = {1, 2, 3, 4, 5} --> True 
ArrayList two = {1, 5, 2} --> True 
ArrayList two = {1, 7, 4} --> False 
ArrayList two = {0, 1, 3} --> False 
ArrayList two = {4, 5, 6} --> False 
ArrayList two = {7, 8, 9} --> False 

Answer 1

C'è un metodo chiamato containsAll dichiarato nell'interfaccia java.util.Collection. Nella tua impostazione one.containsAll(two) dà la risposta desiderata.

Answer 2

Il codice nell'esempio non ha senso, ma qui è un esempio in ogni caso.

ArrayList<Integer> one, two; 
//initialize 
boolean good = true; 
for (int i = 0; i < two.size(); i ++) { 
    if (!(one.contains(two.get(i))) { 
     good = false; 
     break; 
    } 
} 

E loop semplicemente attraverso tutti gli elementi e controlli two s' per vedere se sono in one.

Quindi il valore booleano good contiene il valore desiderato.

Vedere ArrayList#contains.

MODIFICA: oh wow, ho completamente dimenticato containsAll. Oh bene, questo è un modo alternativo di farlo se vuoi davvero capirlo.

Answer 3

Per l'interfaccia List:

myList.containsAll(...); 

Answer 4

Date un'occhiata a containsAll(Collection<?> c) metodo dal List interfaccia. Penso che sia quello che stai cercando.

Answer 5

È possibile utilizzare il metodo containsAll dell'elenco per eseguire il controllo. Tuttavia, questa è un'operazione lineare. Se la lista è grande, si dovrebbe convertirlo in HashSet prima, e poi eseguire containsAll:

HashSet tmp = new HashSet(one); 
if (tmp.containsAll(two)) { 
    ... 
} 

Se la lunghezza del one è N e la lunghezza dei due è M, questa soluzione ha il tempo la complessità di O(M+N); la "semplice" containsAll ha la complessità di O(M*N), che potrebbe essere significativamente peggiore.

Answer 6

Ecco un altro esempio di uso containsAll() che ho usato per affermare che due array sono uguali in fase di test JUnit:

List<String> expected = new ArrayList<String>(); 
expected.add("this"); 
expected.add("that"); 
expected.add("another"); 

List<String> actual = new ArrayListString(); 
actual.add("another"); 
actual.add("that"); 
actual.add("this"); 

Assert.assertTrue("The lists do not match!", expected.containsAll(actual));