การดึงรายการจาก java.util.stream.Stream ใน Java 8

ฉันกำลังเล่นกับ lambdas Java 8 เพื่อกรองคอลเลกชันได้อย่างง่ายดาย แต่ฉันไม่พบวิธีรัดกุมในการดึงผลลัพธ์เป็นรายการใหม่ภายในข้อความเดียวกัน นี่คือแนวทางที่รัดกุมที่สุดของฉัน:

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
List<Long> targetLongList = new ArrayList<>();
sourceLongList.stream().filter(l -> l > 100).forEach(targetLongList::add);

ตัวอย่างบนอินเทอร์เน็ตไม่ได้ตอบคำถามของฉันเพราะพวกเขาหยุดโดยไม่สร้างรายการผลลัพธ์ใหม่ จะต้องมีวิธีที่กระชับกว่านี้ ฉันจะคาดหวังว่าStreamชั้นมีวิธีการเป็นtoList(), toSet()...

มีวิธีที่ตัวแปรtargetLongListสามารถกำหนดโดยตรงโดยบรรทัดที่สามหรือไม่?

สิ่งที่คุณทำอาจจะเป็นวิธีที่ง่ายที่สุดที่ให้การเข้าพักของสตรีมลำดับ-มิฉะนั้นคุณจะต้องใส่โทรไปตามลำดับ () forEachก่อน

[แก้ไขในภายหลัง: เหตุผลที่จำเป็นต้องใช้การเรียกไปยังซีเควนเชียล () เป็นรหัสที่มันยืน ( forEach(targetLongList::add)) จะมีชีวิตชีวาถ้ากระแสนั้นขนานกัน ถึงอย่างนั้นมันก็จะไม่บรรลุผลตามที่ตั้งใจไว้เช่นเดียวกับforEachnondeterministic อย่างชัดเจนแม้ในลำดับการประมวลผลองค์ประกอบจะไม่รับประกัน คุณจะต้องใช้forEachOrderedเพื่อให้แน่ใจว่าการสั่งซื้อที่ถูกต้อง ความตั้งใจของผู้ออกแบบ Stream API คือคุณจะใช้ตัวรวบรวมในสถานการณ์นี้ดังต่อไปนี้]

ทางเลือกคือ

targetLongList = sourceLongList.stream()
    .filter(l -> l > 100)
    .collect(Collectors.toList());

Updated:

อีกวิธีคือการใช้Collectors.toList:

targetLongList = 
    sourceLongList.stream().
    filter(l -> l > 100).
    collect(Collectors.toList());

โซลูชันก่อนหน้า:

อีกวิธีคือการใช้Collectors.toCollection:

targetLongList = 
    sourceLongList.stream().
    filter(l -> l > 100).
    collect(Collectors.toCollection(ArrayList::new));

ฉันชอบใช้วิธี util ที่คืนค่าตัวสะสมArrayListเมื่อนั่นคือสิ่งที่ฉันต้องการ

ฉันคิดว่าการแก้ปัญหาโดยใช้Collectors.toCollection(ArrayList::new)เสียงดังเกินไปสำหรับการดำเนินการทั่วไป

ตัวอย่าง:

ArrayList<Long> result = sourceLongList.stream()
    .filter(l -> l > 100)
    .collect(toArrayList());

public static <T> Collector<T, ?, ArrayList<T>> toArrayList() {
    return Collectors.toCollection(ArrayList::new);
}

ด้วยคำตอบนี้ฉันต้องการแสดงให้เห็นถึงความเรียบง่ายในการสร้างและใช้นักสะสมที่กำหนดเองซึ่งโดยทั่วไปมีประโยชน์มาก

ถ้าคุณมีอาร์เรย์ของวิทยาการคุณสามารถใช้คอลเลกชันแบบดั้งเดิมที่มีอยู่ในEclipse คอลเลกชัน

