ฉันจะเข้าร่วมสองรายการใน Java ได้อย่างไร


749

เงื่อนไข: ห้ามดัดแปลงรายชื่อดั้งเดิม; JDK เท่านั้นไม่มีไลบรารีภายนอก คะแนนโบนัสสำหรับรุ่นเดียวหรือรุ่น JDK 1.3

มีวิธีที่ง่ายกว่า:

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

5
หากคุณทำสิ่งนี้เพียงเพื่อจุดประสงค์การทำซ้ำโปรดดูคำถามอื่น - มี Google guava และ java 8 solutions stackoverflow.com/questions/4896662/…
Boris Treukhov

โซลูชัน Java 8 พร้อมวิธียูทิลิตี้: stackoverflow.com/a/37386846/1216775
akhil_mittal

หลังจากอ่านคำตอบบางอย่างฉันขอโทษฉันถาม
Anthony Rutledge

คำตอบ:


591

ใน Java 8:

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

82
อืมนั่นเป็นสิ่งที่อยู่ใน Java 8 ใช่ไหม เทคนิคที่คุณชนะผมคิดว่า แต่ที่ heck ของสายยาว :-)
โรเบิร์ตแอตกินส์

4
สำหรับผู้อ่านทั่วไปนี่เป็นคำตอบสั้นลงโดยใช้ Java _ Streams: stackoverflow.com/a/34090554/363573
Stephan

7
มันน่าเกลียด แต่อย่างน้อยก็คล่องแคล่วและสามารถใช้งานได้โดยไม่ต้องแกะหลายบรรทัด ฉันหวังว่าจะมีส่วนเสริมอย่างคล่องแคล่วซึ่งส่งคืนรายการที่เชื่อมโยงกัน
Usman Ismail

6
ฉันคิดว่ามันน่าสังเกตว่ามันเป็นเรื่องง่ายมากที่จะได้รายชื่อที่แตกต่างออกไปจากเรื่องนี้เช่นกัน:List<String> newList = Stream.concat(listOne.stream(), listTwo.stream()).distinct().collect(Collectors.toList());
Roger

1
ทางเลือกอื่นสำหรับ concat: สตรีมของลำธารStream.of(listOne, listTwo).flatMap(Collection::stream).collect(Collectors.toList())
Peter Walser

569

จากด้านบนของหัวฉันสามารถย่อให้สั้นลงหนึ่งบรรทัด:

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

156
ในขณะที่คุณถูกต้องทางเทคนิคคุณได้ย่อให้สั้นลงหนึ่งบรรทัดความไม่สมดุลของข้อบกพร่องนี้ทำให้ฉัน พอฉันมีความสุขที่จะ "ใช้" บรรทัดพิเศษ
Robert Atkins

13
ไม่มีปัญหาที่นี่ที่ interal ของ newList array จะเริ่มต้นขนาดของ listOne แล้วต้องขยายเมื่อเพิ่มรายการทั้งหมดจาก listTwo? มันจะดีกว่าหรือไม่ที่จะใช้ขนาดของแต่ละรายการและใช้เพื่อกำหนดขนาดของอาร์เรย์ใหม่
Eric

2
นี่คือทางออกที่ดีที่สุดสำหรับฉัน ฉันทำการเปรียบเทียบประสิทธิภาพของโซลูชันที่แตกต่างกันซึ่งผู้ชนะออกมาพร้อมกับการสร้างรายการว่างและจากนั้นaddAll()ทั้งคู่ ฉันลองทั้งหมดที่แนะนำไม่คัดลอกรายการและพวกเขาทำให้มีค่าใช้จ่ายมากมายที่เราไม่ต้องการเวลานี้
manuelvigarcia

ดี แต่คุณสามารถทำให้สั้นลงได้: List list = new ArrayList <> (list1) .addAll (list2);
ความเร็ว

1
@velocity: ไม่ว่าจะไม่ทำงาน ผลตอบแทนaddAll(Collection) boolean
Stijn Van Bael

306

คุณสามารถใช้Apache คอมมอนส์ -ห้องสมุดเก็บ :

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

52
ดี แต่ต้องใช้ apache ทั่วไป เขาระบุ 'ไม่มีห้องสมุดภายนอก'
Quantum7

101
@ Quantum7 ยังมีประโยชน์สำหรับคนอื่น ๆ ;) นอกจากนี้ apache ยังรวมถึงห้องสมุดภายนอกหรือไม่? ฉันไม่เริ่มอะไรเลยถ้าไม่มีมัน!
tster

