รวบรวมคู่ต่อเนื่องจากสตรีม

ได้รับกระแสเช่น{ 0, 1, 2, 3, 4 },

ฉันจะเปลี่ยนเป็นรูปแบบที่กำหนดอย่างหรูหราที่สุดได้อย่างไร:

{ new Pair(0, 1), new Pair(1, 2), new Pair(2, 3), new Pair(3, 4) }

(สมมติว่าฉันได้กำหนด class Pair ไว้แล้ว)?

แก้ไข:สิ่งนี้ไม่ได้เกี่ยวกับ ints หรือสตรีมดั้งเดิมอย่างเคร่งครัด คำตอบควรเป็นคำตอบทั่วไปสำหรับสตรีมทุกประเภท

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

int[] pairwiseDiffs = IntStreamEx.of(input).pairMap((a, b) -> (b-a)).toArray();

สำหรับสตรีมวัตถุคุณสามารถสร้างวัตถุประเภทอื่นได้ ไลบรารีของฉันไม่มีโครงสร้างข้อมูลใหม่ที่ผู้ใช้มองเห็นได้เช่นPair(ซึ่งเป็นส่วนหนึ่งของแนวคิดไลบรารี) อย่างไรก็ตามหากคุณมีPairคลาสของตัวเองและต้องการใช้งานคุณสามารถดำเนินการดังต่อไปนี้:

Stream<Pair> pairs = IntStreamEx.of(input).boxed().pairMap(Pair::new);

หรือหากคุณมีอยู่แล้วStream:

Stream<Pair> pairs = StreamEx.of(stream).pairMap(Pair::new);

ฟังก์ชั่นนี้จะดำเนินการโดยใช้spliterator ที่กำหนดเอง มีค่าใช้จ่ายค่อนข้างต่ำและสามารถขนานกันได้อย่างสวยงาม แน่นอนว่ามันใช้งานได้กับแหล่งสตรีมใด ๆ ไม่ใช่แค่รายการ / อาร์เรย์การเข้าถึงแบบสุ่มเหมือนโซลูชันอื่น ๆ ในการทดสอบหลายครั้งทำได้ดีมาก นี่คือเกณฑ์มาตรฐาน JMH ที่เราพบค่าอินพุตทั้งหมดที่นำหน้าค่าที่มากกว่าโดยใช้วิธีการต่างๆ (ดูคำถามนี้ )

ไลบรารีสตรีม Java 8 ส่วนใหญ่มุ่งเน้นไปที่การแยกสตรีมออกเป็นชิ้นเล็ก ๆ สำหรับการประมวลผลแบบขนานดังนั้นขั้นตอนไปป์ไลน์ที่มีสถานะค่อนข้าง จำกัด และไม่รองรับการทำสิ่งต่างๆเช่นการรับดัชนีขององค์ประกอบสตรีมปัจจุบันและการเข้าถึงองค์ประกอบสตรีมที่อยู่ติดกัน

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

    IntStream.range(1, arrayList.size())
             .mapToObj(i -> new Pair(arrayList.get(i-1), arrayList.get(i)))
             .forEach(System.out::println);

แน่นอนข้อ จำกัด คืออินพุตไม่สามารถเป็นสตรีมที่ไม่มีที่สิ้นสุดได้ ไปป์ไลน์นี้สามารถทำงานแบบขนานได้

สิ่งนี้ไม่สวยหรูเป็นวิธีแก้ปัญหาที่แฮ็ก แต่ใช้ได้กับสตรีมที่ไม่มีที่สิ้นสุด

Stream<Pair> pairStream = Stream.iterate(0, (i) -> i + 1).map( // natural numbers
    new Function<Integer, Pair>() {
        Integer previous;

        @Override
        public Pair apply(Integer integer) {
            Pair pair = null;
            if (previous != null) pair = new Pair(previous, integer);
            previous = integer;
            return pair;
        }
    }).skip(1); // drop first null

ตอนนี้คุณสามารถ จำกัด สตรีมได้ตามความยาวที่คุณต้องการ

pairStream.limit(1_000_000).forEach(i -> System.out.println(i));

ปล.ฉันหวังว่าจะมีทางออกที่ดีกว่านี้เช่น clojure(partition 2 1 stream)

