tutorial - que son las listas java

regresando la diferencia entre dos listas en java

Question

Tengo dos listas de matrices, por ejemplo

List<Date> a;
contains : 10/10/2014, 10/11/2016

List<Date> b;
contains : 10/10/2016

¿Cómo puedo hacer una verificación entre la lista a y b para que se devuelva el valor que falta en b ? Por ejemplo, 10/10/2014

Answer 1

Estaba buscando un problema diferente y encontré esto, así que agregaré mi solución a un problema relacionado: comparar dos mapas.

    // make a copy of the data
    Map<String,String> a = new HashMap<String,String>(actual);
    Map<String,String> e = new HashMap<String,String>(expected);
    // check *every* expected value
    for(Map.Entry<String, String> val : e.entrySet()){
        // check for presence
        if(!a.containsKey(val.getKey())){
            System.out.println(String.format("Did not find expected value: %s", val.getKey()));
        }
        // check for equality
        else{
            if(0 != a.get(val.getKey()).compareTo(val.getValue())){
                System.out.println(String.format("Value does not match expected: %s", val.getValue()));
            }
            // we have found the item, so remove it 
            // from future consideration. While it 
            // doesn''t affect Java Maps, other types of sets
            // may contain duplicates, this will flag those
            // duplicates. 
            a.remove(val.getKey());
        }
    }
    // check to see that we did not receive extra values
    for(Map.Entry<String,String> val : a.entrySet()){
        System.out.println(String.format("Found unexpected value: %s", val.getKey()));
    }

Funciona según el mismo principio que las otras soluciones, pero también compara no solo que los valores están presentes, sino que contienen el mismo valor. Principalmente, lo he usado en software de contabilidad al comparar datos de dos fuentes (los valores ingresados ​​por el empleado y el administrador coinciden; las transacciones corporativas y del cliente coinciden, etc.)

Answer 2

Puede convertirlos a Set conjuntos y realizar una operación de set difference en ellos.

Me gusta esto:

Set<Date> ad = new HashSet<Date>(a);
Set<Date> bd = new HashSet<Date>(b);
ad.removeAll(bd);

Answer 3

Puede llamar al método U.difference (lists) en la biblioteca de underscore-java . Soy el mantenedor del proyecto. Ejemplo vivo

import com.github.underscore.U;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1, 2, 3);
        List<Integer> list2 = Arrays.asList(1, 2);
        List<Integer> list3 = U.difference(list1, list2);
        System.out.println(list3);
        // [3]
    }
}

Answer 4

Puedes usar CollectionUtils de Apache Commons Collections 4.0 :

new ArrayList<>(CollectionUtils.subtract(a, b))

Answer 5

Puedes usar el filtro por la biblioteca de Java 8 Stream

List<String> aList = Arrays.asList("l","e","t","''","s");
List<String> bList = Arrays.asList("g","o","e","s","t");

List<String> result = aList.stream().filter(aObject -> {
     return bList.contains(aObject);
 }).collect(Collectors.toList());

//or more reduced without curly braces and return
List<String> result2 = aList.stream().filter(aObject -> 
bList.contains(aObject)).collect(Collectors.toList());

System.out.println(result);

Resultado:

[e, t, s]

Answer 6

Si solo quieres encontrar valores faltantes en b, puedes hacer:

List toReturn = new ArrayList(a);
toReturn.removeAll(b);

return toReturn;

Si desea averiguar los valores que están presentes en cualquiera de las listas, puede ejecutar el código superior dos veces. Con listas modificadas.