คุณสามารถแบ่งสตรีมเป็นสองสตรีมได้หรือไม่?

ฉันมีชุดข้อมูลที่แสดงโดยกระแส Java 8:

Stream<T> stream = ...;

ฉันสามารถดูวิธีการกรองเพื่อให้ได้ชุดย่อยแบบสุ่ม - ตัวอย่างเช่น

Random r = new Random();
PrimitiveIterator.OfInt coin = r.ints(0, 2).iterator();   
Stream<T> heads = stream.filter((x) -> (coin.nextInt() == 0));

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

(heads, tails) = stream.[some kind of split based on filter]

ขอบคุณสำหรับความเข้าใจใด ๆ

ไม่แน่นอน คุณไม่สามารถรับสองStreamออกจากหนึ่งเดียว สิ่งนี้ไม่สมเหตุสมผล - คุณจะทำซ้ำสิ่งใดสิ่งหนึ่งโดยไม่จำเป็นต้องสร้างอีกแบบในเวลาเดียวกันได้อย่างไร สตรีมสามารถใช้งานได้เพียงครั้งเดียว

อย่างไรก็ตามหากคุณต้องการทิ้งมันลงในรายการหรือบางสิ่งคุณสามารถทำได้

stream.forEach((x) -> ((x == 0) ? heads : tails).add(x));

ตัวสะสมสามารถใช้สำหรับสิ่งนี้

• สำหรับสองประเภทให้ใช้Collectors.partitioningBy()โรงงาน

สิ่งนี้จะสร้างMapจากBooleanถึงListและวางรายการในรายการใดรายการหนึ่งตามรายการPredicateที่อยู่บนพื้นฐานของ

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

นอกจากนี้ไม่จำเป็นต้องมีตัววนซ้ำไม่แม้แต่จะอยู่ในตัวอย่างเฉพาะที่คุณให้ไว้

• การแยกแบบไบนารีมีลักษณะดังนี้:

Random r = new Random();

Map<Boolean, List<String>> groups = stream
    .collect(Collectors.partitioningBy(x -> r.nextBoolean()));

System.out.println(groups.get(false).size());
System.out.println(groups.get(true).size());

• สำหรับหมวดหมู่เพิ่มเติมให้ใช้Collectors.groupingBy()โรงงาน

Map<Object, List<String>> groups = stream
    .collect(Collectors.groupingBy(x -> r.nextInt(3)));
System.out.println(groups.get(0).size());
System.out.println(groups.get(1).size());
System.out.println(groups.get(2).size());

ในกรณีที่กระแสไม่ได้Streamแต่หนึ่งในกระแสดั้งเดิมเช่นIntStreamนี้.collect(Collectors)วิธีการจะไม่สามารถใช้ได้ คุณจะต้องทำด้วยตัวเองโดยไม่ต้องใช้โรงงานเก็บ การใช้งานมีลักษณะดังนี้:

[ตัวอย่าง 2.0 ตั้งแต่ 2020-04-16]

    IntStream    intStream = IntStream.iterate(0, i -> i + 1).limit(100000).parallel();
    IntPredicate predicate = ignored -> r.nextBoolean();

    Map<Boolean, List<Integer>> groups = intStream.collect(
            () -> Map.of(false, new ArrayList<>(100000),
                         true , new ArrayList<>(100000)),
            (map, value) -> map.get(predicate.test(value)).add(value),
            (map1, map2) -> {
                map1.get(false).addAll(map2.get(false));
                map1.get(true ).addAll(map2.get(true ));
            });

ในตัวอย่างนี้ฉันเริ่มต้น ArrayLists ด้วยขนาดเต็มของคอลเลกชันเริ่มต้น (ถ้าเป็นที่รู้จักทั้งหมด) สิ่งนี้จะช่วยป้องกันเหตุการณ์การปรับขนาดแม้ในสถานการณ์ที่เลวร้ายที่สุด แต่อาจจะกินพื้นที่ 2 * N * T (N = จำนวนองค์ประกอบเริ่มต้น, T = จำนวนเธรด) ในการแลกเปลี่ยนพื้นที่เพื่อความเร็วคุณสามารถละทิ้งมันหรือใช้การเดาที่มีการศึกษาดีที่สุดของคุณเช่นจำนวนองค์ประกอบสูงสุดที่คาดไว้ในพาร์ติชันเดียว

