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

first remove duplicates:

arrayList1.removeAll(arrayList2);

puis fusionner deux tableaux:

arrayList1.addAll(arrayList2);

enfin, triez votre arrayList si vous le souhaitez:

collections.sort(arrayList1);

dans le cas où vous ne voulez pas faire de changements sur la liste existante, créez d'abord leurs listes de sauvegarde:

arrayList1Backup = new ArrayList(arrayList1);

ajouter ArrayList1, ArrayList2 et produire une seule ArrayList ArrayList3. Maintenant convertissez-le en

Set Unique_set = new HashSet(Arraylist3);

dans l'ensemble unique vous obtiendrez les éléments uniques.

Remarque:

ArrayList permet de dupliquer des valeurs. Set ne permet pas aux valeurs de dupliquer. J'espère que votre problème en résout.

List<String> listA = new ArrayList<String>();

    listA.add("A");
    listA.add("B");

List<String> listB = new ArrayList<String>();

    listB.add("B");
    listB.add("C");

Set<String> newSet = new HashSet<String>(listA);

    newSet.addAll(listB);
List<String> newList = new ArrayList<String>(newSet);

System.out.println("New List :"+newList);

est de vous donner Nouvelle Liste: [A, B, C]

peut-être mon emboîté pour boucles étant utilisé incorrectement?

Conseil: les boucles imbriquées ne fonctionneront pas pour ce problème. Un simple pour boucle ne fonctionnera pas non plus.

vous devez visualiser le problème.

écrivez deux listes ordonnées sur un morceau de papier, et en utilisant deux doigts pour pointer les éléments des listes respectives, marchez à travers eux que vous faites la fusion dans votre tête. Puis traduisez votre processus de décision mentale en un algorithme et ensuite code.

la solution optimale fait un seul passage à travers les deux listes.

Java 8 Stream API peut être utilisé pour le but,

ArrayList<String> list1 = new ArrayList<>();

list1.add("A");
list1.add("B");
list1.add("A");
list1.add("D");
list1.add("G");

ArrayList<String> list2 = new ArrayList<>();

list2.add("B");
list2.add("D");
list2.add("E");
list2.add("G");

List<String> 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()hashCode().

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

ArrayList<String> firstArrayList = new ArrayList<String>();

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

ajouter des éléments dans le second arraylist

ArrayList<String> secondArrayList = new ArrayList<String>();

secondArrayList.add("B");
secondArrayList.add("D");
secondArrayList.add("F");
secondArrayList.add("G");

Ajouter une première liste de tableaux d'éléments en deuxième arraylist

secondArrayList.addAll(firstArrayList);

Attribuer de nouvelles combiner liste de tableaux et d'ajouter tous les éléments des deux arraylists

ArrayList<String> comboArrayList = new ArrayList<String>(firstArrayList);
comboArrayList.addAll(secondArrayList);

Assigner un nouveau Jeu pour supprimer des entrées en double dans arraylist

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

Tri des arraylist

Collections.sort(comboArrayList);

Sortie

 A
 B
 C
 D
 E
 F
 G

votre second pour loop devrait avoir j++ au lieu de i++

Je ne suis pas sûr de savoir pourquoi votre code actuel échoue (Quelle est l'Exception que vous obtenez?), mais je tiens à souligner que cette approche fonctionne O(N-au carré). Envisagez de pré-trier vos tableaux d'entrées (s'ils ne sont pas définis pour être pré-triés) et de fusionner les tableaux triés:

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

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

votre for imbriquées boucle

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

est infini car j sera toujours égal à zéro, d'un autre côté, je serai augmenté à volonté dans cette boucle. Vous obtenez une exception quand je suis plus grand que plusArray.taille()

Voici une solution utilisant java 8:

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

**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(String[] args) {

    List<String> l1 = new ArrayList<String>();
    l1.add("1");l1.add("2");l1.add("3");l1.add("4");l1.add("5");l1.add("6");
    List<String> l2 = new ArrayList<String>();
    l2.add("1");l2.add("7");l2.add("8");l2.add("9");l2.add("10");l2.add("3");
    List<String> l3 = new ArrayList<String>();
    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 la liste des tableaux. Votre premier code est en cours d'exécution pour toujours parce que l'extérieur pour la condition de boucle est 'toujours vrai'. Puisque vous ajoutez des éléments à plusArray, ainsi la taille de la plusArray augmente avec chaque ajout et donc ' i ' est toujours moins qu'elle. En conséquence, la condition n'échoue jamais et le programme court pour toujours. Astuce: essayez d'abord de fusionner la liste et ensuite à partir de la liste fusionnée supprimer les doublons éléments. :)

Vous n'avez pas à handcode. La définition du problème est précisément le comportement d'Apache Commons CollectionUtils#collate. Il est également surchargé pour différents ordres de tri et permettant des doublons.