Wie schließe ich zwei Listen in Java an?


Answers

In Java 8:

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

Bedingungen: Die originalen Listen nicht verändern; JDK nur, keine externen Bibliotheken. Bonuspunkte für eine One-Liner oder JDK 1.3 Version.

Gibt es einen einfacheren Weg als:

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



Wahrscheinlich nicht einfacher, aber faszinierend und hässlich:

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

Benutze es nicht im Produktionscode ...;)




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



Nicht einfacher, aber ohne die Größe zu ändern:

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



Sie können einen Oneliner ausführen, wenn die Zielliste vordefiniert ist.

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



Ein weiterer Java 8 One-Liner:

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

Als Bonus, da Stream.of() variabel ist, können Sie so viele Listen verketten, wie Sie möchten.

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



eine weitere Liner-Lösung mit Java8 Stream, da flatMap Lösung bereits gebucht wurde, hier ist eine Lösung ohne flatMap

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]



Hier ist ein Ansatz mit Streams und Java 8, wenn Ihre Listen verschiedene Typen haben und Sie diese 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());
}



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

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



Java 8-Version mit Unterstützung für den Beitritt 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 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"));

}

}



Etwas einfacher:

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



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



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

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