条件:请勿修改原始清单;仅JDK,无外部库。一线或JDK 1.3版本的加分点。
有没有比以下更简单的方法:
List<String> newList = new ArrayList<String>();
newList.addAll(listOne);
newList.addAll(listTwo);
条件:请勿修改原始清单;仅JDK,无外部库。一线或JDK 1.3版本的加分点。
有没有比以下更简单的方法:
List<String> newList = new ArrayList<String>();
newList.addAll(listOne);
newList.addAll(listTwo);
Answers:
在Java 8中:
List<String> newList = Stream.concat(listOne.stream(), listTwo.stream())
.collect(Collectors.toList());
List<String> newList = Stream.concat(listOne.stream(), listTwo.stream()).distinct().collect(Collectors.toList());
Stream.of(listOne, listTwo).flatMap(Collection::stream).collect(Collectors.toList())
我可以把它缩短一排:
List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);
addAll()
了两者。我尝试了所有建议不要复制列表的方法,它们导致我们这次不需要很多开销。
addAll(Collection)
返回boolean
。
您可以使用Apache commons-collections库:
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);
Collections.unmodifiableList()
方法非常相似,该方法包装了一个列表使其无法修改。 CompositeUnmodifiableList
除了包装两个列表并提供串联视图外,它的功能相同。您提出的所有观点也CompositeUnmodifiableList
都是正确的Collections.unmodifiableList()
。
List<? extends E>
可能不简单,但有趣且丑陋:
List<String> newList = new ArrayList<String>() { { addAll(listOne); addAll(listTwo); } };
不要在生产代码中使用它;;)
另一个Java 8单行代码:
List<String> newList = Stream.of(listOne, listTwo)
.flatMap(Collection::stream)
.collect(Collectors.toList());
另外,由于Stream.of()
可变参数,您可以连接任意数量的列表。
List<String> newList = Stream.of(listOne, listTwo, listThree)
.flatMap(Collection::stream)
.collect(Collectors.toList());
x -> x.stream()
可以用代替Collection::stream
。
List::stream
。
发现了这个问题,希望连接任意数量的列表,而不在乎外部库。因此,也许会帮助其他人:
com.google.common.collect.Iterables#concat()
如果要在一个for()中将相同的逻辑应用于多个不同的集合,则很有用。
com.google.common.collect.Iterators#concat(java.util.Iterator<? extends java.util.Iterator<? extends T>>)
代替Iterables#concat()
; 因为以后仍然将元素复制到临时链接中!
Java 8(
Stream.of
和Stream.concat
)
提议的解决方案适用于三个列表,尽管它也可以应用于两个列表。在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);
这是使用两行的Java 8解决方案:
List<Object> newList = new ArrayList<>();
Stream.of(list1, list2).forEach(newList::addAll);
请注意,如果出现以下情况,则不应使用此方法
newList
未知,可能已与其他线程共享newList
是并行流,并且访问 newList
不同步或线程安全由于副作用的考虑。
上述两个条件不适用于将两个列表连接在一起的上述情况,因此这是安全的。
基于这个答案,另一个问题。
newList
上,任何其他线程都无法观察到。但是您是正确的,如果不知道值的newList
来源(例如,如果newList
作为参数传递),则可能不应该这样做(例如,作为参数传递。)
.forEach(newList::addAll);
代替.collect(Collectors.toList());
?
List<List<Object>>
。您可能想到的是这样的:stackoverflow.com/questions/189559/…–
flatMap
。
稍微简单一点:
List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);
List
结构没有任何唯一性约束。您可以通过对集合执行相同的操作来删除重复项。Set<String> newSet = new HashSet<>(setOne); newSet.addAll(setTwo);
在Java 8中(另一种方式):
List<?> newList =
Stream.of(list1, list2).flatMap(List::stream).collect(Collectors.toList());
另一个使用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]
flatMap
,因为列表在收集时仅被迭代一次
我认为最聪明的是:
/**
* @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;
}
@SafeVarargs
!
您可以使用静态导入和帮助程序类来完成此操作
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(@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;
}
我们可以使用java8和2种方法加入2个列表。
List<String> list1 = Arrays.asList("S", "T");
List<String> list2 = Arrays.asList("U", "V");
1)使用concat:
List<String> collect2 = Stream.concat(list1.stream(), list2.stream()).collect(toList());
System.out.println("collect2 = " + collect2); // collect2 = [S, T, U, V]
2)使用flatMap:
List<String> collect3 = Stream.of(list1, list2).flatMap(Collection::stream).collect(toList());
System.out.println("collect3 = " + collect3); // collect3 = [S, T, U, V]
几乎所有的答案都建议使用ArrayList。
List<String> newList = new LinkedList<>(listOne);
newList.addAll(listTwo);
最好使用LinkedList进行有效的添加操作。
ArrayList add被O(1)摊销,但是O(n)最坏的情况是因为必须调整数组大小并复制它。而LinkedList add始终为常数O(1)。
我并不是说这很简单,但是您提到了单线奖励;-)
Collection mergedList = Collections.list(new sun.misc.CompoundEnumeration(new Enumeration[] {
new Vector(list1).elements(),
new Vector(list2).elements(),
...
}))
如果您的列表具有不同的类型,并且您想将它们组合到另一种类型的列表中,那么这是一种使用流和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());
}
如果要静态执行此操作,则可以执行以下操作。
这些示例以自然顺序(== Enum-order)使用2个EnumSet,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);
}}
);
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;
}
}