ฉันหวังว่าฉันจะไม่รุกรานใครโดยใช้วิธีการของ Java 9 สำหรับเวอร์ชัน Java 8 ให้ดูที่ประวัติการแก้ไข

ฉันสะดุดกับคำถามนี้กับตัวเองและฉันรู้สึกว่าสตรีมที่แยกออกจากกันมีกรณีการใช้งานบางอย่างที่สามารถพิสูจน์ได้ว่าถูกต้อง ฉันเขียนรหัสด้านล่างในฐานะผู้บริโภคเพื่อที่จะไม่ทำอะไรเลย แต่คุณสามารถนำไปใช้กับฟังก์ชั่นและสิ่งอื่นที่คุณอาจเจอ

class PredicateSplitterConsumer<T> implements Consumer<T>
{
  private Predicate<T> predicate;
  private Consumer<T>  positiveConsumer;
  private Consumer<T>  negativeConsumer;

  public PredicateSplitterConsumer(Predicate<T> predicate, Consumer<T> positive, Consumer<T> negative)
  {
    this.predicate = predicate;
    this.positiveConsumer = positive;
    this.negativeConsumer = negative;
  }

  @Override
  public void accept(T t)
  {
    if (predicate.test(t))
    {
      positiveConsumer.accept(t);
    }
    else
    {
      negativeConsumer.accept(t);
    }
  }
}

ตอนนี้การติดตั้งโค้ดของคุณอาจเป็นดังนี้:

personsArray.forEach(
        new PredicateSplitterConsumer<>(
            person -> person.getDateOfBirth().isPresent(),
            person -> System.out.println(person.getName()),
            person -> System.out.println(person.getName() + " does not have Date of birth")));

น่าเสียดายที่สิ่งที่คุณขอนั้นถูกขมวดคิ้วโดยตรงในJavaDoc of Stream :

ควรดำเนินการสตรีมบน (เรียกใช้การดำเนินการสตรีมกลางหรือเทอร์มินัล) เพียงครั้งเดียว กฎนี้ออกตัวอย่างเช่นสตรีม "ทางแยก" ซึ่งแหล่งที่มาเดียวกันฟีดสองท่อหรือมากกว่าหรือหลายเส้นทางของสตรีมเดียวกัน

คุณสามารถหลีกเลี่ยงปัญหานี้ได้โดยใช้peekวิธีการอื่นหรือหากคุณต้องการพฤติกรรมประเภทนั้นอย่างแท้จริง ในกรณีนี้สิ่งที่คุณควรทำคือแทนที่จะพยายามสำรองสองสตรีมจากแหล่งสตรีมดั้งเดิมเดียวกันด้วยตัวกรองฟอร์กกิ้งคุณจะทำซ้ำสตรีมของคุณและกรองรายการที่ซ้ำกันแต่ละรายการอย่างเหมาะสม

อย่างไรก็ตามคุณอาจต้องการพิจารณาใหม่หาก a Streamเป็นโครงสร้างที่เหมาะสมสำหรับกรณีการใช้งานของคุณ

สิ่งนี้ขัดต่อกลไกทั่วไปของสตรีม สมมติว่าคุณสามารถแยกสตรีม S0 เป็น Sa และ Sb ได้ตามที่คุณต้องการ ทำการแสดงการทำงานของเทอร์มินัลใด ๆcount()บน Sa จะต้อง "กิน" องค์ประกอบทั้งหมดใน S0 ดังนั้น Sb จึงสูญเสียแหล่งข้อมูล

ก่อนหน้านี้สตรีมมี tee()วิธีหนึ่งฉันคิดว่าสตรีมซ้ำกับสองวิธี มันถูกลบออกตอนนี้