ฉันได้ติดตั้งตัวแยกกระดาษห่อตัวซึ่งนำทุกnองค์ประกอบTจากตัวแยกต้นฉบับและสร้างList<T>:

public class ConsecutiveSpliterator<T> implements Spliterator<List<T>> {

    private final Spliterator<T> wrappedSpliterator;

    private final int n;

    private final Deque<T> deque;

    private final Consumer<T> dequeConsumer;

    public ConsecutiveSpliterator(Spliterator<T> wrappedSpliterator, int n) {
        this.wrappedSpliterator = wrappedSpliterator;
        this.n = n;
        this.deque = new ArrayDeque<>();
        this.dequeConsumer = deque::addLast;
    }

    @Override
    public boolean tryAdvance(Consumer<? super List<T>> action) {
        deque.pollFirst();
        fillDeque();
        if (deque.size() == n) {
            List<T> list = new ArrayList<>(deque);
            action.accept(list);
            return true;
        } else {
            return false;
        }
    }

    private void fillDeque() {
        while (deque.size() < n && wrappedSpliterator.tryAdvance(dequeConsumer))
            ;
    }

    @Override
    public Spliterator<List<T>> trySplit() {
        return null;
    }

    @Override
    public long estimateSize() {
        return wrappedSpliterator.estimateSize();
    }

    @Override
    public int characteristics() {
        return wrappedSpliterator.characteristics();
    }
}

อาจใช้วิธีต่อไปนี้เพื่อสร้างสตรีมติดต่อกัน:

public <E> Stream<List<E>> consecutiveStream(Stream<E> stream, int n) {
    Spliterator<E> spliterator = stream.spliterator();
    Spliterator<List<E>> wrapper = new ConsecutiveSpliterator<>(spliterator, n);
    return StreamSupport.stream(wrapper, false);
}

ตัวอย่างการใช้งาน:

consecutiveStream(Stream.of(0, 1, 2, 3, 4, 5), 2)
    .map(list -> new Pair(list.get(0), list.get(1)))
    .forEach(System.out::println);

คุณสามารถทำได้ด้วยเมธอด Stream.reduce () (ฉันไม่เห็นคำตอบอื่นใดที่ใช้เทคนิคนี้)

public static <T> List<Pair<T, T>> consecutive(List<T> list) {
    List<Pair<T, T>> pairs = new LinkedList<>();
    list.stream().reduce((a, b) -> {
        pairs.add(new Pair<>(a, b));
        return b;
    });
    return pairs;
}

คุณสามารถทำได้ในcyclops-react (ฉันมีส่วนร่วมในไลบรารีนี้) โดยใช้ตัวดำเนินการเลื่อน

  LazyFutureStream.of( 0, 1, 2, 3, 4 )
                  .sliding(2)
                  .map(Pair::new);

หรือ

   ReactiveSeq.of( 0, 1, 2, 3, 4 )
                  .sliding(2)
                  .map(Pair::new);

สมมติว่าตัวสร้างคู่สามารถยอมรับคอลเล็กชันที่มี 2 องค์ประกอบได้

หากคุณต้องการจัดกลุ่มด้วย 4 และเพิ่มทีละ 2 ที่รองรับด้วย

     ReactiveSeq.rangeLong( 0L,Long.MAX_VALUE)
                .sliding(4,2)
                .forEach(System.out::println);

วิธีการคงที่เท่ากันสำหรับการสร้างมุมมองแบบเลื่อนบน java.util.stream.Stream ยังจัดเตรียมไว้ในคลาสStreamUtils ของ cyclops -stream

       StreamUtils.sliding(Stream.of(1,2,3,4),2)
                  .map(Pair::new);

หมายเหตุ: - สำหรับการดำเนินการแบบเธรดเดียว ReactiveSeq จะเหมาะสมกว่า LazyFutureStream ขยาย ReactiveSeq แต่ส่วนใหญ่มุ่งเน้นสำหรับการใช้งานพร้อมกัน / คู่ขนาน (เป็น Stream of Futures)