28
@ Platinum ไม่ตามเอกสาร ListUtils.union นั้นเทียบเท่ากับรหัสของ OP แต่อาจเป็นการเข้าใจผิดที่จะใช้การดำเนินการ SET ("Union") ในบริบทรายการ ฉันสามารถดูว่าคุณอาจคาดหวังว่าสิ่งนี้จะลบรายการที่ซ้ำกันหรือบางสิ่งบางอย่าง แต่ดูเหมือนว่าวิธีการไม่ได้ทำ
Quantum7

24
หลีกเลี่ยงการรวบรวม Apache Commons มันไม่ใช่ประเภทที่ปลอดภัยไม่มียาชื่อสามัญ ยอดเยี่ยมถ้าคุณใช้ Java 1.4 แต่สำหรับ Java 5 ขึ้นไปฉันต้องการ Google Guava
Michael Piefel

11
@MichaelPiefel คอลเลคชั่น Apache Commons 4 ล่าสุดเป็นประเภทที่ปลอดภัย ด้วยการอ้างอิงวิธี Java 8 สาธารณูปโภคแบบคงที่นี้มีความสำคัญมาก
mingfai

93

หนึ่งในข้อกำหนดของคุณคือการรักษารายการดั้งเดิมไว้ หากคุณสร้างรายการใหม่และใช้งาน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);

15
นี่คือคำตอบที่แท้จริงสำหรับคำถามนี้
Wouter Lievens

9
นี่เป็นวิธีแก้ปัญหาที่ใช้การได้ แต่โปรดทราบว่าหากวัตถุรายการพื้นฐานเปลี่ยนแปลง (list1, list2) เนื้อหาของรายการนี้จะเปลี่ยนไป คุณอาจไม่สามารถแก้ไขอินสแตนซ์ของ CompositeUnmodifiableList ได้เองแต่ถ้าคุณสามารถรับการอ้างอิงไปยังรายการดั้งเดิมคุณก็สามารถทำได้ นอกจากนี้สำหรับผู้ที่ไม่คุ้นเคย: ตัวปรับขั้นสุดท้ายมีผลกับการอ้างอิงไปยังอ็อบเจกต์ลิสต์เองไม่สามารถเปลี่ยนแปลงได้ แต่ก็ยังเป็นไปได้ที่เนื้อหาของรายการจะเปลี่ยน!
jwj

3
@ jwj คะแนนดีมากขอบคุณ ชื่อคลาสอาจสมควรได้รับคำอธิบายบางอย่าง ฉันเห็นว่าคลาสนี้ทำสิ่งที่คล้ายกันมากกับCollections.unmodifiableList()วิธีการซึ่งล้อมรายการเพื่อทำให้ไม่สามารถแก้ไขได้ CompositeUnmodifiableListทำสิ่งเดียวกันยกเว้นจะตัดรายการสองรายการและแสดงมุมมองที่ต่อกัน ทุกจุดที่คุณทำCompositeUnmodifiableListนั้นเป็นจริงCollections.unmodifiableList()เช่นกัน
เควินเค

2
ตัวสร้างสามารถใช้List<? extends E>
Patrick Parker

84

อาจไม่ง่าย แต่น่าสนใจและน่าเกลียด:

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

อย่าใช้มันในรหัสการผลิต ... ;)


44
น่าเกลียดและชั่วร้ายเช่นเดียวกับการใช้การเริ่มต้นรั้งคู่ใด ๆ มันเป็นเวลาที่สั้นกว่าแม้ว่า;)
Jorn

4
@MarnixKlooster: Eclipse รู้ดีว่าคุณไม่ควรใช้มันและทำให้มันไม่เป็นที่พอใจในการใช้ ;-)
Joachim Sauer

20
แม้ว่ามันจะเป็นเส้นเดียว แต่ฉันก็ไม่คิดว่าเป็น "หนึ่งซับ"
splungebob

11
ทำไมผู้คนถึงเกลียดชังผู้เริ่มต้นบล็อกนิรนาม
NimChimpsky

18
@NimChimpsky ฉันคิดว่าส่วนใหญ่เป็นเพราะมันไม่ได้เป็นเพียงแค่ initializer บล็อกที่ไม่ระบุชื่อ แต่จริงๆแล้วคุณกำลังสร้างคลาสย่อยที่ไม่ระบุชื่อของ ArrayList ที่ถูกกล่าวว่าถ้าคุณเชื่อมั่นในผลลัพธ์ของคำถามการเริ่มต้น Double Braceมันทำให้ดูเหมือนว่าเกลียด DBI ส่วนใหญ่เป็นเรื่องของรสนิยมโวหารและการเพิ่มประสิทธิภาพขนาดเล็ก เท่าที่ฉันสามารถบอกได้ไม่มีการลงโทษที่สำคัญสำหรับการทำมัน ข้อเสียเล็ก ๆ น้อย ๆ จะเป็นถ้าคุณเคยพยายามที่จะเปรียบเทียบระดับเพราะมันจะไม่ ArrayList
Patrick

