Jak dołączyć do dwóch list w Javie?

Warunki: nie modyfikuj oryginalnych list; Tylko JDK, brak bibliotek zewnętrznych. Punkty bonusowe za wersję jedno-liniową lub wersję JDK 1.3.

Czy istnieje prostszy sposób niż:

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

W Javie 8:

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

Z czubka głowy mogę skrócić go o jedną linię:

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

Możesz użyć biblioteki wspólnych kolekcji Apache :

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

Jednym z twoich wymagań jest zachowanie oryginalnych list. Jeśli utworzysz nową listę i użyjesz addAll(), skutecznie podwajasz liczbę odwołań do obiektów na twoich listach. Może to prowadzić do problemów z pamięcią, jeśli twoje listy są bardzo duże.

Jeśli nie musisz modyfikować połączonego wyniku, możesz tego uniknąć za pomocą niestandardowej implementacji listy. Niestandardowa klasa implementacji to oczywiście więcej niż jedna linia ... ale korzystanie z niej jest krótkie i słodkie.

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

Stosowanie:

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

Prawdopodobnie nie prostsze, ale intrygujące i brzydkie:

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

Nie używaj go w kodzie produkcyjnym ...;)

Kolejny jednowierszowy program Java 8:

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

Jako bonus, ponieważ Stream.of()jest on variadic, możesz połączyć dowolną liczbę list.

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

Nie prościej, ale bez zmiany narzutu:

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

Znalazłem to pytanie, próbując połączyć dowolną liczbę list, nie wspominając o bibliotekach zewnętrznych. Być może pomoże to komuś innemu:

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

Przydatne, jeśli chcesz zastosować tę samą logikę do wielu różnych kolekcji w jednym for ().

Java 8 ( Stream.ofi Stream.concat)

Proponowane rozwiązanie dotyczy trzech list, choć można je również zastosować do dwóch list. W Javie 8 możemy skorzystać z Stream.of lub Stream.concat jako:

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.concatpobiera dwa strumienie jako dane wejściowe i tworzy leniwie połączony strumień, którego elementami są wszystkie elementy pierwszego strumienia, a następnie wszystkie elementy drugiego strumienia. Ponieważ mamy trzy listy, zastosowaliśmy tę metodę ( Stream.concat) dwa razy.

Możemy również napisać klasę narzędzia za pomocą metody, która pobiera dowolną liczbę list (używając varargs ) i zwraca skonkatenowaną listę jako:

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

Następnie możemy skorzystać z tej metody jako:

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

Oto rozwiązanie Java 8 wykorzystujące dwie linie:

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

Należy pamiętać, że tej metody nie należy stosować, jeśli

• pochodzenie newListnie jest znane i może być już udostępnione innym wątkom
• strumień, który modyfikuje, newListjest strumieniem równoległym, a dostęp do niego newListnie jest synchronizowany ani bezpieczny dla wątków

ze względu na skutki uboczne.

Oba powyższe warunki nie dotyczą powyższego przypadku połączenia dwóch list, więc jest to bezpieczne.

Na podstawie tej odpowiedzi na inne pytanie.

Jest to prosta i tylko jedna linia, ale doda zawartość listTwo do listOne. Czy naprawdę musisz umieścić zawartość na trzeciej liście?

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

Nieco prostsze:

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

Nieco krótszy byłby:

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

Możesz utworzyć ogólną metodę narzędzia Java 8 , aby połączyć dowolną liczbę list .

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

Możesz zrobić oneliner, jeśli lista celów jest zadeklarowana.

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

W Javie 8 (w drugą stronę):

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

inne rozwiązanie liniowe wykorzystujące Java8strumień, ponieważ flatMaprozwiązanie jest już opublikowane, oto rozwiązanie bezflatMap

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

lub

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

kod

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

wynik

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

Najmądrzejszy moim zdaniem:

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

Możesz to zrobić za pomocą importu statycznego i klasy pomocniczej

nb generacja tej klasy mogłaby prawdopodobnie ulec poprawie

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

}

Następnie możesz robić takie rzeczy jak

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

Wersja Java 8 z obsługą łączenia według klucza obiektu:

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

Użyj klasy pomocnika.

Sugeruję:

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

Możemy dołączyć do 2 list za pomocą java8 z 2 podejściami.

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

1) Za pomocą concat:

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

2) Korzystanie z flatMap:

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

Prawie odpowiedzi sugerują użycie ArrayList.

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

Wolę używać LinkedList do wydajnych operacji dodawania.

ArrayList add jest amortyzowane przez O (1), ale w najgorszym przypadku O (n), ponieważ należy zmienić rozmiar tablicy i skopiować. Podczas gdy LinkedList add jest zawsze stałą O (1).

więcej informacji https://stackoverflow.com/a/322742/311420

Nie twierdzę, że to proste, ale wspomniałeś o premii za linijki ;-)

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

Nie ma mowy w pobliżu jednej linijki, ale myślę, że jest to najprostsze:

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

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

Oto podejście wykorzystujące strumienie i Javę 8, jeśli listy mają różne typy i chcesz je połączyć z listą innego typu.

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

Jeśli chcesz to zrobić statycznie, możesz:

W przykładach użyto 2 zestawów EnumSet w porządku naturalnym (== porządek Enum) A, Bi łączy się następnie na ALLliście.

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

}