¿Cómo unir dos listas en Java?

Condiciones: no modifique las listas originales; JDK solamente, no hay bibliotecas externas. Puntos de bonificación para una versión de una línea o JDK 1.3.

¿Hay una manera más simple que:

List<String> newList = new ArrayList<String>();
newList.addAll(listOne);
newList.addAll(listTwo);

En Java 8:

List<String> newList = Stream.concat(listOne.stream(), listTwo.stream())
                             .collect(Collectors.toList());

Desde la parte superior de mi cabeza, puedo acortarlo en una línea:

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

Puede usar la biblioteca de colecciones comunes de Apache :

List<String> newList = ListUtils.union(list1, list2);

Uno de sus requisitos es preservar las listas originales. Si crea una nueva lista y la usa addAll(), efectivamente está duplicando el número de referencias a los objetos en sus listas. Esto podría provocar problemas de memoria si sus listas son muy grandes.

Si no necesita modificar el resultado concatenado, puede evitarlo utilizando una implementación de lista personalizada. La clase de implementación personalizada es más de una línea, obviamente ... pero usarla es corta y agradable.

CompositeUnmodifiableList.java:

public class CompositeUnmodifiableList<E> extends AbstractList<E> {

    private final List<E> list1;
    private final List<E> list2;

    public CompositeUnmodifiableList(List<E> list1, List<E> list2) {
        this.list1 = list1;
        this.list2 = list2;
    }

    @Override
    public E get(int index) {
        if (index < list1.size()) {
            return list1.get(index);
        }
        return list2.get(index-list1.size());
    }

    @Override
    public int size() {
        return list1.size() + list2.size();
    }
}

Uso:

List<String> newList = new CompositeUnmodifiableList<String>(listOne,listTwo);

Probablemente no más simple, pero intrigante y feo:

List<String> newList = new ArrayList<String>() { { addAll(listOne); addAll(listTwo); } };

No lo use en el código de producción ...;)

Otro Java 8 one-liner:

List<String> newList = Stream.of(listOne, listTwo)
                            .flatMap(Collection::stream)
                            .collect(Collectors.toList());

Como Stream.of()beneficio adicional, dado que es variable, puede concatenar tantas listas como desee.

List<String> newList = Stream.of(listOne, listTwo, listThree)
                            .flatMap(Collection::stream)
                            .collect(Collectors.toList());

No es más simple, pero sin cambiar el tamaño de la sobrecarga:

List<String> newList = new ArrayList<>(listOne.size() + listTwo.size());
newList.addAll(listOne);
newList.addAll(listTwo);

Encontré esta pregunta buscando concatenar una cantidad arbitraria de listas, sin importar bibliotecas externas. Entonces, quizás ayude a alguien más:

com.google.common.collect.Iterables#concat()

Útil si desea aplicar la misma lógica a varias colecciones diferentes en una para ().

Java 8 ( Stream.ofy Stream.concat)

La solución propuesta es para tres listas, aunque también se puede aplicar para dos listas. En Java 8 podemos hacer uso de Stream.of o Stream.concat como:

List<String> result1 = Stream.concat(Stream.concat(list1.stream(),list2.stream()),list3.stream()).collect(Collectors.toList());
List<String> result2 = Stream.of(list1,list2,list3).flatMap(Collection::stream).collect(Collectors.toList());

Stream.concattoma dos secuencias como entrada y crea una secuencia concatenada perezosamente cuyos elementos son todos los elementos de la primera secuencia seguidos de todos los elementos de la segunda secuencia. Como tenemos tres listas, hemos usado este método ( Stream.concat) dos veces.

También podemos escribir una clase de utilidad con un método que tome cualquier número de listas (usando varargs ) y devuelva una lista concatenada como:

public static <T> List<T> concatenateLists(List<T>... collections) {
        return Arrays.stream(collections).flatMap(Collection::stream).collect(Collectors.toList()); 
}

Entonces podemos hacer uso de este método como:

List<String> result3 = Utils.concatenateLists(list1,list2,list3);

Aquí hay una solución de Java 8 que usa dos líneas:

List<Object> newList = new ArrayList<>();
Stream.of(list1, list2).forEach(newList::addAll);

Tenga en cuenta que este método no debe usarse si

• newListse desconoce el origen de y ya se puede compartir con otros hilos
• la secuencia que se modifica newListes una secuencia paralela y el acceso newListno está sincronizado o es seguro

debido a consideraciones de efectos secundarios.

Las dos condiciones anteriores no se aplican al caso anterior de unir dos listas, por lo que esto es seguro.

Basado en esta respuesta a otra pregunta.

