Y a-t-il un moyen optimal de trouver des valeurs distinctes dans 2 arraylist

• Convertir des arraylistes en hashsets
  • Cela vous donne O (1) pour set.Contains ()
  • Utilisez la carte.equales () pour vérifier si 2 cartes ont la même paire de la valeur de clé ou non (c'est-à-dire vérifier si le contenu est identique)

    Vous pouvez maintenant itérer plus d'un ensemble et vérifier si cet élément est présent dans l'autre ensemble. Cela vous donnera du temps linéaire au lieu de quadratique

Meilleures performances pour la recherche d'élément dans une collection utilise hashset.

Vérifiez ici: https://www.baeldung.com/java-hashst-arrayList-Contains- performance

Étapes pour résoudre ce problème:

1. Fusionner des cartes de ArrayList A1 à la carte Lold, Fusionner des cartes de ArrayList A2 à la carte Lnew Li>
2. Fetch Keytsets de la carte Lold et Lnew Carte Li>
3. Ajoutez des clés courantes des deux touches de frappe en arraylist temporaire Li>
4. Supprimez cette arrayliste temporaire des deux touches. LI>
5. Si vous souhaitez que la sortie de l'arraylist, ajoutez des cartes Lold et LNew dans des arraylistes nouvellement créés li> ol>

   Démo sur Ideone P>

           // start- get arrayList a1 index entries, fetch map,put all maps into one map to 
           //remove duplicate keys,doesn't matter value- because they will be removed anyways)
           Map<String, String> lOld = new HashMap<String, String>();
           for (i = 0; i < a1.size(); i++) {
               HashMap<String, String> a1Map = a1.get(i);
               lOld.putAll(a1Map);
           }
           //end
   
           // start- get arrayList a2 index entries, fetch map,put all maps into other map to remove
           // duplicate keys,doesn't matter value- because they will be removed anyways)
   
           HashMap<String, String> lNew = new HashMap<String, String>();
           for (j = 0; j < a2.size(); j++) {
               HashMap<String, String> a2Map = a2.get(j);
               lNew.putAll(a2Map);
           }
          //end
   
           // check if first map keys (set) is in second map keys (set). 
          //if yes, add them into a list.
           List<String> toRemove = new ArrayList<>();
           Set<String> oldKeys = lOld.keySet();
           Set<String> newKeys = lNew.keySet();
           for (String oldKey : oldKeys) {
               if (lNew.containsKey(oldKey)) {
                   toRemove.add(oldKey);
               }
           }
   
           // remove that list elements from both sets which will remove them from map itself.
           oldKeys.removeAll(toRemove);
           newKeys.removeAll(toRemove);
   
           // print both map
           System.out.println("lold map is: " + lOld);
           System.out.println("lNew map is: " + lNew);
   
           // don't remove elements from set while iterating. it will give ConcurrentModificationException