LazyFutureStream ขยาย ReactiveSeq ซึ่งขยาย Seq จากjOOλที่ยอดเยี่ยม (ซึ่งขยาย java.util.stream.Stream) ดังนั้นการนำเสนอโซลูชันของ Lukas ก็จะทำงานร่วมกับประเภทสตรีม สำหรับใครก็ตามที่สนใจความแตกต่างหลักระหว่างตัวดำเนินการหน้าต่าง / บานเลื่อนคือการแลกเปลี่ยนพลังงาน / ความซับซ้อนสัมพัทธ์ที่เห็นได้ชัดและความเหมาะสมสำหรับการใช้งานกับสตรีมที่ไม่มีที่สิ้นสุด (การเลื่อนไม่กินกระแส แต่จะบัฟเฟอร์เมื่อมันไหล)

ห้องสมุดโปรตอนแพ็คมีฟังก์ชั่นหน้าต่าง ด้วยคลาส Pair และ Stream คุณสามารถทำได้ดังนี้:

Stream<Integer> st = Stream.iterate(0 , x -> x + 1);
Stream<Pair<Integer, Integer>> pairs = StreamUtils.windowed(st, 2, 1)
                                                  .map(l -> new Pair<>(l.get(0), l.get(1)))
                                                  .moreStreamOps(...);

ตอนนี้pairsสตรีมประกอบด้วย:

(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, ...) and so on

การหาคู่ที่ต่อเนื่องกัน

หากคุณยินดีที่จะใช้ไลบรารีของบุคคลที่สามและไม่จำเป็นต้องใช้การขนานกันjOOλมีฟังก์ชันหน้าต่างรูปแบบ SQL ดังนี้

System.out.println(
Seq.of(0, 1, 2, 3, 4)
   .window()
   .filter(w -> w.lead().isPresent())
   .map(w -> tuple(w.value(), w.lead().get())) // alternatively, use your new Pair() class
   .toList()
);

การให้ผลผลิต

[(0, 1), (1, 2), (2, 3), (3, 4)]

lead()ฟังก์ชั่นการเข้าถึงค่าถัดไปเพื่อสำรวจเส้นทางจากหน้าต่าง

การค้นหาสามเท่าต่อเนื่อง / สี่เท่า / n-tuples

คำถามในความคิดเห็นกำลังขอวิธีแก้ปัญหาที่กว้างขึ้นโดยที่ไม่ควรจับคู่ แต่ควรรวบรวม n-tuples (หรืออาจเป็นรายการ) นี่จึงเป็นแนวทางอื่น:

int n = 3;

System.out.println(
Seq.of(0, 1, 2, 3, 4)
   .window(0, n - 1)
   .filter(w -> w.count() == n)
   .map(w -> w.window().toList())
   .toList()
);

การให้รายชื่อรายการ

[[0, 1, 2], [1, 2, 3], [2, 3, 4]]

หากไม่มีfilter(w -> w.count() == n)ผลลัพธ์ก็จะเป็น

[[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4], [4]]

ข้อจำกัดความรับผิดชอบ: ฉันทำงานให้กับ บริษัท ที่อยู่เบื้องหลังjOOλ

Streams.zip(..) มีอยู่ใน Guavaสำหรับผู้ที่พึ่งพามัน

ตัวอย่าง:

Streams.zip(list.stream(),
            list.stream().skip(1),
            (a, b) -> System.out.printf("%s %s\n", a, b));

เราสามารถใช้RxJava ( ไลบรารีส่วนขยายปฏิกิริยาที่มีประสิทธิภาพมาก)

IntStream intStream  = IntStream.iterate(1, n -> n + 1);

Observable<List<Integer>> pairObservable = Observable.from(intStream::iterator).buffer(2,1);

pairObservable.take(10).forEach(b -> {
            b.forEach(n -> System.out.println(n));
            System.out.println();
        });

ตัวดำเนินการบัฟเฟอร์จะ แปลง Observable ที่ปล่อยไอเท็มเป็น Observable ที่ปล่อยคอลเลคชันบัฟเฟอร์ของไอเท็มเหล่านั้น ..

การดำเนินการนั้นมีสถานะเป็นหลักดังนั้นจึงไม่ใช่สิ่งที่สตรีมมีไว้เพื่อแก้ปัญหา - ดูส่วน "พฤติกรรมไร้สัญชาติ" ในjavadoc :

แนวทางที่ดีที่สุดคือหลีกเลี่ยงพารามิเตอร์พฤติกรรมที่ระบุสถานะเพื่อสตรีมการดำเนินการทั้งหมด

