Comment joindre deux listes en Java?

Conditions: ne modifiez pas les listes originales; JDK uniquement, pas de bibliothèques externes. Points bonus pour un one-liner ou une version JDK 1.3.

Existe-t-il un moyen plus 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());

Du haut de ma tête, je peux le raccourcir d'une ligne:

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

Vous pouvez utiliser la bibliothèque Apache commons-collections :

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

L'une de vos exigences est de conserver les listes originales. Si vous créez une nouvelle liste et utilisez addAll(), vous doublez effectivement le nombre de références aux objets dans vos listes. Cela pourrait entraîner des problèmes de mémoire si vos listes sont très volumineuses.

Si vous n'avez pas besoin de modifier le résultat concaténé, vous pouvez éviter cela en utilisant une implémentation de liste personnalisée. La classe d'implémentation personnalisée est plus d'une ligne, évidemment ... mais son utilisation est courte et douce.

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

Usage:

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

Probablement pas plus simple, mais intrigant et laid:

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

Ne l'utilisez pas dans le code de production ...;)

Une autre ligne unique Java 8:

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

En prime, comme Stream.of()c'est variadic, vous pouvez concaténer autant de listes que vous le souhaitez.

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

Pas plus simple, mais sans redimensionner la surcharge:

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

Trouvé cette question cherchant à concaténer une quantité arbitraire de listes, sans se soucier des bibliothèques externes. Donc, cela aidera peut-être quelqu'un d'autre:

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

Utile si vous souhaitez appliquer la même logique à plusieurs collections différentes en une pour ().

Java 8 ( Stream.ofet Stream.concat)

La solution proposée concerne trois listes, mais elle peut également s'appliquer à deux listes. Dans Java 8, nous pouvons utiliser Stream.of ou Stream.concat comme:

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.concatprend deux flux en entrée et crée un flux paresseusement concaténé dont les éléments sont tous les éléments du premier flux suivis de tous les éléments du second flux. Comme nous avons trois listes, nous avons utilisé cette méthode ( Stream.concat) deux fois.

Nous pouvons également écrire une classe utilitaire avec une méthode qui prend n'importe quel nombre de listes (en utilisant des varargs ) et retourne une liste concaténée comme:

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

Ensuite, nous pouvons utiliser cette méthode comme:

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

Voici une solution java 8 utilisant deux lignes:

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

Sachez que cette méthode ne doit pas être utilisée si

• l'origine de newListn'est pas connue et elle peut déjà être partagée avec d'autres threads
• le flux qui modifie newListest un flux parallèle et l'accès à newListn'est pas synchronisé ou threadsafe

en raison de considérations d'effets secondaires.

Les deux conditions ci-dessus ne s'appliquent pas au cas ci-dessus de rejoindre deux listes, c'est donc sans danger.

Basé sur cette réponse à une autre question.

C'est simple et juste une ligne, mais ajoutera le contenu de listTwo à listOne. Avez-vous vraiment besoin de mettre le contenu dans une troisième liste?

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

Un peu plus simple:

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

Un peu plus court serait:

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

Vous pouvez créer votre méthode utilitaire générique Java 8 pour concatrier n'importe quel nombre de listes .

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

Vous pouvez faire un oneliner si la liste cible est pré-déclarée.

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

En Java 8 (dans l'autre sens):

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

une autre solution de liner en utilisant Java8stream, puisque la flatMapsolution est déjà publiée, voici une solution sansflatMap

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

ou

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

code

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

production

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

Le plus intelligent à mon avis:

/**
 * @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;
}

Vous pouvez le faire avec une importation statique et une classe d'assistance

nb la génération de cette classe pourrait probablement être améliorée

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

}

Ensuite, vous pouvez faire des choses comme

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

Version Java 8 avec prise en charge de la jonction par clé d'objet:

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

Utilisez une classe d'assistance.

Je suggère:

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

Nous pouvons joindre 2 listes en utilisant java8 avec 2 approches.

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

1) Utilisation de concat:

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

2) Utilisation de flatMap:

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

Presque des réponses suggèrent d'utiliser une ArrayList.

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

Préférez utiliser une LinkedList pour des opérations d'ajout efficaces.

ArrayList add est O (1) amorti, mais O (n) dans le pire des cas car le tableau doit être redimensionné et copié. Alors que LinkedList add est toujours constant O (1).

plus d'infos https://stackoverflow.com/a/322742/311420

Je ne prétends pas que c'est simple, mais vous avez mentionné le bonus pour les one-liners ;-)

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

Pas du tout près d'une ligne, mais je pense que c'est la plus simple:

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

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

Voici une approche utilisant des flux et java 8 si vos listes ont différents types et que vous souhaitez les combiner à une liste d'un autre type.

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 vous souhaitez le faire de manière statique, vous pouvez procéder comme suit.

Les exemples utilisent 2 EnumSets dans l'ordre naturel (== Enum-order) A, Bet les rejoignent ensuite dans une ALLliste.

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

}