LongList sourceLongList = LongLists.mutable.of(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
LongList targetLongList = sourceLongList.select(l -> l > 100);

หากคุณไม่สามารถเปลี่ยน sourceLongList ได้จากList:

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
List<Long> targetLongList = 
    ListAdapter.adapt(sourceLongList).select(l -> l > 100, new ArrayList<>());

ถ้าคุณต้องการใช้LongStream:

long[] sourceLongs = new long[]{1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L};
LongList targetList = 
    LongStream.of(sourceLongs)
    .filter(l -> l > 100)
    .collect(LongArrayList::new, LongArrayList::add, LongArrayList::addAll);

หมายเหตุ: ฉันเป็นผู้บริจาคให้กับ Eclipse Collections

วิธีที่มีประสิทธิภาพมากขึ้นเล็กน้อย (หลีกเลี่ยงการสร้างรายการแหล่งที่มาและการยกเลิกการทำกล่องอัตโนมัติโดยตัวกรอง):

List<Long> targetLongList = LongStream.of(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L)
    .filter(l -> l > 100)
    .boxed()
    .collect(Collectors.toList());

collect(Collectors.toList());

นี่คือการโทรที่คุณสามารถใช้เพื่อแปลงสตรีมเป็นรายการ

เป็นรูปธรรมมากขึ้น:

    List<String> myList = stream.collect(Collectors.toList()); 

จาก:

https://www.geeksforgeeks.org/collectors-tolist-method-in-java-with-examples/

หากคุณไม่ทราบใช้ห้องสมุดของบุคคลที่ 3 ของ AOL ไซคลอปส์ทำปฏิกิริยา lib (เปิดเผยผมมีส่วนร่วม) มีส่วนขยายสำหรับทุกJDK เก็บประเภทรวมทั้งรายการ อินเตอร์เฟส ListX ขยาย java.util.List และเพิ่มตัวดำเนินการที่มีประโยชน์จำนวนมากรวมถึงตัวกรอง

คุณสามารถเขียน -

ListX<Long> sourceLongList = ListX.of(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
ListX<Long> targetLongList = sourceLongList.filter(l -> l > 100);

ListX สามารถสร้างได้จาก List ที่มีอยู่ (ผ่าน ListX.fromIterable)

มีวิธีการรวบรวมอีกวิธีหนึ่งที่จัดทำโดยคลาส LongStream และในทำนองเดียวกันโดยคลาส IntStream และ DoubleStream ด้วย

<R> R collect(Supplier<R> supplier,
              ObjLongConsumer<R> accumulator,
              BiConsumer<R,R> combiner)

ดำเนินการลดที่ไม่แน่นอนในองค์ประกอบของกระแสนี้ การลดที่ไม่แน่นอนคือการที่ค่าที่ลดลงเป็นคอนเทนเนอร์ผลลัพธ์ที่ไม่แน่นอนเช่น ArrayList และองค์ประกอบจะถูกรวมเข้าด้วยกันโดยการอัพเดตสถานะของผลลัพธ์แทนการแทนที่ผลลัพธ์ สิ่งนี้สร้างผลลัพธ์ที่เทียบเท่ากับ:

R result = supplier.get();
  for (long element : this stream)
       accumulator.accept(result, element);
  return result;

เช่นเดียวกับการลด (ความยาว LongBinaryOperator) การดำเนินการรวบรวมสามารถขนานกันได้โดยไม่ต้องทำการซิงโครไนซ์เพิ่มเติม นี่เป็นการทำงานของเครื่อง

และตอบคำถามของคุณด้วยวิธีการรวบรวมนี้มีดังต่อไปนี้:

    LongStream.of(1L, 2L, 3L, 3L).filter(i -> i > 2)
    .collect(ArrayList::new, (list, value) -> list.add(value)
    , (list1, list2) -> list1.addAll(list2));

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

     LongStream.of(1L, 2L, 3L, 3L).filter(i -> i > 2)
    .collect(ArrayList::new, List::add , List::addAll);

ด้านล่างจะเป็นตัวแปร HashSet:

     LongStream.of(1L, 2L, 3L, 3).filter(i -> i > 2)
     .collect(HashSet::new, HashSet::add, HashSet::addAll);

ตัวแปรที่คล้ายกันของ LinkedList มีลักษณะดังนี้:

     LongStream.of(1L, 2L, 3L, 3L)
     .filter(i -> i > 2)
     .collect(LinkedList::new, LinkedList::add, LinkedList::addAll);

ในกรณีที่มีคน (เช่นฉัน) ออกมามองหาวิธีการจัดการกับวัตถุแทนประเภทดั้งเดิมแล้วใช้ mapToObj()

String ss = "An alternative way is to insert the following VM option before "
        + "the -vmargs option in the Eclipse shortcut properties(edit the "
        + "field Target inside the Shortcut tab):";

List<Character> ll = ss
                        .chars()
                        .mapToObj(c -> new Character((char) c))
                        .collect(Collectors.toList());

System.out.println("List type: " + ll.getClass());
System.out.println("Elem type: " + ll.get(0).getClass());
ll.stream().limit(50).forEach(System.out::print);

พิมพ์:

List type: class java.util.ArrayList
Elem type: class java.lang.Character
An alternative way is to insert the following VM o

String joined = 
                Stream.of(isRead?"read":"", isFlagged?"flagged":"", isActionRequired?"action":"", isHide?"hide":"")
                      .filter(s -> s != null && !s.isEmpty())
                      .collect(Collectors.joining(","));

นี่คือรหัสโดยAbacusUtil

LongStream.of(1, 10, 50, 80, 100, 120, 133, 333).filter(e -> e > 100).toList();

การเปิดเผยข้อมูล: ฉันเป็นผู้พัฒนา AbacusUtil

คุณสามารถเขียนรหัสใหม่ได้ดังนี้:

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
List<Long> targetLongList = sourceLongList.stream().filter(l -> l > 100).collect(Collectors.toList());

ในการรวบรวมในรายการที่ไม่แน่นอน

targetList = sourceList.stream()
                       .filter(i -> i > 100) //apply filter
                       .collect(Collectors.toList());

ในการรวบรวมในรายการที่ไม่เปลี่ยนรูป:

targetList = sourceList.stream()
                       .filter(i -> i > 100) //apply filter
                       .collect(Collectors.toUnmodifiableList());

คำอธิบายของcollectจากJavaDoc :

ดำเนินการลดที่ไม่แน่นอนในองค์ประกอบของสตรีมนี้โดยใช้ Collector นักสะสมสรุปฟังก์ชั่นที่ใช้เป็นอาร์กิวเมนต์ในการรวบรวม (ซัพพลายเออร์, BiConsumer, BiConsumer) เพื่อให้สามารถใช้กลยุทธ์การเก็บรวบรวมและองค์ประกอบของการดำเนินการรวบรวมเช่นการจัดกลุ่มหลายระดับหรือการแบ่งพาร์ติชัน หากสตรีมเป็นแบบขนานและ Collector พร้อมกันและสตรีมไม่ได้เรียงลำดับหรือไม่ได้เรียงลำดับตัวสะสมจะทำการลดพร้อมกัน (ดูรายละเอียดเกี่ยวกับการสะสมพร้อมกัน)

นี่เป็นการทำงานของเครื่อง

เมื่อดำเนินการแบบขนานผลลัพธ์ระหว่างกลางหลายรายการอาจถูกทำให้เป็นอินสแตนซ์เติมและผสานเพื่อรักษาความแยกของโครงสร้างข้อมูลที่ไม่แน่นอน ดังนั้นแม้ว่าจะดำเนินการแบบขนานกับโครงสร้างข้อมูลที่ไม่ปลอดภัย (เช่น ArrayList) ไม่จำเป็นต้องมีการซิงโครไนซ์เพิ่มเติมสำหรับการลดแบบขนาน

หากคุณไม่ได้ใช้parallel()สิ่งนี้จะทำงาน

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);

List<Long> targetLongList =  new ArrayList<Long>();

sourceLongList.stream().peek(i->targetLongList.add(i)).collect(Collectors.toList());