เงื่อนไข: ห้ามดัดแปลงรายชื่อดั้งเดิม; 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);
คำตอบ:
ใน 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 คอมมอนส์ -ห้องสมุดเก็บ :
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
หรือแม้กระทั่งกับ
ไม่ใช่เรื่องง่าย แต่ไม่มีการปรับขนาดค่าใช้จ่าย:
List<String> newList = new ArrayList<>(listOne.size() + listTwo.size());
newList.addAll(listOne);
newList.addAll(listTwo);
พบคำถามนี้ที่ต้องการเชื่อมโยงรายการต่าง ๆ เข้าด้วยกันโดยไม่สนใจไลบรารีภายนอก ดังนั้นอาจช่วยคนอื่นได้:
com.google.common.collect.Iterables#concat()
มีประโยชน์ถ้าคุณต้องการใช้ตรรกะเดียวกันกับคอลเลกชันที่แตกต่างกันจำนวนหนึ่งในหนึ่งสำหรับ ()
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
ใช้สองสตรีมเป็นอินพุตและสร้างสตรีมแบบต่อเนื่อง lazily ที่มีองค์ประกอบเป็นองค์ประกอบทั้งหมดของสตรีมแรกตามด้วยองค์ประกอบทั้งหมดของสตรีมที่สอง เนื่องจากเรามีสามรายการเราจึงใช้วิธีนี้ ( 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
ไม่ถูกซิงโครไนซ์หรือ threadsafeเนื่องจากการพิจารณาผลข้างเคียง
เงื่อนไขทั้งสองข้างต้นใช้ไม่ได้กับกรณีด้านบนของการเข้าร่วมสองรายการดังนั้นจึงปลอดภัย
ตามคำตอบนี้กับคำถามอื่น
newList
นั้นไม่สามารถสังเกตได้โดยเธรดอื่น ๆ แต่คุณถูกต้องว่าสิ่งนี้อาจไม่ควรทำหากไม่ทราบว่าค่าnewList
มาจากไหน(ตัวอย่างเช่นถ้าnewList
ผ่านเป็นพารามิเตอร์
.forEach(newList::addAll);
แทน.collect(Collectors.toList());
?
List<List<Object>>
เพราะเก็บจะเก็บรวบรวม สิ่งที่คุณอาจมีในใจคืออะไรเช่นนี้: stackoverflow.com/questions/189559/…
flatMap
ใช่ฉันควรจะได้รับความคิดของ
นี่ง่ายและเพียงหนึ่งบรรทัด แต่จะเพิ่มเนื้อหาของ listTwo to listOne คุณจำเป็นต้องใส่เนื้อหาในรายการที่สามหรือไม่?
Collections.addAll(listOne, listTwo.toArray());
ง่ายขึ้นเล็กน้อย:
List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);
List
โครงสร้างการเรียกเก็บไม่ จำกัด เอกลักษณ์ คุณสามารถลบ dupes โดยทำสิ่งเดียวกันกับชุด Set<String> newSet = new HashSet<>(setOne); newSet.addAll(setTwo);
สั้นกว่าเล็กน้อยคือ:
List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);
คุณสามารถสร้างทั่วไปของJava 8วิธีการสาธารณูปโภคเพื่อ concat จำนวนรายชื่อใด ๆ
@SafeVarargs
public static <T> List<T> concat(List<T>... lists) {
return Stream.of(lists).flatMap(List::stream).collect(Collectors.toList());
}
คุณสามารถทำ oneliner ได้หากรายการเป้าหมายถูกประกาศไว้ล่วงหน้า
(newList = new ArrayList<String>(list1)).addAll(list2);
ใน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 generification ของชั้นนี้อาจอาจจะดีขึ้น
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 version พร้อมรองรับการเข้าร่วมโดยใช้ object key:
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;
}
ใช้คลาสผู้ช่วย
ฉันแนะนำ:
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;
}
เราสามารถเข้าร่วม 2 รายการโดยใช้ java8 ด้วย 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 นั้นคงที่ O (1) เสมอ
ข่าวสารเพิ่มเติมhttps://stackoverflow.com/a/322742/311420
ฉันไม่ได้อ้างว่ามันง่าย แต่คุณพูดถึงโบนัสสำหรับหนึ่ง liners ;-)
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());
}
หากคุณต้องการทำสิ่งนี้แบบคงที่คุณสามารถทำสิ่งต่อไปนี้ได้
ตัวอย่างใช้ EnumSets 2 ชุดในการเรียงตามธรรมชาติ (== Enum-order) 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;
}
}