Java comparar dos listas

Question

tengo dos listas (no listas de Java, se puede decir dos columnas)

Por ejemplo

**List 1**   **Lists 2** 
    milan     hafil 
    dingo     iga 
    iga     dingo 
    elpha     binga 
    hafil     mike 
    meat     dingo 
    milan 
    elpha 
    meat 
    iga     
    neeta.peeta  

me gustaría un método que devuelve el número de elementos son los mismos. Para este ejemplo, debe ser 3 y también me debe devolver valores similares de la lista y valores diferentes.

Debo usar hashmap en caso afirmativo, entonces, ¿qué método debo utilizar para obtener mi resultado?

Por favor, ayuda

PS: No es una tarea escolar :) Así que si sólo me guía será suficiente

Answer 1

EDITAR

Aquí hay dos versiones. Una y otra utilizando ArrayList usando HashSet

compararlas y crear su propia versión de esto, hasta que se obtiene lo que necesita.

Esto debería ser suficiente para cubrir el:

PS: No es una tarea escolar :) Así que si sólo me guía será suficiente

parte de su pregunta .

continuar con la respuesta original:

Se puede usar un java.util.Collection y/o java.util.ArrayList para eso.

El método retainAll hace lo siguiente:

conserva solamente los elementos de esta colección que están contenidos en la colección especificada

ver este ejemplo:

import java.util.Collection; 
import java.util.ArrayList; 
import java.util.Arrays; 

public class Repeated { 
    public static void main(String [] args) { 
     Collection listOne = new ArrayList(Arrays.asList("milan","dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta")); 
     Collection listTwo = new ArrayList(Arrays.asList("hafil", "iga", "binga", "mike", "dingo")); 

     listOne.retainAll(listTwo); 
     System.out.println(listOne); 
    } 
} 

EDITAR

para la segunda parte (valores similares) puede usar la removeAll método:

Elimina todos los elementos de esta colección que también están contenidos en la colección especificada.

Esta segunda versión también le da los valores y asas similares repetidos (descartándolos).

Esta vez el Collection podría ser una Set en lugar de un List (valores de la diferencia es, el conjunto no permite repetir)

import java.util.Collection; 
import java.util.HashSet; 
import java.util.Arrays; 

class Repeated { 
     public static void main(String [] args) { 

      Collection<String> listOne = Arrays.asList("milan","iga", 
                "dingo","iga", 
                "elpha","iga", 
                "hafil","iga", 
                "meat","iga", 
                "neeta.peeta","iga"); 

      Collection<String> listTwo = Arrays.asList("hafil", 
                "iga", 
                "binga", 
                "mike", 
                "dingo","dingo","dingo"); 

      Collection<String> similar = new HashSet<String>(listOne); 
      Collection<String> different = new HashSet<String>(); 
      different.addAll(listOne); 
      different.addAll(listTwo); 

      similar.retainAll(listTwo); 
      different.removeAll(similar); 

      System.out.printf("One:%s%nTwo:%s%nSimilar:%s%nDifferent:%s%n", listOne, listTwo, similar, different); 
     } 
} 

Salida:

$ java Repeated 
One:[milan, iga, dingo, iga, elpha, iga, hafil, iga, meat, iga, neeta.peeta, iga] 

Two:[hafil, iga, binga, mike, dingo, dingo, dingo] 

Similar:[dingo, iga, hafil] 

Different:[mike, binga, milan, meat, elpha, neeta.peeta] 

Si no es así' Haga exactamente lo que necesita, le da un buen comienzo para que pueda manejar desde aquí.

Pregunta para el lector: ¿Cómo incluiría todos los valores repetidos?

Answer 2

Suponiendo hash1 y hash2

List<String> sames = whatever 
List<String> diffs = whatever 

int count = 0; 
for(String key : hash1.keySet()) 
{ 
    if(hash2.containsKey(key)) 
    { 
     sames.add(key); 
    } 
    else 
    { 
     diffs.add(key); 
    } 
} 

//sames.size() contains the number of similar elements. 

Answer 3

Son estos realmente lists (ordenado, con duplicados), ¿o son sets (sin pedido, sin duplicados)?

Porque si es el último, entonces puede usar, por ejemplo, un java.util.HashSet<E> y hacer esto en el tiempo lineal esperado usando el conveniente retainAll.

List<String> list1 = Arrays.asList(
     "milan", "milan", "iga", "dingo", "milan" 
    ); 
    List<String> list2 = Arrays.asList(
     "hafil", "milan", "dingo", "meat" 
    ); 

    // intersection as set 
    Set<String> intersect = new HashSet<String>(list1); 
    intersect.retainAll(list2); 
    System.out.println(intersect.size()); // prints "2" 
    System.out.println(intersect); // prints "[milan, dingo]" 

    // intersection/union as list 
    List<String> intersectList = new ArrayList<String>(); 
    intersectList.addAll(list1); 
    intersectList.addAll(list2); 
    intersectList.retainAll(intersect); 
    System.out.println(intersectList); 
    // prints "[milan, milan, dingo, milan, milan, dingo]" 

    // original lists are structurally unmodified 
    System.out.println(list1); // prints "[milan, milan, iga, dingo, milan]" 
    System.out.println(list2); // prints "[hafil, milan, dingo, meat]" 

Answer 4

Puede probar intersection() y subtract() métodos de CollectionUtils.

método intersection() le da una colección que contiene elementos comunes y el método subtract() le ofrece todos los poco comunes.

También deben cuidar de elementos similares

Answer 5

me encontré con un ejemplo muy básico de la comparación de lista en List Compare En este ejemplo se verifica el tamaño primero y luego comprueba la disponibilidad del elemento particular de una lista en otra.

Answer 6

Utilización de Java 8 removeIf

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 7

public static boolean compareList(List ls1, List ls2){ 
    return ls1.containsAll(ls2) && ls1.size() == ls2.size() ? true :false; 
    } 

public static void main(String[] args) { 

    ArrayList<String> one = new ArrayList<String>(); 
    one.add("one"); 
    one.add("two"); 
    one.add("six"); 

    ArrayList<String> two = new ArrayList<String>(); 
    two.add("one"); 
    two.add("six"); 
    two.add("two"); 

    System.out.println("Output1 :: " + compareList(one, two)); 

    two.add("ten"); 

    System.out.println("Output2 :: " + compareList(one, two)); 
    }