Esto es simple y solo una línea, pero agregará el contenido de listTwo to listOne. ¿Realmente necesitas poner el contenido en una tercera lista?

Collections.addAll(listOne, listTwo.toArray());

Ligeramente más simple:

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

Un poco más corto sería:

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

Puede crear su método de utilidad genérico Java 8 para concatenar cualquier cantidad de listas .

@SafeVarargs
public static <T> List<T> concat(List<T>... lists) {
    return Stream.of(lists).flatMap(List::stream).collect(Collectors.toList());
}

Puede hacer un oneliner si la lista de objetivos está predeclarada.

(newList = new ArrayList<String>(list1)).addAll(list2);

En Java 8 (al revés):

List<?> newList = 
Stream.of(list1, list2).flatMap(List::stream).collect(Collectors.toList());

otra solución de un revestimiento utilizando Java8flujo, ya que la flatMapsolución ya está publicada, aquí hay una solución sinflatMap

List<E> li = lol.stream().collect(ArrayList::new, List::addAll, List::addAll);

o

List<E> ints = Stream.of(list1, list2).collect(ArrayList::new, List::addAll, List::addAll);

código

    List<List<Integer>> lol = Arrays.asList(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6));
    List<Integer> li = lol.stream().collect(ArrayList::new, List::addAll, List::addAll);
    System.out.println(lol);
    System.out.println(li);

salida

[[1, 2, 3], [4, 5, 6]]
[1, 2, 3, 4, 5, 6]

El más inteligente en mi opinión:

/**
 * @param smallLists
 * @return one big list containing all elements of the small ones, in the same order.
 */
public static <E> List<E> concatenate (final List<E> ... smallLists)
{
    final ArrayList<E> bigList = new ArrayList<E>();
    for (final List<E> list: smallLists)
    {
        bigList.addAll(list);
    }
    return bigList;
}

Podrías hacerlo con una importación estática y una clase auxiliar

nb el generification de esta clase probablemente podría mejorarse

public class Lists {

   private Lists() { } // can't be instantiated

   public static List<T> join(List<T>... lists) {
      List<T> result = new ArrayList<T>();
      for(List<T> list : lists) {
         result.addAll(list);
      }
      return results;
   }

}

Entonces puedes hacer cosas como

import static Lists.join;
List<T> result = join(list1, list2, list3, list4);

Versión de Java 8 con soporte para unirse por clave de objeto:

public List<SomeClass> mergeLists(final List<SomeClass> left, final List<SomeClass> right, String primaryKey) {
    final Map<Object, SomeClass> mergedList = new LinkedHashMap<>();

    Stream.concat(left.stream(), right.stream())
        .map(someObject -> new Pair<Object, SomeClass>(someObject.getSomeKey(), someObject))
        .forEach(pair-> mergedList.put(pair.getKey(), pair.getValue()));

    return new ArrayList<>(mergedList.values());
}

public static <T> List<T> merge(List<T>... args) {
    final List<T> result = new ArrayList<>();

    for (List<T> list : args) {
        result.addAll(list);
    }

    return result;
}

Usa una clase de ayuda.

Yo sugiero:

public static <E> Collection<E> addAll(Collection<E> dest, Collection<? extends E>... src) {
    for(Collection<? extends E> c : src) {
        dest.addAll(c);
    }

    return dest;
}

public static void main(String[] args) {
    System.out.println(addAll(new ArrayList<Object>(), Arrays.asList(1,2,3), Arrays.asList("a", "b", "c")));

    // does not compile
    // System.out.println(addAll(new ArrayList<Integer>(), Arrays.asList(1,2,3), Arrays.asList("a", "b", "c")));

    System.out.println(addAll(new ArrayList<Integer>(), Arrays.asList(1,2,3), Arrays.asList(4, 5, 6)));
}

public static <T> List<T> merge(@Nonnull final List<T>... list) {
    // calculate length first
    int mergedLength = 0;
    for (List<T> ts : list) {
      mergedLength += ts.size();
    }

    final List<T> mergedList = new ArrayList<>(mergedLength);

    for (List<T> ts : list) {
      mergedList.addAll(ts);
    }

    return mergedList;
  }

Podemos unir 2 listas usando java8 con 2 enfoques.

    List<String> list1 = Arrays.asList("S", "T");
    List<String> list2 = Arrays.asList("U", "V");

1) Usando concat:

    List<String> collect2 = Stream.concat(list1.stream(), list2.stream()).collect(toList());
    System.out.println("collect2 = " + collect2); // collect2 = [S, T, U, V]

