Wie verbinde ich zwei Listen in Java?

Bedingungen: Ändern Sie nicht die ursprünglichen Listen; Nur JDK, keine externen Bibliotheken. Bonuspunkte für einen Einzeiler oder eine JDK 1.3-Version.

Gibt es einen einfacheren Weg als:

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

In Java 8:

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

Auf den ersten Blick kann ich es um eine Zeile kürzen:

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

Sie können die Apache Commons-Collections- Bibliothek verwenden:

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

Eine Ihrer Anforderungen ist es, die ursprünglichen Listen beizubehalten. Wenn Sie eine neue Liste erstellen und verwendenaddAll() , verdoppeln Sie effektiv die Anzahl der Verweise auf die Objekte in Ihren Listen. Dies kann zu Speicherproblemen führen, wenn Ihre Listen sehr groß sind.

Wenn Sie das verkettete Ergebnis nicht ändern müssen, können Sie dies mithilfe einer benutzerdefinierten Listenimplementierung vermeiden. Die benutzerdefinierte Implementierungsklasse besteht natürlich aus mehr als einer Zeile ... aber die Verwendung ist kurz und bündig.

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

Verwendungszweck:

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

Wahrscheinlich nicht einfacher, aber faszinierend und hässlich:

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

Verwenden Sie es nicht im Produktionscode ...;)

Ein weiterer Java 8 Einzeiler:

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

Als Bonus Stream.of()können Sie beliebig viele Listen verketten , da dies variabel ist.

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

Nicht einfacher, aber ohne Größenänderung:

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

Ich habe diese Frage gefunden, um eine beliebige Anzahl von Listen zu verketten, ohne Rücksicht auf externe Bibliotheken. Vielleicht hilft es jemand anderem:

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

Nützlich, wenn Sie dieselbe Logik auf mehrere verschiedene Sammlungen in einer for () anwenden möchten.

Java 8 ( Stream.ofund Stream.concat)

Die vorgeschlagene Lösung gilt für drei Listen, kann jedoch auch für zwei Listen angewendet werden. In Java 8 können wir Stream.of oder Stream.concat verwenden als:

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.concatNimmt zwei Streams als Eingabe und erstellt einen träge verketteten Stream, dessen Elemente alle Elemente des ersten Streams sind, gefolgt von allen Elementen des zweiten Streams. Da wir drei Listen haben, haben wir diese Methode ( Stream.concat) zweimal verwendet.

Wir können auch eine Utility-Klasse mit einer Methode schreiben, die eine beliebige Anzahl von Listen (unter Verwendung von varargs ) verwendet und eine verkettete Liste wie folgt zurückgibt:

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

Dann können wir diese Methode wie folgt anwenden:

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

Hier ist eine Java 8-Lösung mit zwei Zeilen:

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

Beachten Sie, dass diese Methode nicht verwendet werden sollte, wenn

• Der Ursprung von newListist nicht bekannt und kann bereits mit anderen Threads geteilt werden
• Der Stream, der geändert newListwird , ist ein paralleler Stream und der Zugriff auf newListist nicht synchronisiert oder threadsicher

aufgrund von Nebenwirkungen Überlegungen.

Beide oben genannten Bedingungen gelten nicht für den oben genannten Fall der Verbindung zweier Listen, daher ist dies sicher.

Basierend auf dieser Antwort auf eine andere Frage.

Dies ist einfach und nur eine Zeile, fügt jedoch den Inhalt von listTwo zu listOne hinzu. Müssen Sie den Inhalt wirklich in eine dritte Liste aufnehmen?

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

Etwas einfacher:

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

Ein bisschen kürzer wäre:

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

Sie können Ihre generische Java 8- Dienstprogrammmethode erstellen, um eine beliebige Anzahl von Listen zu verknüpfen .

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

Sie können einen Oneliner erstellen, wenn die Zielliste vordeklariert ist.

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

In Java 8 (umgekehrt):

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

Eine andere Einzeiler-Lösung mit Java8Stream, da die flatMapLösung bereits veröffentlicht ist, ist hier eine Lösung ohneflatMap

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

oder

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

Ausgabe

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

Das klügste meiner Meinung nach:

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

Sie können dies mit einem statischen Import und einer Hilfsklasse tun

nb Die Generierung dieser Klasse könnte wahrscheinlich verbessert werden

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

}

Dann können Sie Dinge wie tun

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

Java 8-Version mit Unterstützung für das Verbinden nach Objektschlüssel:

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

Verwenden Sie eine Helferklasse.

Ich schlage vor:

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

Wir können 2 Listen mit Java8 mit 2 Ansätzen verbinden.

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

1) Verwenden von concat:

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

2) Verwenden von flatMap:

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

Fast alle Antworten schlagen vor, eine ArrayList zu verwenden.

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

Verwenden Sie lieber eine LinkedList für effiziente Additionsvorgänge.

ArrayList add ist O (1) amortisiert, aber O (n) im schlimmsten Fall, da die Größe des Arrays geändert und kopiert werden muss. Während LinkedList add ist immer konstant O (1).

Weitere Informationen https://stackoverflow.com/a/322742/311420

Ich behaupte nicht, dass es einfach ist, aber Sie haben den Bonus für Einzeiler erwähnt ;-)

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

Kein Weg in die Nähe von Einzeiler, aber ich denke, das ist das einfachste:

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

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

Hier ist ein Ansatz mit Streams und Java 8, wenn Ihre Listen unterschiedliche Typen haben und Sie sie zu einer Liste eines anderen Typs kombinieren möchten.

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

Wenn Sie dies statisch tun möchten, können Sie Folgendes tun.

In den Beispielen werden 2 EnumSets in natürlicher Reihenfolge (== Enum-Reihenfolge) verwendet A, Bund dann in einer ALLListe verknüpft .

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

}