Условия: не изменять первоначальные списки; Только JDK, нет внешних библиотек. Бонусные баллы для однострочного или JDK 1.3 версии.
Существует ли более простой способ:
List<String> newList = new ArrayList<String>();
newList.addAll(listOne);
newList.addAll(listTwo);
Сверху моей головы я могу сократить ее на одну строку:
List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);
В Java 8:
List<String> newList = Stream.concat(listOne.stream(), listTwo.stream())
.collect(Collectors.toList());
Вы можете использовать библиотеку Apache commons-collection:
List<String> newList = ListUtils.union(list1, list2);
Одно из ваших требований - сохранить исходные списки. Если вы создаете новый список и используете addAll(), вы фактически удваиваете количество ссылок на объекты в ваших списках. Это может привести к проблемам с памятью, если ваши списки очень большие.
Если вам не нужно изменять конкатенированный результат, вы можете избежать этого, используя реализацию настраиваемого списка. Пользовательский класс реализации - это более чем одна строка, очевидно... но использование его короткое и сладкое.
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();
}
}
Использование:
List<String> newList = new CompositeUnmodifiableList<String>(listOne,listTwo);
Наверное, не проще, а интригующе и уродливо:
List<String> newList = new ArrayList<String>() { { addAll(listOne); addAll(listTwo); } };
Не используйте его в производственном коде...;)
Не проще, но без изменения служебных данных:
List<String> newList = new ArrayList<>(listOne.size() + listTwo.size());
newList.addAll(listOne);
newList.addAll(listTwo);
Еще один однострочный один Java 8:
List<String> newList = Stream.of(listOne, listTwo)
.flatMap(x -> x.stream())
.collect(Collectors.toList());
В качестве бонуса, поскольку Stream.of() является переменным, вы можете объединить столько списков, сколько захотите.
List<String> newList = Stream.of(listOne, listTwo, listThree)
.flatMap(x -> x.stream())
.collect(Collectors.toList());
Нашел этот вопрос, чтобы объединить произвольное количество списков, не обращая внимания на внешние библиотеки. Так что, возможно, это поможет кому-то еще:
com.google.common.collect.Iterables#concat()
Полезно, если вы хотите применить одну и ту же логику к множеству разных коллекций в одном для().
Вот решение java 8, использующее две строки:
List<Object> newList = new ArrayList<>();
Stream.of(list1, list2).forEach(newList::addAll);
Помните, что этот метод нельзя использовать, если
newList неизвестно, и оно уже может использоваться совместно с другими потоками.newList, является параллельным потоком, и доступ к newList не синхронизирован или потокобезопасениз-за соображений побочных эффектов.
Оба вышеуказанных условия не применяются для вышеуказанного случая объединения двух списков, поэтому это безопасно.
Основываясь на этом ответе на другой вопрос.
Это просто и только одна строка, но добавит содержимое listTwo в listOne. Вам действительно нужно разместить содержимое в третьем списке?
Collections.addAll(listOne, listTwo.toArray());
Немного проще:
List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);
Предлагаемое решение предназначено для трех списков, хотя оно может применяться и для двух списков. В Java 8 мы можем использовать Stream.of или Stream.concat как:
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 принимает два потока в качестве входных данных и создает ленивый каскадный поток, элементами которого являются все элементы первого потока, за которыми следуют все элементы второго потока. Поскольку у нас есть три списка, мы использовали этот метод (Stream.concat) два раза.
Мы также можем написать служебный класс с методом, который принимает любое количество списков (используя varargs) и возвращает объединенный список в виде:
public static <T> List<T> concatenateLists(List<T>... collections) {
return Arrays.stream(collections).flatMap(Collection::stream).collect(Collectors.toList());
}
Тогда мы можем использовать этот метод как:
List<String> result3 = Utils.concatenateLists(list1,list2,list3);
Немного короче:
List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);
Вы можете сделать oneliner, если список целей предварительно определен.
(newList = new ArrayList<String>(list1)).addAll(list2);
другое однолинейное решение с использованием потока Java8, так как решение flatMap уже опубликовано, вот решение без flatMap
List<E> li = lol.stream().collect(ArrayList::new, List::addAll, List::addAll);
или
List<E> ints = Stream.of(list1, list2).collect(ArrayList::new, List::addAll, List::addAll);
код
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);
Выход
[[1, 2, 3], [4, 5, 6]]
[1, 2, 3, 4, 5, 6]
Вы можете создать свой универсальный метод утилит Java 8 для объединения любого количества списков.
@SafeVarargs
public static <T> List<T> concat(List<T>... lists) {
return Stream.of(lists).flatMap(List::stream).collect(Collectors.toList());
}
В Java 8 (иначе):
List<?> newList =
Stream.of(list1, list2).flatMap(List::stream).collect(Collectors.toList());
Самый умный, на мой взгляд:
/**
* @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;
}
Вы можете сделать это со статическим импортом и вспомогательным классом
nb можно было бы улучшить генерацию этого класса.
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;
}
}
Затем вы можете делать такие вещи, как
import static Lists.join;
List<T> result = join(list1, list2, list3, list4);
Версия Java 8 с поддержкой соединения с помощью ключа объекта:
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 <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(List<T>... args) {
final List<T> result = new ArrayList<>();
for (List<T> list : args) {
result.addAll(list);
}
return result;
}
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;
}
Я не утверждаю, что это просто, но вы упомянули о бонусе для однострочных; -)
Collection mergedList = Collections.list(new sun.misc.CompoundEnumeration(new Enumeration[] {
new Vector(list1).elements(),
new Vector(list2).elements(),
...
}))
Ничего не стоит рядом с одним слоем, но я думаю, что это самое простое:
List<String> newList = new ArrayList<String>(l1);
newList.addAll(l2);
for(String w:newList)
System.out.printf("%s ", w);
Здесь используется подход с использованием потоков и java 8, если ваши списки имеют разные типы и вы хотите объединить их в список другого типа.
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());
}
Если вы хотите сделать это статически, вы можете сделать следующее.
В примерах используются 2 EnumSets в естественном порядке (== Enum-порядке) A, B и затем объединяются в список 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);
}}
);
В котлин:
val result = listOne.plus(listTwo)
Или проще:
val result = listOne + listTwo
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;
}
}
List<?> newList = ListUtils.combine(list1, list2);
О, вы должны реализовать метод combine: -)