Java compare deux listes

J'ai deux listes (pas des listes java, 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 renvoie le nombre d'éléments identiques. Pour cet exemple, il devrait être 3 et il devrait me renvoyer des valeurs similaires de liste et de valeurs différentes également.

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

Veuillez aider

PS: Ce n'est pas une mission scolaire :) Donc si vous me guidez, cela suffira

ÉDITER

Voici deux versions. Une utilisation ArrayListet une autre utilisationHashSet

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

Cela devrait suffire à couvrir:

PS: Ce n'est pas une mission scolaire :) Donc si vous me guidez, cela suffira

une partie de votre question.

continuer avec la réponse originale:

Vous pouvez utiliser un java.util.Collection et / ou java.util.ArrayListpour cela.

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

Conserve uniquement les éléments de cette collection qui sont 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 );
    }
}

ÉDITER

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 également les valeurs similaires et gère les répétitions (en les supprimant).

Cette fois, le Collectionpourrait être un Setau lieu d'un List(la différence est que l'ensemble ne permet pas de 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);
      }
}

Production:

$ 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 fait pas exactement ce dont vous avez besoin, cela vous donne un bon départ afin que vous puissiez gérer à partir d'ici.

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

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

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

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

S'agit-il vraiment de listes (ordonnées, avec doublons), ou sont-elles des ensembles (non ordonnés, pas de doublons)?

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

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

Si vous recherchez un moyen pratique de tester l'égalité de deux collections, vous pouvez utiliser org.apache.commons.collections.CollectionUtils.isEqualCollection, qui compare deux collections indépendamment de l'ordre.

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

• Je n'ai pas à déclarer de liste supplémentaire / définir moi-même
• Je ne mute 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.collectionsune 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é.

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

Production :-

similiar [b, c]
different [f]

En supposant hash1ethash2

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.

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

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