Объединение двух списков arrayLists в новый массивList, без дубликатов и по порядку, в Java

Ответ 1

Вместо кода, который вы написали, вы можете использовать ArrayList.addAll(), чтобы объединить списки, Collections.sort(), чтобы отсортировать его и, наконец, переместить полученный ArrayList, чтобы удалить дубликаты. Таким образом, совокупная сложность O(n)+O(n*log(n))+O(n) эквивалентна O(n*log(n)).

Ответ 2

Сначала удалите дубликаты:

arrayList1.removeAll(arrayList2);

Затем слейте два arrayList:

arrayList1.addAll(arrayList2);

Наконец, отсортируйте свой массивList, если хотите:

collections.sort(arrayList1);

Если вы не хотите вносить какие-либо изменения в существующий список, сначала создайте свои резервные списки:

arrayList1Backup = new ArrayList(arrayList1);

Ответ 3

Добавьте ArrayList1, ArrayList2 и создайте Single arraylist ArrayList3. Теперь преобразуем его в

Set Unique_set = new HashSet(Arraylist3);

в уникальном наборе вы получите уникальные элементы.
Примечание

ArrayList позволяет дублировать значения. Установить не позволяет дублировать значения. Надеюсь, ваша проблема решает.

Ответ 4

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

дает вам   Новый список: [A, B, C]

Ответ 5

Может быть, я неправильно использовал вложенные петли?

Подсказка: вложенные петли не будут работать для этой проблемы. Простой цикл также не работает.

Вам нужно визуализировать проблему.

Напишите два упорядоченных списка на листе бумаги и двумя пальцами, чтобы указать элементы соответствующих списков, пройдите через них, как вы делаете слияние в голове. Затем переведите свой процесс принятия решений в алгоритм, а затем код.

Оптимальное решение делает один проход через два списка.

Ответ 6

Добавить элементы в первом arraylist

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

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

Добавить элементы во втором arraylist

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

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

Добавить первые элементы arraylist во втором arraylist

secondArrayList.addAll(firstArrayList);

Назначьте новый комбайновый массив и добавьте все элементы из обоих arraylists

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

Назначить новый набор для удаления дубликатов записей из arraylist

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

Сортировка arraylist

Collections.sort(comboArrayList);

Выход

 A
 B
 C
 D
 E
 F
 G

Ответ 7

Второй цикл for должен иметь j ++ вместо я ++

Ответ 8

Я не уверен, почему ваш текущий код не работает (что такое Exception, которое вы получаете?), но я хотел бы указать, что этот подход выполняет O (N-squared). Рассмотрим предварительную сортировку ваших входных массивов (если они не определены для предварительной сортировки) и слияние отсортированных массивов:

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

Сортировка, как правило, O (N logN), а слияние - O (m + n).

Ответ 9

Java 8 Stream API может использоваться для этой цели,

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, не следует забывать, что distinct() использует hashCode().

Ответ 10

ваш вложенный цикл цикла

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

бесконечна, так как j всегда будет равна нулю, с другой стороны, я будет увеличена по желанию в этом цикле. Вы получаете OutOfBoundaryException, когда я больше, чем plusArray.size()

Ответ 11

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

}

Выход: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Ответ 12

Я понял, что вы не хотите использовать встроенные функции для слияния или удаления дубликатов из ArrayList. Ваш первый код работает навсегда, потому что внешнее условие цикла - "Always True". Поскольку вы добавляете элементы в плюсArray, поэтому размер плюсArray увеличивается с каждым добавлением, и, следовательно, "i" всегда меньше его. В результате условие никогда не прерывается, и программа работает навсегда. Совет. Сначала попробуйте объединить список, а затем из объединенного списка удалите повторяющиеся элементы.:)

Ответ 13

Вам не нужно указывать это вручную. Определение проблемы - это именно поведение Apache Commons CollectionUtils # collate. Он также перегружен для разных порядков сортировки и позволяет дублировать.