75

อีก 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());

35
x -> x.stream()Collection::streamจะถูกแทนที่ด้วย
Martin

10
... List::streamหรือแม้กระทั่งกับ
MC Emperor

73

ไม่ใช่เรื่องง่าย แต่ไม่มีการปรับขนาดค่าใช้จ่าย:

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

55

พบคำถามนี้ที่ต้องการเชื่อมโยงรายการต่าง ๆ เข้าด้วยกันโดยไม่สนใจไลบรารีภายนอก ดังนั้นอาจช่วยคนอื่นได้:

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

มีประโยชน์ถ้าคุณต้องการใช้ตรรกะเดียวกันกับคอลเลกชันที่แตกต่างกันจำนวนหนึ่งในหนึ่งสำหรับ ()


9
ตัวอย่างเช่น: Lists.newArrayList (Iterables.concat (list1, list2));
meilechh

คุณควรจะเรียกcom.google.common.collect.Iterators#concat(java.util.Iterator<? extends java.util.Iterator<? extends T>>)แทนIterables#concat(); เพราะในภายหลังยังคงคัดลอกองค์ประกอบลงในลิงก์ชั่วคราว!
บ๊อบ

45

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

คุณอาจเต็มใจที่จะพูดรายการ <String> result1 = Stream.concat (Stream.concat (list1.stream (), list2.stream ()), list3.stream ()) รวบรวม (Collector.toList ()); ในผู้ให้บริการรายแรกของคุณ กรุณาแก้ไข
WebComer

44

นี่คือโซลูชัน java 8 ที่ใช้สองบรรทัด:

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

ระวังว่าวิธีนี้ไม่ควรใช้ถ้า

  • ที่มาของ newListไม่เป็นที่รู้จักและมันอาจจะใช้ร่วมกันกับหัวข้ออื่น ๆ
  • สตรีมที่แก้ไขnewListเป็นสตรีมแบบขนานและการเข้าถึง newListไม่ถูกซิงโครไนซ์หรือ threadsafe

เนื่องจากการพิจารณาผลข้างเคียง

เงื่อนไขทั้งสองข้างต้นใช้ไม่ได้กับกรณีด้านบนของการเข้าร่วมสองรายการดังนั้นจึงปลอดภัย

ตามคำตอบนี้กับคำถามอื่น


12
หากฉันไม่ผิดก็ไม่แนะนำให้ทำเช่นนี้ - docs.oracle.com/javase/8/docs/api/java/util/stream/?hl=th โปรดดูส่วนด้านประสิทธิภาพ > ผลข้างเคียงของพารามิเตอร์พฤติกรรมในการทำงานของสตรีมโดยทั่วไปนั้นเป็นสิ่งที่ท้อแท้เนื่องจากพวกเขามักจะนำไปสู่การละเมิดความต้องการไร้สัญชาติโดยไม่เจตนารวมถึงอันตรายจากความปลอดภัยของด้ายอื่น ๆ ดังนั้นในกรณีนี้จะดีกว่าถ้าใช้ Collector.toList ()
Anton Balaniuc

