una - ¿Cómo me uno a dos listas en Java?

lista de string java

Question

Condiciones: no modificar las listas originales; Sólo JDK, no hay bibliotecas externas. Puntos de bonificación para una versión de una sola 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);

Answer 1

Aquí hay una solución java 8 usando dos líneas:

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

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

• el origen de newList no se conoce y puede que ya esté compartido con otros subprocesos
• La secuencia que modifica newList es una secuencia paralela y el acceso a newList no está sincronizado o es seguro para hilos.

Debido a consideraciones de efectos secundarios.

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

Basado en esta respuesta a otra pregunta.

Answer 2

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

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

Answer 3

De ninguna manera cerca de una sola línea, pero creo que esto es lo más simple:

List<String> newList = new ArrayList<String>(l1);
newList.addAll(l2);
for(String w:newList)
System.out.printf("%s ", w);

Answer 4

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

Answer 5

En Java 8 (al revés):

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

Answer 6

En Java 8:

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

Answer 7

En el caso general, no puedo mejorar las dos líneas sin presentar su propio método de utilidad, pero si tiene listas de cadenas y está dispuesto a asumir que esas cadenas no contienen comas, puede tirar este largo -transatlántico:

List<String> newList = new ArrayList<String>(Arrays.asList((listOne.toString().subString(1, listOne.length() - 1) + ", " + listTwo.toString().subString(1, listTwo.length() - 1)).split(", ")));

Si elimina los genéricos, esto debería ser compatible con JDK 1.4 (aunque no lo he probado). Tampoco se recomienda para código de producción ;-)

Answer 8

Encontré esta pregunta buscando concatenar cantidades arbitrarias de listas, sin importar bibliotecas externas. Entonces, tal vez 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 ().

Answer 9

Este es un enfoque que utiliza streams y java 8 si sus listas tienen tipos diferentes y desea combinarlos con 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());
}

Answer 10

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

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

Answer 11

La solución propuesta es para tres listas, aunque también se puede aplicar para dos listas. En Java 8 podemos usar 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.concat toma dos flujos como entrada y crea un flujo concatenado perezosamente cuyos elementos son todos los elementos del primer flujo seguidos por todos los elementos del segundo flujo. 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 toma cualquier número de listas (usando varargs ) y devuelve una lista concatenada como:

public static <T> List<T> concatenatedList(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 = StringUtils.concatenatedList(list1,list2,list3);

Answer 12

No estoy diciendo que sea simple, pero mencionaste una bonificación para las frases de una línea ;-)

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

Answer 13

No más sencillo, pero sin redimensionar gastos generales:

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

Answer 14

Otro Java 8 de una sola línea:

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

Como Stream.of() adicional, ya que Stream.of() es variable, puedes concatenar tantas listas como quieras.

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

Answer 15

Podría usar la biblioteca de colecciones comunes de Apache :

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

Answer 16

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

NB la generación 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);

Answer 17

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

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

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

Answer 18

Puede crear su método genérico de utilidad Java 8 para concentrar cualquier número de listas .

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

Answer 19

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

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

Answer 20

Si quieres hacer esto estáticamente puedes hacer lo siguiente.

Los ejemplos utilizan 2 EnumSets en orden natural (== Enum-order) A, B y se unen luego en una lista de ALL .

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

Answer 21

Un poco más corto sería:

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

Answer 22

Un poco más simple:

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

Answer 23

Uno de sus requisitos es preservar las listas originales. Si crea una nueva lista y usa addAll() , efectivamente está duplicando la cantidad de referencias a los objetos en sus listas. Esto podría llevar a 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 su uso es corto y dulce.

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

Answer 24

Use una clase de ayudante.

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

Answer 25

Versión de Java 8 con soporte para unir 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());
}

Answer 26

otra solución de liner que usa el flujo Java8 , ya que la solución flatMap ya está publicada, aquí hay una solución sin flatMap

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]

Answer 27

public class TestApp {
/**
* @param args
*/
public static void main(String[] args) {
System.out.println("Hi");
Set<List<String>> bcOwnersList = new HashSet<List<String>>();
List<String> bclist = new ArrayList<String>();
List<String> bclist1 = new ArrayList<String>();
List<String> object = new ArrayList<String>();
object.add("BC11");
object.add("C2");
bclist.add("BC1");
bclist.add("BC2");
bclist.add("BC3");
bclist.add("BC4");
bclist.add("BC5");
bcOwnersList.add(bclist);
bcOwnersList.add(object);
bclist1.add("BC11");
bclist1.add("BC21");
bclist1.add("BC31");
bclist1.add("BC4");
bclist1.add("BC5");
List<String> listList= new ArrayList<String>();
for(List<String> ll : bcOwnersList){
listList = (List<String>) CollectionUtils.union(listList,CollectionUtils.intersection(ll, bclist1));
}
/*for(List<String> lists : listList){
test = (List<String>) CollectionUtils.union(test, listList);
}*/
for(Object l : listList){
System.out.println(l.toString());
}
System.out.println(bclist.contains("BC"));
}
}

Answer 28

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

Answer 29

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