web-dev-qa-db-fra.com

Java Comparer deux listes

J'ai deux listes (pas Java listes, vous pouvez dire deux colonnes)

Par exemple

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

J'aimerais une méthode qui retourne combien d'éléments sont identiques. Pour cet exemple, il devrait être 3 et il devrait me retourner des valeurs similaires de la liste et des valeurs différentes aussi.

Devrais-je utiliser hashmap si oui, quelle méthode pour obtenir mon résultat?

S'il vous plaît aider

P.S: Ce n'est pas un devoir d'école :) Donc si vous me guidez, ce sera suffisant

javalistcomparisonhashmap
84
user238384

EDIT

Voici deux versions. Une utilisant ArrayList et une autre utilisant HashSet

Comparez-les et créez votre propre version jusqu'à ce que vous obteniez ce dont vous avez besoin.

Cela devrait suffire à couvrir:

P.S: Ce n'est pas une tâche scolaire :) Donc si vous me guidez, ce sera suffisant

une partie de votre question.

continue avec la réponse originale:

Vous pouvez utiliser un Java.util.Collection et/ou Java.util.ArrayList pour cela.

La méthode retentionAll effectue les opérations suivantes:

Ne conserve que les éléments de cette collection contenus dans la collection spécifiée

voir cet exemple:

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

EDIT

Pour la deuxième partie (valeurs similaires), vous pouvez utiliser la méthode removeAll :

Supprime tous les éléments de cette collection qui sont également contenus dans la collection spécifiée.

Cette deuxième version vous donne aussi les mêmes valeurs et les mêmes poignées répétés (en les écartant).

Cette fois, le Collection pourrait être un Set au lieu d'un List (la différence est que le jeu ne permet pas les valeurs répétées)

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

Sortie:

$ 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 cela ne fait pas exactement ce dont vous avez besoin, cela vous donnera un bon départ pour que vous puissiez vous en sortir.

Question pour le lecteur: Comment incluez-vous toutes les valeurs répétées?

153
OscarRyz

Vous pouvez essayer intersection() et subtract() à partir de méthodes CollectionUtils .

La méthode intersection() vous donne une collection contenant des éléments communs et la méthode subtract() vous en donne toutes les éléments peu communs.

Ils devraient également prendre en charge des éléments similaires

34
Mihir Mathuria

Sont-ils vraiment listes (ordonnés, avec des doublons), ou sont-ils ensembles (non ordonnés, pas de doublons)?

Parce que si c'est le dernier cas, vous pouvez utiliser, disons, un Java.util.HashSet<E> et le faire dans le temps linéaire attendu à l'aide de la fonction pratique 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]"
_
9
polygenelubricants

Utilisation 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();
}
5
Asanka Siriwardena

Si vous cherchez un moyen pratique de tester l'égalité de deux collections, vous pouvez utiliser org.Apache.commons.collections.CollectionUtils.isEqualCollection, qui compare deux collections quel que soit leur ordre.

2
snowfox

Solution simple: -

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

Sortie: -

similiar [b, c]
different [f]
2
Vijay Gupta

J'ai trouvé un exemple très basique de comparaison de liste à Comparaison de liste Cet exemple vérifie d'abord la taille, puis vérifie la disponibilité de l'élément particulier d'une liste dans une autre.

1
Manoj Kumar

En supposant que hash1 et 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.
1
Stefan Kendall

De toutes les approches, je trouve que org.Apache.commons.collections.CollectionUtils#isEqualCollection est la meilleure approche. Voici les raisons -

  • Je n'ai pas à déclarer de liste supplémentaire
  • Je ne mute pas les listes d'entrées
  • C'est très efficace. Il vérifie l'égalité dans la complexité O(N).

S'il n'est pas possible d'avoir Apache.commons.collections comme dépendance, je recommanderais d'implémenter l'algorithme qu'il suit pour vérifier l'égalité de la liste en raison de son efficacité.

0
shakhawat