สตรีมมีวิธีการแอบดู () แต่คุณอาจจะสามารถใช้เพื่อให้บรรลุตามความต้องการของคุณ

ไม่ว่า Collectors.groupingBy()แต่คุณอาจจะสามารถบรรลุสิ่งที่คุณต้องการโดยการกล่าวอ้าง คุณสร้างคอลเลกชันใหม่และจากนั้นสามารถสร้างสตรีมในคอลเลกชันใหม่นั้น

นี่เป็นคำตอบที่แย่ที่สุดที่ฉันสามารถทำได้

import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;

public class Test {

    public static <T, L, R> Pair<L, R> splitStream(Stream<T> inputStream, Predicate<T> predicate,
            Function<Stream<T>, L> trueStreamProcessor, Function<Stream<T>, R> falseStreamProcessor) {

        Map<Boolean, List<T>> partitioned = inputStream.collect(Collectors.partitioningBy(predicate));
        L trueResult = trueStreamProcessor.apply(partitioned.get(Boolean.TRUE).stream());
        R falseResult = falseStreamProcessor.apply(partitioned.get(Boolean.FALSE).stream());

        return new ImmutablePair<L, R>(trueResult, falseResult);
    }

    public static void main(String[] args) {

        Stream<Integer> stream = Stream.iterate(0, n -> n + 1).limit(10);

        Pair<List<Integer>, String> results = splitStream(stream,
                n -> n > 5,
                s -> s.filter(n -> n % 2 == 0).collect(Collectors.toList()),
                s -> s.map(n -> n.toString()).collect(Collectors.joining("|")));

        System.out.println(results);
    }

}

การดำเนินการนี้จะใช้จำนวนเต็มและแยกที่ 5 สำหรับผู้ที่มากกว่า 5 จะกรองเฉพาะตัวเลขและใส่ไว้ในรายการ สำหรับส่วนที่เหลือจะรวมกับ |

เอาท์พุท:

 ([6, 8],0|1|2|3|4|5)

มันไม่เหมาะอย่างยิ่งเมื่อรวบรวมทุกอย่างไว้ในคอลเล็กชั่นตัวกลางทำลายกระแส

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

public class MyProcess {
    /* Return a Predicate that performs a bail-out action on non-matching items. */
    private static <T> Predicate<T> withAltAction(Predicate<T> pred, Consumer<T> altAction) {
    return x -> {
        if (pred.test(x)) {
            return true;
        }
        altAction.accept(x);
        return false;
    };

    /* Example usage in non-trivial pipeline */
    public void processItems(Stream<Item> stream) {
        stream.filter(Objects::nonNull)
              .peek(this::logItem)
              .map(Item::getSubItems)
              .filter(withAltAction(SubItem::isValid,
                                    i -> logError(i, "Invalid")))
              .peek(this::logSubItem)
              .filter(withAltAction(i -> i.size() > 10,
                                    i -> logError(i, "Too large")))
              .map(SubItem::toDisplayItem)
              .forEach(this::display);
    }
}

รุ่นที่สั้นกว่าที่ใช้ลอมบอก

import java.util.function.Consumer;
import java.util.function.Predicate;

import lombok.RequiredArgsConstructor;

/**
 * Forks a Stream using a Predicate into postive and negative outcomes.
 */
@RequiredArgsConstructor
@FieldDefaults(makeFinal = true, level = AccessLevel.PROTECTED)
public class StreamForkerUtil<T> implements Consumer<T> {
    Predicate<T> predicate;
    Consumer<T> positiveConsumer;
    Consumer<T> negativeConsumer;

    @Override
    public void accept(T t) {
        (predicate.test(t) ? positiveConsumer : negativeConsumer).accept(t);
    }
}

เกี่ยวกับ:

Supplier<Stream<Integer>> randomIntsStreamSupplier =
    () -> (new Random()).ints(0, 2).boxed();

Stream<Integer> tails =
    randomIntsStreamSupplier.get().filter(x->x.equals(0));
Stream<Integer> heads =
    randomIntsStreamSupplier.get().filter(x->x.equals(1));