ทางออกหนึ่งที่นี่คือการแนะนำสถานะในสตรีมของคุณผ่านตัวนับภายนอกแม้ว่าจะใช้ได้กับสตรีมแบบต่อเนื่องเท่านั้น

public static void main(String[] args) {
    Stream<String> strings = Stream.of("a", "b", "c", "c");
    AtomicReference<String> previous = new AtomicReference<>();
    List<Pair> collect = strings.map(n -> {
                            String p = previous.getAndSet(n);
                            return p == null ? null : new Pair(p, n);
                        })
                        .filter(p -> p != null)
                        .collect(toList());
    System.out.println(collect);
}


static class Pair<T> {
    private T left, right;
    Pair(T left, T right) { this.left = left; this.right = right; }
    @Override public String toString() { return "{" + left + "," + right + '}'; }
}

ในกรณีของคุณฉันจะเขียน IntFunction ที่กำหนดเองซึ่งจะติดตาม int ล่าสุดที่ผ่านและใช้เพื่อแมป IntStream ดั้งเดิม

import java.util.function.IntFunction;
import java.util.stream.IntStream;

public class PairFunction implements IntFunction<PairFunction.Pair> {

  public static class Pair {

    private final int first;
    private final int second;

    public Pair(int first, int second) {
      this.first = first;
      this.second = second;
    }

    @Override
    public String toString() {
      return "[" + first + "|" + second + "]";
    }
  }

  private int last;
  private boolean first = true;

  @Override
  public Pair apply(int value) {
    Pair pair = !first ? new Pair(last, value) : null;
    last = value;
    first = false;
    return pair;
  }

  public static void main(String[] args) {

    IntStream intStream = IntStream.of(0, 1, 2, 3, 4);
    final PairFunction pairFunction = new PairFunction();
    intStream.mapToObj(pairFunction)
        .filter(p -> p != null) // filter out the null
        .forEach(System.out::println); // display each Pair

  }

}

สำหรับการคำนวณความแตกต่างต่อเนื่องในเวลา (ค่า x) ของอนุกรมเวลาผมใช้stream's collect(...)วิธีการ:

final List< Long > intervals = timeSeries.data().stream()
                    .map( TimeSeries.Datum::x )
                    .collect( DifferenceCollector::new, DifferenceCollector::accept, DifferenceCollector::combine )
                    .intervals();

โดยที่ DifferenceCollector เป็นดังนี้:

public class DifferenceCollector implements LongConsumer
{
    private final List< Long > intervals = new ArrayList<>();
    private Long lastTime;

    @Override
    public void accept( final long time )
    {
        if( Objects.isNull( lastTime ) )
        {
            lastTime = time;
        }
        else
        {
            intervals.add( time - lastTime );
            lastTime = time;
        }
    }

    public void combine( final DifferenceCollector other )
    {
        intervals.addAll( other.intervals );
        lastTime = other.lastTime;
    }

    public List< Long > intervals()
    {
        return intervals;
    }
}

คุณอาจปรับเปลี่ยนสิ่งนี้ให้เหมาะกับความต้องการของคุณได้

ในที่สุดฉันก็หาวิธีหลอก Stream.reduce เพื่อให้สามารถจัดการกับคู่ค่าได้อย่างเรียบร้อย มีกรณีการใช้งานมากมายที่ต้องใช้สิ่งอำนวยความสะดวกนี้ซึ่งไม่ปรากฏตามธรรมชาติใน JDK 8:

public static int ArithGeo(int[] arr) {
    //Geometric
    List<Integer> diffList = new ArrayList<>();
    List<Integer> divList = new ArrayList<>();
    Arrays.stream(arr).reduce((left, right) -> {
        diffList.add(right-left);
        divList.add(right/left);
        return right;
    });
    //Arithmetic
    if(diffList.stream().distinct().count() == 1) {
        return 1;
    }
    //Geometric
    if(divList.stream().distinct().count() == 1) {
        return 2;
    }
    return -1;
}

เคล็ดลับที่ฉันใช้คือการคืนสิทธิ์ คำให้การ.

ทางออกที่สวยงามจะใช้ซิป สิ่งที่ต้องการ:

