Java Compare Duas Listas

Eu tenho duas listas (não listas java, você pode dizer duas colunas)

Por exemplo

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

Eu gostaria de um método que retornasse quantos elementos são iguais. Para este exemplo, deve ser 3 e deve retornar valores semelhantes de lista e também valores diferentes.

Devo usar hashmap se sim, qual método para obter meu resultado?

Por favor ajude

PS: Não é um trabalho escolar :) Então, se você apenas me orientar, será o suficiente

EDITAR

Aqui estão duas versões. Um usando ArrayListe outro usandoHashSet

Compare-os e crie sua própria versão a partir disso, até obter o que precisa.

Isso deve ser o suficiente para cobrir:

PS: Não é um trabalho escolar :) Então, se você apenas me orientar, será o suficiente

parte da sua pergunta.

continuando com a resposta original:

Você pode usar um java.util.Collection e / ou java.util.ArrayListpara isso.

O método retémAll faz o seguinte:

Retém apenas os elementos desta coleção que estão contidos na coleção especificada

veja este exemplo:

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 a segunda parte (valores semelhantes), você pode usar o método removeAll :

Remove todos os elementos desta coleção que também estão contidos na coleção especificada.

Esta segunda versão fornece também os valores semelhantes e alças repetidas (descartando-os).

Desta vez, o Collectionpoderia ser um em Setvez de um List(a diferença é que o conjunto não permite valores repetidos)

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);
      }
}

Resultado:

$ 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]

Se não fizer exatamente o que você precisa, é um bom começo para que você possa prosseguir a partir daqui.

Pergunta para o leitor: Como você incluiria todos os valores repetidos?

Você pode tentar intersection()e subtract()métodos de CollectionUtils.

intersection()método fornece uma coleção contendo elementos comuns e o subtract()método fornece todos os elementos incomuns.

Eles também devem cuidar de elementos semelhantes

Essas listas são realmente (ordenadas, com duplicatas) ou são conjuntos (não ordenadas, sem duplicatas)?

Porque se for o último, então você pode usar, digamos, a java.util.HashSet<E>e fazer isso no tempo linear esperado usando o 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]"

Usando 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();
}

Se você está procurando uma maneira prática de testar a igualdade de duas coleções, pode usar o org.apache.commons.collections.CollectionUtils.isEqualCollection, que compara duas coleções independentemente da ordem.

De todas as abordagens, acho que usar org.apache.commons.collections.CollectionUtils#isEqualCollectioné a melhor. Aqui estão as razões -

• Eu não tenho que declarar nenhuma lista / definição adicional
• Eu não estou alterando as listas de entrada
• É muito eficiente. Ele verifica a igualdade na complexidade O (N).

Se não for possível ter apache.commons.collectionscomo dependência, recomendo implementar o algoritmo que segue para verificar a igualdade da lista devido à sua eficiência.

Solução simples: -

    List<String> list = new ArrayList<String>(Arrays.asList("a", "b", "d", "c"));
    List<String> list2 = new ArrayList<String>(Arrays.asList("b", "f", "c"));

    list.retainAll(list2);
    list2.removeAll(list);
    System.out.println("similiar " + list);
    System.out.println("different " + list2);

Resultado :-

similiar [b, c]
different [f]

Assumindo hash1ehash2

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.

Encontrei um exemplo muito básico de comparação de lista em Comparação de lista. Este exemplo verifica o tamanho primeiro e, em seguida, verifica a disponibilidade de um elemento específico de uma lista em outra.

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));
  }