example - list java español

¿Comparar los valores de objetos de Java Compare Two List?

Question

Tengo dos listas * *ListA<MyData> listA = new ArrayList<MyData>() ** y ListB<MyData> listB = new ArrayList<MyData>() ambas contienen objetos de tipo MyData y MyData contienen estas variables.

MyData {
    String name;
    boolean check;
} 

ListA y ListB ambos contienen objetos MyData, ahora tengo que comparar los valores de los objetos de la lista aquí nombre así como verificar variable como si ListA contiene estos valores de objeto

ListA = ["Ram",true],["Hariom",true],["Shiv",true];

y ListB también contienen

ListB = ["Ram",true],["Hariom",true],["Shiv",true];

entonces tengo que comparar listas y devolver falso porque ambas listas son las mismas, pero si ListA contiene

ListA = ["Ram",true],["Hariom",true],["Shiv",false];

y ListB contienen

 ListB = ["Ram",true],["Hariom",true],["Shiv",true];

entonces tengo que comparar listas y devolver verdadero porque ambas lista no son las mismas

o viceversa, por lo que cualquier cambio leve en los valores de la lista debe devolverse verdadero. Una cosa que he mencionado aquí, los objetos pueden estar en cualquier orden.

Answer 1

Encontré un ejemplo muy básico de comparación de listas en la comparación de listas. Este ejemplo verifica primero el tamaño y luego verifica la disponibilidad del elemento particular de una lista en otra.

Answer 2

Han pasado unos 5 años desde entonces y afortunadamente tenemos a Kotlin ahora.
La comparación de dos listas ahora se ve tan simple como:

fun areListsEqual(list1 : List<Any>, list2 : List<Any>) : Boolean {
        return list1 == list2
}

O simplemente siéntete libre de omitirlo y usa el operador de igualdad.

Answer 3

La lógica debería ser algo así como:

1. Primer paso: para la clase MyData implementa la interfaz Comparable, anule el método compareTo según el requisito por objeto.

2. Segundo paso: cuando se trata de una comparación de listas (después de buscar nulos), 2.1 Compruebe el tamaño de ambas listas, si igual devuelve verdadero else devuelve falso, continúe con la iteración de objetos 2.2 Si el paso 2.1 devuelve verdadero, itere sobre elementos de ambas listas y invocar algo así como,

   listA.get (i) .compareTo (listB.get (i))

Esto será según el código mencionado en el paso-1.

Answer 4

Mira si esto funciona

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


public class ArrayListComparison {

    public static void main(String[] args) {
        List<MyData> list1 = new ArrayList<MyData>();
        list1.add(new MyData("Ram", true));
        list1.add(new MyData("Hariom", true));
        list1.add(new MyData("Shiv", true));
//      list1.add(new MyData("Shiv", false));
        List<MyData> list2 = new ArrayList<MyData>();
        list2.add(new MyData("Ram", true));
        list2.add(new MyData("Hariom", true));
        list2.add(new MyData("Shiv", true));

        System.out.println("Lists are equal:" + listEquals(list1, list2));
    }

    private static boolean listEquals(List<MyData> list1, List<MyData> list2) {
        if(list1.size() != list2.size())
            return true;
        for (MyData myData : list1) {
            if(!list2.contains(myData))
                return true;
        }
        return false;
    }
}

class MyData{
    String name;
    boolean check;