List<Integer> input = Arrays.asList(0, 1, 2, 3, 4);
Stream<Pair> pairStream = Streams.zip(input.stream(),
                                      input.stream().substream(1),
                                      (a, b) -> new Pair(a, b)
);

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

อีกปัญหาหนึ่ง (ที่ยุ่งยากกว่ามาก) คือ zip พร้อมกับคลาส Streams ทั้งหมดได้ถูกลบออกจาก API เมื่อเร็ว ๆ นี้ โค้ดด้านบนใช้ได้กับb95หรือรุ่นเก่ากว่าเท่านั้น ดังนั้นด้วย JDK ล่าสุดฉันจะบอกว่าไม่มีโซลูชันสไตล์ FP ที่หรูหราและตอนนี้เราสามารถหวังได้ว่าในทางใดทางหนึ่ง zip จะได้รับการแนะนำให้รู้จักกับ API

นี่คือปัญหาที่น่าสนใจ. ความพยายามไฮบริดของฉันต่ำกว่าดีหรือไม่?

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, 3);
    Iterator<Integer> first = list.iterator();
    first.next();
    if (first.hasNext())
        list.stream()
        .skip(1)
        .map(v -> new Pair(first.next(), v))
        .forEach(System.out::println);
}

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

ดังที่คนอื่น ๆ สังเกตเห็นว่ามีอยู่เนื่องจากลักษณะของปัญหาจึงจำเป็นต้องมีสถานะบางอย่าง

ฉันประสบกับปัญหาที่คล้ายกันซึ่งฉันต้องการสิ่งที่เป็นหลักของฟังก์ชัน Oracle SQL LEAD ความพยายามของฉันในการใช้งานที่อยู่ด้านล่าง

/**
 * Stream that pairs each element in the stream with the next subsequent element.
 * The final pair will have only the first item, the second will be null.
 */
<T> Spliterator<Pair<T>> lead(final Stream<T> stream)
{
    final Iterator<T> input = stream.sequential().iterator();

    final Iterable<Pair<T>> iterable = () ->
    {
        return new Iterator<Pair<T>>()
        {
            Optional<T> current = getOptionalNext(input);

            @Override
            public boolean hasNext()
            {
                return current.isPresent();
            }

            @Override
            public Pair<T> next()
            {
                Optional<T> next = getOptionalNext(input);
                final Pair<T> pair = next.isPresent()
                    ? new Pair(current.get(), next.get())
                    : new Pair(current.get(), null);
                current = next;

                return pair;
            }
        };
    };

    return iterable.spliterator();
}

private <T> Optional<T> getOptionalNext(final Iterator<T> iterator)
{
    return iterator.hasNext()
        ? Optional.of(iterator.next())
        : Optional.empty();
}

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

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

public class TwoSubsequentElems {
  public static void main(String[] args) {
    List<Integer> input = new ArrayList<Integer>(asList(0, 1, 2, 3, 4));

    class BoundedQueue<T> extends LinkedList<T> {
      public BoundedQueue<T> save(T curElem) {
        if (size() == 2) { // we need to know only two subsequent elements
          pollLast(); // remove last to keep only requested number of elements
        }

        offerFirst(curElem);

        return this;
      }

      public T getPrevious() {
        return (size() < 2) ? null : getLast();
      }

      public T getCurrent() {
        return (size() == 0) ? null : getFirst();
      }
    }

    BoundedQueue<Integer> streamHistory = new BoundedQueue<Integer>();

    final List<Pair<Integer>> answer = input.stream()
      .map(i -> streamHistory.save(i))
      .filter(e -> e.getPrevious() != null)
      .map(e -> new Pair<Integer>(e.getPrevious(), e.getCurrent()))
      .collect(Collectors.toList());

    answer.forEach(System.out::println);
  }
}

ฉันเห็นด้วยกับ @aepurniet แต่คุณต้องใช้ mapToObj แทน

range(0, 100).mapToObj((i) -> new Pair(i, i+1)).forEach(System.out::println);

รันforลูปที่ตั้งแต่ 0 ถึงlength-1สตรีมของคุณ

for(int i = 0 ; i < stream.length-1 ; i++)
{
    Pair pair = new Pair(stream[i], stream[i+1]);
    // then add your pair to an array
}