objetos - Fusionando dos arrayLists en una nueva lista de arreglos, sin duplicados y en orden, en Java

lista sin repetidos java

Question

Estoy tratando de "combinar" dos arrayLists, produciendo una nueva lista de arreglos que contiene todos los números en las dos listas de arreglos combinadas, pero sin elementos duplicados y deben estar en orden. Se me ocurrió este código a continuación. Lo reviso y tiene sentido para mí, pero no estoy seguro si puedo usar <o> para comparar get (i) en listas de arreglos. Estoy agregando todos los elementos en array1 en plusArray. Luego voy a través de la herramienta másArray y la comparo con la matriz2 para ver si alguno de los elementos de la matriz2 existe dentro de la matriz más. Si lo hacen, no estoy haciendo nada, pero si no lo hacen, estoy tratando de agregarlo en su posición correcta. ¿Quizás mis bucles anidados se usen incorrectamente? Nota: ArrayLists es ordenado por el usuario en orden creciente.

     ArrayList<Integer> plusArray = new ArrayList<Integer>();
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));
    }
    else if(plusArray.get(i).equals(array2.get(j))){
        ;
    }
    else if(array2.get(j) > plusArray.get(i)){
        plusArray.add(i, array2.get(j));
    }

}

ACTUALIZACIÓN: ya no recibo la excepción a continuación. En cambio, parece que el programa se ejecuta para siempre. Cambié la ubicación de dónde agregar los elementos en las condiciones <y>. /// Esta es la excepción que obtengo cuando mis listas de arreglos son: 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)

Answer 1

¿Quizás mis bucles anidados se usen incorrectamente?

Sugerencia: los bucles anidados no funcionarán para este problema. Un simple for loop tampoco funcionará.

Necesitas visualizar el problema.

Escriba dos listas ordenadas en un pedazo de papel, y usando dos dedos para señalar los elementos de las respectivas listas, páselos mientras hace la fusión en su cabeza. Luego, traduce tu proceso de decisión mental en un algoritmo y luego codifica.

La solución óptima realiza una única pasada a través de las dos listas.

Answer 2

Agregue ArrayList1, ArrayList2 y genere ArrayList3 de arrays únicos. Ahora conviértalo en

Set Unique_set = new HashSet(Arraylist3);

en el conjunto único obtendrás los elementos únicos.
Nota

ArrayList permite duplicar valores. Set no permite que los valores se dupliquen. Espero que tu problema resuelva

Answer 3

Aquí hay una solución usando java 8:

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

Answer 4

En lugar del código que escribió, puede usar ArrayList.addAll() para combinar las listas, Collections.sort() para ordenarlo y finalmente recorrer el ArrayList resultante para eliminar duplicados. La complejidad agregada es, por lo tanto, O(n)+O(n*log(n))+O(n) que es equivalente a O(n*log(n)) .

Answer 5

Entendí que no desea utilizar las funciones integradas para fusionar o eliminar duplicados de ArrayList. Su primer código se ejecuta para siempre porque la condición de bucle for externo es ''Siempre verdadero''. Como está agregando elementos a plusArray, el tamaño de plusArray aumenta con cada adición y, por lo tanto, ''i'' siempre es menor que él. Como resultado, la condición nunca falla y el programa se ejecuta para siempre. Consejo: intente fusionar primero la lista y luego, de la lista fusionada, elimine los elementos duplicados. :)

Answer 6

Java 8 Stream API se puede utilizar para este fin,

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, no se debe olvidar que distinct() hace uso de hashCode() .

Answer 7

No estoy seguro de por qué su código actual está fallando (¿cuál es la excepción que obtiene?), Pero me gustaría señalar que este enfoque realiza O (N-cuadrado). Considere ordenar previamente sus matrices de entrada (si no están definidas para ser clasificadas previamente) y fusionar las matrices ordenadas:

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

La clasificación generalmente es O (N logN) y la fusión es O (m + n).

Answer 8

No tiene que codificar a mano esto. La definición del problema es precisamente el comportamiento de Apache Commons CollectionUtils#collate . También está sobrecargado para diferentes órdenes de clasificación y permite duplicados.

Answer 9

Primero eliminar duplicados:

arrayList1.removeAll(arrayList2);

A continuación, combine dos arrayList:

arrayList1.addAll(arrayList2);

Por último, clasifique su arrayList si lo desea:

collections.sort(arrayList1);

En caso de que no desee realizar ningún cambio en la lista existente, primero cree sus listas de respaldo:

arrayList1Backup = new ArrayList(arrayList1);

Answer 10

Su segundo bucle for debe tener j ++ en lugar de i ++

Answer 11

su anidado para bucle

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

es infinito ya que j siempre será igual a cero; por otro lado, aumentaré a voluntad en este ciclo. Obtienes OutOfBoundaryException cuando soy más grande que plusArray.size ()

Answer 12

Agregar elementos en la primera lista de archivos

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

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

Agregar elementos en el segundo arraylist

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

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

Agregue los primeros elementos del arraylist en el segundo arraylist

secondArrayList.addAll(firstArrayList);

Asigne una nueva lista de arrays de combinación y agregue todos los elementos de ambas listas de arreglos

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

Asignar nuevo conjunto para eliminar entradas duplicadas de la lista de arrays

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

Ordenando arraylist

Collections.sort(comboArrayList);

Salida

 A
 B
 C
 D
 E
 F
 G

Answer 13

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

}

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

Answer 14

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

te está dando una nueva lista: [A, B, C]