@AntonBalaniuc คำถามคือถ้าไม่ว่าจะเป็นจริงผลข้างเคียง ณ จุดnewListนั้นไม่สามารถสังเกตได้โดยเธรดอื่น ๆ แต่คุณถูกต้องว่าสิ่งนี้อาจไม่ควรทำหากไม่ทราบว่าค่าnewListมาจากไหน(ตัวอย่างเช่นถ้าnewListผ่านเป็นพารามิเตอร์
SpaceTrucker

2
ฉันอยากรู้; ทำไม.forEach(newList::addAll);แทน.collect(Collectors.toList());?
11684

4
@ 11684 List<List<Object>>เพราะเก็บจะเก็บรวบรวม สิ่งที่คุณอาจมีในใจคืออะไรเช่นนี้: stackoverflow.com/questions/189559/…
SpaceTrucker

@ SpaceTrucker โอ๊ะฉันมองข้ามไปแล้ว ขอบคุณสำหรับการล้างความสับสนของฉัน flatMapใช่ฉันควรจะได้รับความคิดของ
11684

34

นี่ง่ายและเพียงหนึ่งบรรทัด แต่จะเพิ่มเนื้อหาของ listTwo to listOne คุณจำเป็นต้องใส่เนื้อหาในรายการที่สามหรือไม่?

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

11
การไม่แก้ไขรายการดั้งเดิมเป็นหนึ่งในเกณฑ์ แต่สิ่งนี้มีประโยชน์ที่จะมีที่นี่เป็นตัวอย่างสำหรับสถานการณ์ที่ไม่มีข้อ จำกัด
Robert Atkins

1
ขอขอบคุณหรือแม้แต่ listOne.addAll ที่เรียบง่ายกว่า (listTwo)
Jay

27

ง่ายขึ้นเล็กน้อย:

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

สิ่งนี้จะทำให้สตริงที่ซ้ำกันหรือไม่ ความหมายของสตริงที่มีอยู่ในทั้งสองรายการจะมีอยู่สองครั้งในรายการผลลัพธ์
AgentKnopf

4
@ Zainodis ใช่อาจมีการซ้ำซ้อน Listโครงสร้างการเรียกเก็บไม่ จำกัด เอกลักษณ์ คุณสามารถลบ dupes โดยทำสิ่งเดียวกันกับชุด Set<String> newSet = new HashSet<>(setOne); newSet.addAll(setTwo);
Patrick

20

สั้นกว่าเล็กน้อยคือ:

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

17

คุณสามารถสร้างทั่วไปของJava 8วิธีการสาธารณูปโภคเพื่อ concat จำนวนรายชื่อใด

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

13

คุณสามารถทำ oneliner ได้หากรายการเป้าหมายถูกประกาศไว้ล่วงหน้า

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


9

อีกหนึ่งโซลูชันซับโดยใช้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]

1
ฉันจะเพิ่มว่าวิธีการแก้ปัญหานี้อาจมีประสิทธิภาพมากกว่าที่ใช้flatMapเพราะรายการจะซ้ำเพียงครั้งเดียวเมื่อพวกเขาจะถูกรวบรวม
สเตฟาน Haberl

7

ฉลาดในความคิดของฉัน:

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

3
อย่าลืม@SafeVarargs!
Radon Rosborough

6

คุณสามารถทำได้ด้วยการนำเข้าคงที่และระดับผู้ช่วย

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

การนำเข้าคงที่หรือคลาสผู้ช่วยมีความสัมพันธ์กันอย่างไร
shmosel

6

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


4

ใช้คลาสผู้ช่วย

ฉันแนะนำ:

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

3
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

เราสามารถเข้าร่วม 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]

1
เมื่อตอบคำถามอายุสิบเอ็ดปีโดยมีคำตอบอีกสามสิบข้อให้แน่ใจว่าได้ชี้ประเด็นใหม่ ๆ ของคำถามที่คุณตอบไปและให้สังเกตว่าเทคนิคเหล่านี้จะใช้ได้เมื่อคำถามถูกถามหรือว่าขึ้นอยู่กับคุณสมบัติที่เคยเป็น แนะนำในช่วงหลายปี
Jason Aller

2

เกือบคำตอบแนะนำให้ใช้ 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


0

ฉันไม่ได้อ้างว่ามันง่าย แต่คุณพูดถึงโบนัสสำหรับหนึ่ง liners ;-)

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

ทำไมบางคนไม่เคยใช้สิ่งเหล่านั้น?
David

5
@ David เนื่องจากมีวัตถุประสงค์เพื่อใช้ภายในใน JDK หากคุณใช้ในรหัสของคุณรหัสของคุณอาจจะไม่ทำงานบนที่ไม่ใช่ Sun (หรือไม่ใช่ Oracle ตอนนี้) JDK / JRE
Adrian Shum

@AdrianShum มี JDKs / JREs อื่นนอกเหนือจาก Oracle หรือไม่ นั่นจะทำให้ฉันประหลาดใจ แม้ว่าจะถูก จำกัด ให้ใช้งานได้กับ API ทั่วไป แต่การสร้างสิ่งนั้นใหม่อาจใช้เวลานานกว่าเดิม ...
Egor Hans

1
มี JVM ค่อนข้างมาก สิ่งที่เห็นได้มากที่สุดในโลกธุรกิจควรเป็น IBM ซึ่งก็คือ iirc ซึ่งมาพร้อมกับ websphere
Adrian Shum

0

ไม่มีทางใกล้กับสายการบินเดียว แต่ฉันคิดว่านี่เป็นวิธีที่ง่ายที่สุด:

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

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

0

ต่อไปนี้เป็นวิธีการใช้สตรีมและ 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());
}

0

หากคุณต้องการทำสิ่งนี้แบบคงที่คุณสามารถทำสิ่งต่อไปนี้ได้

ตัวอย่างใช้ 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);
                  }}
              );

สิ่งนี้จะสร้างคลาสที่ระบุชื่อใหม่ ไม่แนะนำวิธีการ!
kravemir

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

}
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.