2) Usando flatMap:

    List<String> collect3 = Stream.of(list1, list2).flatMap(Collection::stream).collect(toList());
    System.out.println("collect3 = " + collect3); // collect3 = [S, T, U, V]

Casi todas las respuestas sugieren usar una ArrayList.

List<String> newList = new LinkedList<>(listOne);
newList.addAll(listTwo);

Prefiere usar un LinkedList para operaciones de adición eficientes.

ArrayList add es O (1) amortizado, pero O (n) en el peor de los casos ya que la matriz debe ser redimensionada y copiada. Mientras que LinkedList add siempre es constante O (1).

más información https://stackoverflow.com/a/322742/311420

No estoy afirmando que sea simple, pero mencionaste la bonificación por frases ingeniosas ;-)

Collection mergedList = Collections.list(new sun.misc.CompoundEnumeration(new Enumeration[] {
    new Vector(list1).elements(),
    new Vector(list2).elements(),
    ...
}))

De ninguna manera cerca de una línea, pero creo que este es el más simple:

List<String> newList = new ArrayList<String>(l1);
newList.addAll(l2);

for(String w:newList)
        System.out.printf("%s ", w);

Aquí hay un enfoque que usa streams y java 8 si sus listas tienen diferentes tipos y desea combinarlas en una lista de otro tipo.

public static void main(String[] args) {
    List<String> list2 = new ArrayList<>();
    List<Pair<Integer, String>> list1 = new ArrayList<>();

    list2.add("asd");
    list2.add("asdaf");
    list1.add(new Pair<>(1, "werwe"));
    list1.add(new Pair<>(2, "tyutyu"));

    Stream stream = Stream.concat(list1.stream(), list2.stream());

    List<Pair<Integer, String>> res = (List<Pair<Integer, String>>) stream
            .map(item -> {
                if (item instanceof String) {
                    return new Pair<>(0, item);
                }
                else {
                    return new Pair<>(((Pair<Integer, String>)item).getKey(), ((Pair<Integer, String>)item).getValue());
                }
            })
            .collect(Collectors.toList());
}

Si desea hacer esto estáticamente, puede hacer lo siguiente.

Los ejemplos usan 2 EnumSets en orden natural (== Enum-order) A, By luego se unen en una ALLlista.

public static final EnumSet<MyType> CATEGORY_A = EnumSet.of(A_1, A_2);
public static final EnumSet<MyType> CATEGORY_B = EnumSet.of(B_1, B_2, B_3);

public static final List<MyType> ALL = 
              Collections.unmodifiableList(
                  new ArrayList<MyType>(CATEGORY_A.size() + CATEGORY_B.size())
                  {{
                      addAll(CATEGORY_A);
                      addAll(CATEGORY_B);
                  }}
              );

import java.util.AbstractList;
import java.util.List;


/**
 * The {@code ConcatList} is a lightweight view of two {@code List}s.
 * <p>
 * This implementation is <em>not</em> thread-safe even though the underlying lists can be.
 * 
 * @param <E>
 *            the type of elements in this list
 */
public class ConcatList<E> extends AbstractList<E> {

    /** The first underlying list. */
    private final List<E> list1;
    /** The second underlying list. */
    private final List<E> list2;

    /**
     * Constructs a new {@code ConcatList} from the given two lists.
     * 
     * @param list1
     *            the first list
     * @param list2
     *            the second list
     */
    public ConcatList(final List<E> list1, final List<E> list2) {
        this.list1 = list1;
        this.list2 = list2;
    }

    @Override
    public E get(final int index) {
        return getList(index).get(getListIndex(index));
    }

    @Override
    public E set(final int index, final E element) {
        return getList(index).set(getListIndex(index), element);
    }

    @Override
    public void add(final int index, final E element) {
        getList(index).add(getListIndex(index), element);
    }

    @Override
    public E remove(final int index) {
        return getList(index).remove(getListIndex(index));
    }

    @Override
    public int size() {
        return list1.size() + list2.size();
    }

    @Override
    public boolean contains(final Object o) {
        return list1.contains(o) || list2.contains(o);
    }

    @Override
    public void clear() {
        list1.clear();
        list2.clear();
    }

    /**
     * Returns the index within the corresponding list related to the given index.
     * 
     * @param index
     *            the index in this list
     * 
     * @return the index of the underlying list
     */
    private int getListIndex(final int index) {
        final int size1 = list1.size();
        return index >= size1 ? index - size1 : index;
    }

    /**
     * Returns the list that corresponds to the given index.
     * 
     * @param index
     *            the index in this list
     * 
     * @return the underlying list that corresponds to that index
     */
    private List<E> getList(final int index) {
        return index >= list1.size() ? list2 : list1;
    }

}