Java Compare duas listas

Eu tenho duas listas (não listas de 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 retorna quantos elementos são iguais. Para este exemplo, ele deve ser 3 e deve retornar valores semelhantes de lista e valores diferentes.

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

Por favor ajude

PS: Não é uma tarefa da escola 🙂 Então, se você acabou de me orientar, será suficiente

EDITAR

Aqui estão duas versões. Um usando ArrayList e outro usando HashSet

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

Isso deve ser suficiente para cobrir:

PS: Não é uma tarefa da escola 🙂 Então, se você acabou de me orientar, será suficiente

parte da sua pergunta.

continuando com a resposta original:

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

O método retainAll faz o seguinte:

Mantém apenas os elementos dessa coleçã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 também fornece os valores e manipulações similares repetidos (descartando-os).

Desta vez, a Collection pode ser um Set vez de uma 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 listOne = Arrays.asList("milan","iga", "dingo","iga", "elpha","iga", "hafil","iga", "meat","iga", "neeta.peeta","iga"); Collection listTwo = Arrays.asList("hafil", "iga", "binga", "mike", "dingo","dingo","dingo"); Collection similar = new HashSet( listOne ); Collection different = new HashSet(); 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); } } 

Saída:

 $ 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, você terá um bom começo para poder lidar com isso daqui.

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

Você pode tentar os methods intersection() e subtract() de CollectionUtils .

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

Eles também devem cuidar de elementos semelhantes

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

Porque se for o último, então você pode usar, digamos, um java.util.HashSet e fazer isso no tempo linear esperado, usando o conveniente retainAll .

  List list1 = Arrays.asList( "milan", "milan", "iga", "dingo", "milan" ); List list2 = Arrays.asList( "hafil", "milan", "dingo", "meat" ); // intersection as set Set intersect = new HashSet(list1); intersect.retainAll(list2); System.out.println(intersect.size()); // prints "2" System.out.println(intersect); // prints "[milan, dingo]" // intersection/union as list List intersectList = new ArrayList(); 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 o java 8 removeIf

 public int getSimilarItems(){ List one = Arrays.asList("milan", "dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta"); List 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(); } 

Assumindo hash1 e 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. 

Eu encontrei um exemplo muito básico de comparação de lista no List Compare Este exemplo verifica o tamanho primeiro e, em seguida, verifica a disponibilidade do elemento específico de uma lista em outro.

Se você estiver procurando uma maneira prática de testar a igualdade de duas collections, poderá usar org.apache.commons.collections.CollectionUtils.isEqualCollection , que compara duas collections, independentemente da ordem.

Solução simples: –

  List list = new ArrayList(Arrays.asList("a", "b", "d", "c")); List list2 = new ArrayList(Arrays.asList("b", "f", "c")); list.retainAll(list2); list2.removeAll(list); System.out.println("similiar " + list); System.out.println("different " + list2); 

Saída: –

 similiar [b, c] different [f] 
 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 one = new ArrayList(); one.add("one"); one.add("two"); one.add("six"); ArrayList two = new ArrayList(); 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)); }