¿Cómo puedo calcular la diferencia entre dos ArrayLists?

Question

Tengo dos ArrayLists.

ArrayList A contiene

['2009-05-18','2009-05-19','2009-05-21']

ArrayList B contiene ['2009-05-18','2009-05-18','2009-05-19','2009-05-19','2009-05-20','2009-05-21','2009-05-21','2009-05-22']

Tengo que comparar ArrayLst A y B ArrayLst. El resultado ArrayList  debe contener la lista de los que no existe en ArrayList A. resultado debe ser ArrayList

  

[ '2009-05-20', '2009-05-22']

cómo comparar?

Answer 1

En Java, se puede utilizar el Collection removeAll método .

// Create a couple ArrayList objects and populate them
// with some delicious fruits.
Collection firstList = new ArrayList() {{
    add("apple");
    add("orange");
}};

Collection secondList = new ArrayList() {{
    add("apple");
    add("orange");
    add("banana");
    add("strawberry");
}};

// Show the "before" lists
System.out.println("First List: " + firstList);
System.out.println("Second List: " + secondList);

// Remove all elements in firstList from secondList
secondList.removeAll(firstList);

// Show the "after" list
System.out.println("Result: " + secondList);

El código anterior producirá el siguiente resultado:

First List: [apple, orange]
Second List: [apple, orange, banana, strawberry]
Result: [banana, strawberry]

Answer 2

Ya tiene la respuesta correcta. Y si quieres hacer las operaciones más complicadas e interesantes entre las listas (colecciones) utiliza Apache Commons colecciones (< a href = "http://commons.apache.org/proper/commons-collections/javadocs/api-release/org/apache/commons/collections4/CollectionUtils.html" rel = "noreferrer"> CollectionUtils ) Se le permite hacer conjunción / disyunción, encontrar la intersección, y comprueba si uno colección es un subconjunto de otro y otras cosas agradables.

Answer 3

En Java 8 con corrientes, es bastante simple en realidad. EDIT:. Puede ser eficiente y sin corrientes, ver más baja

List<String> listA = Arrays.asList("2009-05-18","2009-05-19","2009-05-21");
List<String> listB = Arrays.asList("2009-05-18","2009-05-18","2009-05-19","2009-05-19",
                                   "2009-05-20","2009-05-21","2009-05-21","2009-05-22");

List<String> result = listB.stream()
                           .filter(not(new HashSet<>(listA)::contains))
                           .collect(Collectors.toList());

Tenga en cuenta que el conjunto de hash sólo se crea una vez: El Método de referencia está vinculada a su método contains. Hacer lo mismo con lambda requeriría tener el conjunto en una variable. Realización de una variable no es una mala idea, sobre todo si le resulta desagradable o difícil de entender.

No se puede negar el predicado sin algo como esto método de utilidad (o conversión explícita), como no se puede llamar al método de referencia negate directamente (es necesaria la inferencia de tipos primero).

private static <T> Predicate<T> not(Predicate<T> predicate) {
    return predicate.negate();
}

Si corrientes tenían un método filterOut o algo así, se vería más bonito.

---

Además, @Holger me dio una idea. ArrayList tiene su método removeAll optimizado para múltiples extracciones, sólo se reorganiza sus elementos una vez. Sin embargo, se utiliza el método proporcionado por contains colección dada, por lo que necesitamos para optimizar esa parte si listA es todo menos pequeña.

Con listA y listB declarados anteriormente, esta solución no necesita Java 8 y es muy eficiente.

List<String> result = new ArrayList(listB);
result.removeAll(new HashSet<>(listA));

Answer 4

EDIT: Pregunta original no especificar el idioma. Mi respuesta es en C #.

En su lugar debe utilizar HashSet para este propósito. Si tiene que usar ArrayList, puede utilizar los siguientes métodos de extensión:

var a = arrayListA.Cast<DateTime>();
var b = arrayListB.Cast<DateTime>();    
var c = b.Except(a);

var arrayListC = new ArrayList(c.ToArray());

usando HashSet ...

var a = new HashSet<DateTime>(); // ...and fill it
var b = new HashSet<DateTime>(); // ...and fill it
b.ExceptWith(a); // removes from b items that are in a

Answer 5

he utilizado Guava Sets.difference .

Los parámetros son conjuntos y colecciones no generales, sino una forma práctica de crear conjuntos de cualquier colección (con artículos únicos) es guayaba ImmutableSet.copyOf (Iterable).

(La primera vez que envió este sobre una cuestión relacionada / víctima , pero estoy copiando aquí también, ya que me siento es una buena opción que está hasta ahora ausente.)

Answer 6

