Fusion de deux arrayLists dans un nouveau arrayList, sans doublons et dans l’ordre, en Java

J’essaie de “combiner” deux arrayLists, produisant un nouveau arrayList qui contient tous les nombres dans les deux arrayLists combinés, mais sans éléments en double et ils devraient être dans l’ordre. Je suis venu avec ce code ci-dessous. Je le parcours et cela a du sens pour moi, mais je ne suis pas sûr de pouvoir utiliser pour comparer les get (i) dans les listesListe. J’ajoute tous les éléments de array1 dans le plusArray. Ensuite, je parcours le plusArray et le compare à array2 pour voir s’il existe des éléments de array2 dans plusArray. S’ils le font, je ne fais rien, mais s’ils ne le font pas, j’essaie de l’append dans sa position correcte. Peut-être mes boucles nestedes pour une utilisation incorrecte? Remarque: Les listes de tableaux sont présélectionnées par l’utilisateur dans un ordre croissant.

ArrayList plusArray = new ArrayList(); for(int i = 0; i < array1.size(); i++){ plusArray.add(array1.get(i)); } for(int i = 0; i < plusArray.size(); i++){ for(int j = 0; j < array2.size(); j++){ if(array2.get(j)  plusArray.get(i)){ plusArray.add(i, array2.get(j)); } } 

MISE À JOUR: Je ne reçois plus l’exception ci-dessous. Au lieu de cela, il semble que le programme fonctionne pour toujours. J’ai changé l’emplacement où append les éléments dans les conditions . /// Voici l’exception que j’obtiens quand mes listes de tableaux sont: IntSet 1: {1 2} IntSet 2: {1 3 4}

 Exception in thread "main" java.lang.OutOfMemoryError: Java heap space at java.util.Arrays.copyOf(Unknown Source) at java.util.Arrays.copyOf(Unknown Source) at java.util.ArrayList.grow(Unknown Source) at java.util.ArrayList.ensureCapacityInternal(Unknown Source) at java.util.ArrayList.add(Unknown Source) at IntSet.plus(IntSet.java:92) at IntSetDriver.main(IntSetDriver.java:61) 

Au lieu du code que vous avez écrit, vous pouvez utiliser ArrayList.addAll() pour fusionner les listes, Collections.sort() pour le sortinger et enfin parcourir le ArrayList résultant pour supprimer les doublons. La complexité globale est donc O(n)+O(n*log(n))+O(n) qui est équivalent à O(n*log(n)) .

Supprimez tout d’abord les doublons:

 arrayList1.removeAll(arrayList2); 

Puis fusionnez deux arrayList:

 arrayList1.addAll(arrayList2); 

Enfin, sortingez votre arrayList si vous le souhaitez:

 collections.sort(arrayList1); 

Si vous ne souhaitez pas apporter de modifications à la liste existante, créez d’abord leurs listes de sauvegarde:

 arrayList1Backup = new ArrayList(arrayList1); 

Ajoutez ArrayList1, ArrayList2 et produisez un ArraList ArrayList3 unique. Maintenant, convertissez-le en

 Set Unique_set = new HashSet(Arraylist3); 

dans le jeu unique, vous obtiendrez les éléments uniques.
Remarque

ArrayList permet de dupliquer les valeurs. Set ne permet pas de dupliquer les valeurs. J’espère que votre problème sera résolu.

 List listA = new ArrayList(); listA.add("A"); listA.add("B"); List listB = new ArrayList(); listB.add("B"); listB.add("C"); Set newSet = new HashSet(listA); newSet.addAll(listB); List newList = new ArrayList(newSet); System.out.println("New List :"+newList); 

vous donne une nouvelle liste: [A, B, C]

Peut-être mes boucles nestedes pour une utilisation incorrecte?

Indice: les boucles nestedes ne fonctionneront pas pour ce problème. Une simple boucle ne fonctionnera pas non plus.

Vous devez visualiser le problème.

Écrivez deux listes ordonnées sur une feuille de papier et, à l’aide de deux doigts, pointez les éléments des listes respectives et parcourez-les pendant que vous faites la fusion dans votre tête. Ensuite, traduisez votre processus de décision mentale en un algorithme, puis codez.

La solution optimale effectue un seul passage entre les deux listes.

Java 8 Stream API peut être utilisé à cette fin,

 ArrayList list1 = new ArrayList<>(); list1.add("A"); list1.add("B"); list1.add("A"); list1.add("D"); list1.add("G"); ArrayList list2 = new ArrayList<>(); list2.add("B"); list2.add("D"); list2.add("E"); list2.add("G"); List noDup = Stream.concat(list1.stream(), list2.stream()) .distinct() .collect(Collectors.toList()); noDup.forEach(System.out::println); 

En passant, il ne faut pas oublier que distinct() utilise hashCode() .

Ajouter des éléments dans la première liste

 ArrayList firstArrayList = new ArrayList(); firstArrayList.add("A"); firstArrayList.add("B"); firstArrayList.add("C"); firstArrayList.add("D"); firstArrayList.add("E"); 

Ajouter des éléments dans la deuxième liste

 ArrayList secondArrayList = new ArrayList(); secondArrayList.add("B"); secondArrayList.add("D"); secondArrayList.add("F"); secondArrayList.add("G"); 

Ajouter les premiers éléments de l’arraylist dans la deuxième arraylist

 secondArrayList.addAll(firstArrayList); 

Assigner une nouvelle arraylist de combinaison et append tous les éléments des deux arraylists

 ArrayList comboArrayList = new ArrayList(firstArrayList); comboArrayList.addAll(secondArrayList); 

Atsortingbuer un nouvel ensemble pour supprimer les entrées en double de arraylist

 Set setList = new LinkedHashSet(comboArrayList); comboArrayList.clear(); comboArrayList.addAll(setList); 

Trieuse

 Collections.sort(comboArrayList); 

Sortie

  A B C D E F G 

Votre deuxième boucle devrait avoir j ++ au lieu de i ++

Je ne suis pas sûr de savoir pourquoi votre code actuel est défaillant (quelle est l’exception que vous obtenez?), Mais je voudrais souligner que cette approche effectue O (N-carré). Pensez à pré-sortinger vos tableaux d’entrée (s’ils ne sont pas définis pour être pré-sortingés) et à fusionner les tableaux sortingés:

http://www.algolist.net/Algorithms/Merge/Sorted_arrays

Le sorting est généralement O (N logN) et la fusion est O (m + n).

votre nested pour la boucle

  for(int j = 0; j < array2.size(); i++){ 

est infini car j sera toujours égal à zéro, par contre, je serai augmenté à volonté dans cette boucle. Vous obtenez OutOfBoundaryException lorsque i est plus grand que plusArray.size ()

 **Add elements in Final arraylist,** **This will Help you sure** import java.util.ArrayList; import java.util.List; public class NonDuplicateList { public static void main(Ssortingng[] args) { List l1 = new ArrayList(); l1.add("1");l1.add("2");l1.add("3");l1.add("4");l1.add("5");l1.add("6"); List l2 = new ArrayList(); l2.add("1");l2.add("7");l2.add("8");l2.add("9");l2.add("10");l2.add("3"); List l3 = new ArrayList(); l3.addAll(l1); l3.addAll(l2); for (int i = 0; i < l3.size(); i++) { for (int j=i+1; j < l3.size(); j++) { if(l3.get(i) == l3.get(j)) { l3.remove(j); } } } System.out.println(l3); } 

}

Sortie: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

J’ai compris que vous ne voulez pas utiliser les fonctions intégrées pour fusionner ou supprimer les doublons de ArrayList. Votre premier code s’exécute pour toujours car la condition externe de la boucle est «Toujours vrai». Comme vous ajoutez des éléments à plusArray, la taille de plusArray augmente à chaque ajout et «i» est donc toujours inférieur. En conséquence, la condition n’échoue jamais et le programme s’exécute pour toujours. Astuce: Essayez d’abord de fusionner la liste puis, à partir de la liste fusionnée, supprimez les éléments en double. 🙂

Voici une solution utilisant java 8:

 Stream.of(list1, list2) .flatMap(Collection::stream) .distinct() // .sorted() uncomment if you want sorted list .collect(Collectors.toList()); 

Vous n’avez pas à le coder manuellement. La définition du problème est précisément le comportement de Apache Commons CollectionUtils # collate . Il est également surchargé pour différents ordres de sorting et autorisant les doublons.