Java compare deux listes

Question

J'ai deux listes ( pas des listes java, on peut 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    

Je voudrais une méthode qui renvoie combien d'éléments sont identiques. Pour cet exemple, cela devrait être 3 et elle devrait me renvoyer les valeurs similaires des deux listes ainsi que des valeurs différentes.

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

Veuillez m'aider

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

Answer 1

EDITAR

Voici deux versions. L'une utilisant ArrayList et d'autres utilisant HashSet

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

Cela devrait suffire à couvrir le :

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

partie de votre question.

en poursuivant la réponse initiale :

Vous pouvez utiliser un java.util.Collection et/ou java.util.ArrayList pour ça.

El retainAll fait ce qui suit :

Conserve uniquement les éléments de cette collection qui sont contenus dans la collection spécifiée.

voir cet échantillon :

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

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

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

Cette deuxième version vous donne également les valeurs similaires et les manipulations répétées ( en les écartant).

Cette fois, le Collection pourrait être un Set au lieu d'un List (la différence est que le Set n'autorise 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]

S'il ne répond pas exactement à vos besoins, il vous donne un bon point de départ pour que vous puissiez vous débrouiller à partir de là.

Question pour le lecteur : Comment inclure toutes les valeurs répétées ?

Answer 2

Vous pouvez essayer intersection() y subtract() méthodes de CollectionUtils .

intersection() vous donne une collection contenant des éléments communs et la méthode subtract() La méthode vous permet d'obtenir tous les éléments peu courants.

Ils doivent également prendre soin d'éléments similaires

Answer 3

Si vous recherchez un moyen pratique de tester l'égalité de deux collections, vous pouvez utiliser la méthode suivante org.apache.commons.collections.CollectionUtils.isEqualCollection qui compare deux collections sans tenir compte de leur ordre.

Answer 4

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

• Je ne dois pas déclarer moi-même de liste/ensemble supplémentaire
• Je ne modifie pas les listes d'entrée
• C'est très efficace. Il vérifie l'égalité en complexité O(N).

S'il n'est pas possible d'avoir apache.commons.collections en tant que 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é.

Answer 5

Est-ce que ce sont vraiment listes (ordonnées, avec des doublons), ou sont-elles establece (non ordonné, pas de doublons) ?

Parce que si c'est le dernier, alors vous pouvez utiliser, disons, un java.util.HashSet<E> et le faire en temps linéaire prévu en utilisant la 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]"