A pesar de que esta es una pregunta muy antigua en Java 8 se podría hacer algo como

 List<String> a1 = Arrays.asList("2009-05-18", "2009-05-19", "2009-05-21");
 List<String> a2 = Arrays.asList("2009-05-18", "2009-05-18", "2009-05-19", "2009-05-19", "2009-05-20", "2009-05-21","2009-05-21", "2009-05-22");

 List<String> result = a2.stream().filter(elem -> !a1.contains(elem)).collect(Collectors.toList());

Answer 7

Creo que se está hablando de C #. Si es así, puede probar este

    ArrayList CompareArrayList(ArrayList a, ArrayList b)
    {
        ArrayList output = new ArrayList();
        for (int i = 0; i < a.Count; i++)
        {
            string str = (string)a[i];
            if (!b.Contains(str))
            {
                if(!output.Contains(str)) // check for dupes
                    output.Add(str);
            }
        }
        return output;
    }

Answer 8

Usted se acaba de comparar cadenas.

Ponga los valores en ArrayList A como claves en HashTable A.
Poner los valores en ArrayList B como claves en HashTable B.

A continuación, para cada tecla en HashTable A, eliminarlo de HashTable B si existe.

¿Qué le quedan en HashTable B son las cuerdas (claves) que no eran valores en ArrayList A.

C # (3,0) Ejemplo añadido en respuesta a la solicitud de código:

List<string> listA = new List<string>{"2009-05-18","2009-05-19","2009-05-21'"};
List<string> listB = new List<string>{"2009-05-18","2009-05-18","2009-05-19","2009-05-19","2009-05-20","2009-05-21","2009-05-21","2009-05-22"};

HashSet<string> hashA = new HashSet<string>();
HashSet<string> hashB = new HashSet<string>();

foreach (string dateStrA in listA) hashA.Add(dateStrA);
foreach (string dateStrB in listB) hashB.Add(dateStrB);

foreach (string dateStrA in hashA)
{
    if (hashB.Contains(dateStrA)) hashB.Remove(dateStrA);
}

List<string> result = hashB.ToList<string>();

Answer 9

Hola utilizar esta clase esta comparará las dos listas y muestra exactamente el desajuste b / w ambas listas.

import java.util.ArrayList;
import java.util.List;


public class ListCompare {

    /**
     * @param args
     */
    public static void main(String[] args) {
        List<String> dbVinList;
        dbVinList = new ArrayList<String>();
        List<String> ediVinList;
        ediVinList = new ArrayList<String>();           

        dbVinList.add("A");
        dbVinList.add("B");
        dbVinList.add("C");
        dbVinList.add("D");

        ediVinList.add("A");
        ediVinList.add("C");
        ediVinList.add("E");
        ediVinList.add("F");
        /*ediVinList.add("G");
        ediVinList.add("H");
        ediVinList.add("I");
        ediVinList.add("J");*/  

        List<String> dbVinListClone = dbVinList;
        List<String> ediVinListClone = ediVinList;

        boolean flag;
        String mismatchVins = null;
        if(dbVinListClone.containsAll(ediVinListClone)){
            flag = dbVinListClone.removeAll(ediVinListClone);   
            if(flag){
                mismatchVins = getMismatchVins(dbVinListClone);
            }
        }else{
            flag = ediVinListClone.removeAll(dbVinListClone);
            if(flag){
                mismatchVins = getMismatchVins(ediVinListClone);
            }
        }
        if(mismatchVins != null){
            System.out.println("mismatch vins : "+mismatchVins);
        }       

    }

    private static String getMismatchVins(List<String> mismatchList){
        StringBuilder mismatchVins = new StringBuilder();
        int i = 0;
        for(String mismatch : mismatchList){
            i++;
            if(i < mismatchList.size() && i!=5){
                mismatchVins.append(mismatch).append(",");  
            }else{
                mismatchVins.append(mismatch);
            }
            if(i==5){               
                break;
            }
        }
        String mismatch1;
        if(mismatchVins.length() > 100){
            mismatch1 = mismatchVins.substring(0, 99);
        }else{
            mismatch1 = mismatchVins.toString();
        }       
        return mismatch1;
    }

}

Answer 10

Este trabajo también CON Arraylist

    // Create a couple ArrayList objects and populate them
    // with some delicious fruits.
    ArrayList<String> firstList = new ArrayList<String>() {/**
         * 
         */
        private static final long serialVersionUID = 1L;

    {
        add("apple");
        add("orange");
        add("pea");
    }};

    ArrayList<String> secondList = new ArrayList<String>() {

    /**
         * 
         */
        private static final long serialVersionUID = 1L;

    {
        add("apple");
        add("orange");
        add("banana");
        add("strawberry");
    }};

    // Show the "before" lists
    System.out.println("First List: " + firstList);
    System.out.println("Second List: " + secondList);

    // Remove all elements in firstList from secondList
    secondList.removeAll(firstList);

    // Show the "after" list
    System.out.println("Result: " + secondList);