    public MyData(String name, boolean check) {
        super();
        this.name = name;
        this.check = check;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + (check ? 1231 : 1237);
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        MyData other = (MyData) obj;
        if (check != other.check)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
} 

Answer 5

No es la solución más eficiente, pero el código más escueto sería:

boolean equalLists = listA.size() == listB.size() && listA.containsAll(listB);

Actualizar:

@WesleyPorter tiene razón. La solución anterior no funcionará si hay objetos duplicados en la colección.
Para una solución completa necesita iterar sobre una colección para que los objetos duplicados se manejen correctamente.

private static boolean cmp( List<?> l1, List<?> l2 ) {
    // make a copy of the list so the original list is not changed, and remove() is supported
    ArrayList<?> cp = new ArrayList<>( l1 );
    for ( Object o : l2 ) {
        if ( !cp.remove( o ) ) {
            return false;
        }
    }
    return cp.isEmpty();
}

Actualización 28-oct-2014:

@RoeeGavriel tiene razón. La declaración de devolución debe ser condicional. El código anterior se actualiza.

Answer 6

Primero, implemente los MyData.equals(Object o) y MyData.hashCode() . Una vez que implemente el método equals , puede iterar sobre las listas de la siguiente manera:

if(ListA == null && ListB == null)
    return false;
if(ListA == null && ListB != null)
    return true;
if(ListA != null && ListB == null)
    return true;
int max = ListA.size() > ListB.size() ? ListA.size() : ListB.size();
for(int i = 0; i < max; i++) {
    myData1 = ListA.get(i);
    myData2 = ListB.get(i);
    if(!myData1.equals(myData2)) {
        return true;
    }
}
return false;

Answer 7

Puede restar una lista de la otra usando CollectionUtils.subtract, si el resultado es una colección vacía, significa que ambas listas son las mismas. Otro enfoque es usar CollectionUtils.isSubCollection o CollectionUtils.isProperSubCollection.

Para cualquier caso, debe implementar los métodos equals y hashCode para su objeto.

Answer 8

Reemplace el método equals en su clase y use Collection#equals() método Collection#equals() para verificar la igualdad.

Answer 9

Sé que es una pregunta antigua, pero en caso de que alguien lo necesite. Lo uso en mi aplicación y funciona bien. Lo usé para verificar si el carrito ha sido cambiado o no.

private boolean validateOrderProducts(Cart cart) {
    boolean doesProductsChanged = false;
    if (originalProductsList.size() == cart.getCartItemsList().size()) {
        for (Product originalProduct : originalProductsList) {
            if (!doesProductsChanged) {
                for (Product cartProduct : cart.getCartProducts()) {
                    if (originalProduct.getId() == cartProduct.getId()) {
                        if (originalProduct.getPivot().getProductCount() != cartProduct.getCount()) {
                            doesProductsChanged = true;
                            // cart has been changed -> break from inner loop
                            break;
                        }
                    } else {
                        doesProductsChanged = false;
                    }
                }
            } else {
                // cart is already changed -> break from first loop
                break;
            }
        }
    } else {
        // some products has been added or removed (simplest case of Change)
        return true;
    }
    return doesProductsChanged;
}

Answer 10

Tengo esta solución para el problema anterior

public boolean compareLists(List<MyData> prevList, List<MyData> modelList) {
        if (prevList.size() == modelList.size()) {
            for (MyData modelListdata : modelList) {
                for (MyData prevListdata : prevList) {
                    if (prevListdata.getName().equals(modelListdata.getName())
                            && prevListdata.isCheck() != modelListdata.isCheck()) {
                        return  true;

                    }
                }

            }
        }
        else{
            return true;
        }
        return false; 

    }

EDITADO: -
¿Cómo podemos cubrir esto? Imagínese si tuviera dos arreglos "A", verdadero "B", verdadero "C", verdadero y "A", verdadero "B", verdadero "D", verdadero. Aunque la matriz uno tiene C y la matriz dos tiene D, no hay ningún control que capte eso ( mencionado por @Patashu ) .. ASÍ es por lo que he hecho los cambios a continuación.

public boolean compareLists(List<MyData> prevList, List<MyData> modelList) {
        if (prevList!= null && modelList!=null && prevList.size() == modelList.size()) {
            boolean indicator = false;
            for (MyData modelListdata : modelList) {
                for (MyData prevListdata : prevList) {
                    if (prevListdata.getName().equals(modelListdata.getName())
                            && prevListdata.isCheck() != modelListdata.isCheck()) {
                        return  true;

                    }
                    if (modelListdata.getName().equals(prevListdata.getName())) {
                        indicator = false;
                        break;
                    } else
                        indicator = true;
                }
                }

            }
        if (indicator)
            return true;
    }
        }
        else{
            return true;
        }
        return false; 

    }

Answer 11

Usando java 8 removeIf para comparar artículos similares

public int getSimilarItems(){
    List<String> one = Arrays.asList("milan", "dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta");
    List<String> two = new ArrayList<>(Arrays.asList("hafil", "iga", "binga", "mike", "dingo")); //Cannot remove directly from array backed collection
    int initial = two.size();

    two.removeIf(one::contains);
    return initial - two.size();
}

Answer 12

ArrayList ya tiene soporte para esto, con el método equals . Citando los documentos

... En otras palabras, dos listas se definen como iguales si contienen los mismos elementos en el mismo orden.

Requiere que implementes equals correctamente en tu clase MyData .

Editar

Ha actualizado la pregunta que indica que las listas podrían tener diferentes pedidos. En ese caso, primero ordena tu lista y luego aplica iguales.