술어에 의해 스트림 제한

(잠재적으로 무한)을 제한하는 Java 8 스트림 작업이 있습니까? Stream첫 번째 요소가 술어와 일치하지 않을 때까지 있습니까?

Java 9에서는 takeWhile아래 예와 같이 10 미만의 모든 숫자를 인쇄 할 수 있습니다 .

IntStream
    .iterate(1, n -> n + 1)
    .takeWhile(n -> n < 10)
    .forEach(System.out::println);

Java 8에는 그러한 작업이 없으므로 일반적인 방법으로 구현하는 가장 좋은 방법은 무엇입니까?

이러한 작업 은 Java 8 로 가능 해야 Stream하지만 효율적으로 수행 할 수있는 것은 아닙니다. 예를 들어, 요소를 순서대로 살펴보아야하므로 이러한 작업을 병렬화 할 필요는 없습니다.

API는이를 수행하는 쉬운 방법을 제공하지 않지만 아마도 가장 간단한 방법은을 수행 하고 "취약"구현을 갖도록 Stream.iterator()랩한 다음 a Iterator로 이동 Spliterator하는 것 Stream입니다. 또는 아마도이 Spliterator구현에서 더 이상 나눌 수는 없지만를 감싸십시오 .

다음의 검증되지 않은 구현의 takeWhileA의는 Spliterator:

static <T> Spliterator<T> takeWhile(
    Spliterator<T> splitr, Predicate<? super T> predicate) {
  return new Spliterators.AbstractSpliterator<T>(splitr.estimateSize(), 0) {
    boolean stillGoing = true;
    @Override public boolean tryAdvance(Consumer<? super T> consumer) {
      if (stillGoing) {
        boolean hadNext = splitr.tryAdvance(elem -> {
          if (predicate.test(elem)) {
            consumer.accept(elem);
          } else {
            stillGoing = false;
          }
        });
        return hadNext && stillGoing;
      }
      return false;
    }
  };
}

static <T> Stream<T> takeWhile(Stream<T> stream, Predicate<? super T> predicate) {
   return StreamSupport.stream(takeWhile(stream.spliterator(), predicate), false);
}

운영 takeWhile및 dropWhileJDK 9. 예제 코드에 추가되었습니다

IntStream
    .iterate(1, n -> n + 1)
    .takeWhile(n -> n < 10)
    .forEach(System.out::println);

JDK 9에서 컴파일하고 실행할 때 예상대로 정확하게 작동합니다.

JDK 9가 릴리스되었습니다. http://jdk.java.net/9/ 에서 다운로드 할 수 있습니다.

allMatch()는 단락 기능이므로 처리를 중지하는 데 사용할 수 있습니다. 가장 큰 단점은 테스트를 두 번 수행해야한다는 것입니다. 한 번 처리해야하는지 확인하고 계속 진행해야하는지 확인해야합니다.

IntStream
    .iterate(1, n -> n + 1)
    .peek(n->{if (n<10) System.out.println(n);})
    .allMatch(n->n < 10);

@StuartMarks에 대한 후속 조치로 . 내 StreamEx 라이브러리에는 takeWhile현재 JDK-9 구현과 호환되는 작업이 있습니다. JDK-9에서 실행될 때 JDK 구현에 위임 할 것 MethodHandle.invokeExact입니다 (실제로 빠릅니다). JDK-8에서 실행될 때는 "polyfill"구현이 사용됩니다. 따라서 내 라이브러리를 사용하면 다음과 같이 문제를 해결할 수 있습니다.

IntStreamEx.iterate(1, n -> n + 1)
           .takeWhile(n -> n < 10)
           .forEach(System.out::println);

takeWhileprotonpack 라이브러리가 제공하는 기능 중 하나입니다 .

Stream<Integer> infiniteInts = Stream.iterate(0, i -> i + 1);
Stream<Integer> finiteInts = StreamUtils.takeWhile(infiniteInts, i -> i < 10);

assertThat(finiteInts.collect(Collectors.toList()),
           hasSize(10));

업데이트 : Java 9에는 Stream이제 takeWhile 이 제공됩니다. 메소드 .

해킹이나 다른 솔루션이 필요하지 않습니다. 그냥 사용하십시오!

나는 이것이 크게 향상 될 수 있다고 확신한다 : (누군가 그것을 스레드로부터 안전하게 만들 수있다)

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

TakeWhile.stream(stream, n -> n < 10000)
         .forEach(n -> System.out.print((n == 0 ? "" + n : "," + n)));

확실한 해킹은 ... 우아하지는 않지만 작동하지만 ~ : D

class TakeWhile<T> implements Iterator<T> {

    private final Iterator<T> iterator;
    private final Predicate<T> predicate;
    private volatile T next;
    private volatile boolean keepGoing = true;

    public TakeWhile(Stream<T> s, Predicate<T> p) {
        this.iterator = s.iterator();
        this.predicate = p;
    }

    @Override
    public boolean hasNext() {
        if (!keepGoing) {
            return false;
        }
        if (next != null) {
            return true;
        }
        if (iterator.hasNext()) {
            next = iterator.next();
            keepGoing = predicate.test(next);
            if (!keepGoing) {
                next = null;
            }
        }
        return next != null;
    }

    @Override
    public T next() {
        if (next == null) {
            if (!hasNext()) {
                throw new NoSuchElementException("Sorry. Nothing for you.");
            }
        }
        T temp = next;
        next = null;
        return temp;
    }

    public static <T> Stream<T> stream(Stream<T> s, Predicate<T> p) {
        TakeWhile tw = new TakeWhile(s, p);
        Spliterator split = Spliterators.spliterator(tw, Integer.MAX_VALUE, Spliterator.ORDERED);
        return StreamSupport.stream(split, false);
    }

}

java8 + rxjava를 사용할 수 있습니다 .

import java.util.stream.IntStream;
import rx.Observable;


// Example 1)
IntStream intStream  = IntStream.iterate(1, n -> n + 1);
Observable.from(() -> intStream.iterator())
    .takeWhile(n ->
          {
                System.out.println(n);
                return n < 10;
          }
    ).subscribe() ;


// Example 2
IntStream intStream  = IntStream.iterate(1, n -> n + 1);
Observable.from(() -> intStream.iterator())
    .takeWhile(n -> n < 10)
    .forEach( n -> System.out.println(n));

실제로 추가 라이브러리없이 또는 Java 9를 사용하여 Java 8에서 두 가지 방법이 있습니다.

콘솔에서 2에서 20까지의 숫자를 인쇄하려면 다음을 수행하십시오.

IntStream.iterate(2, (i) -> i + 2).peek(System.out::println).allMatch(i -> i < 20);

또는

IntStream.iterate(2, (i) -> i + 2).peek(System.out::println).anyMatch(i -> i >= 20);

결과는 두 경우 모두에 있습니다.

2
4
6
8
10
12
14
16
18
20

아직 아무도 언급 하지 않았습니다. 이것이이 게시물의 이유입니다.

이것은 JDK 9 java.util.stream.Stream.takeWhile (Predicate)에서 복사 한 소스입니다. JDK 8로 작업하기위한 약간의 차이.

static <T> Stream<T> takeWhile(Stream<T> stream, Predicate<? super T> p) {
    class Taking extends Spliterators.AbstractSpliterator<T> implements Consumer<T> {
        private static final int CANCEL_CHECK_COUNT = 63;
        private final Spliterator<T> s;
        private int count;
        private T t;
        private final AtomicBoolean cancel = new AtomicBoolean();
        private boolean takeOrDrop = true;

        Taking(Spliterator<T> s) {
            super(s.estimateSize(), s.characteristics() & ~(Spliterator.SIZED | Spliterator.SUBSIZED));
            this.s = s;
        }

        @Override
        public boolean tryAdvance(Consumer<? super T> action) {
            boolean test = true;
            if (takeOrDrop &&               // If can take
                    (count != 0 || !cancel.get()) && // and if not cancelled
                    s.tryAdvance(this) &&   // and if advanced one element
                    (test = p.test(t))) {   // and test on element passes
                action.accept(t);           // then accept element
                return true;
            } else {
                // Taking is finished
                takeOrDrop = false;
                // Cancel all further traversal and splitting operations
                // only if test of element failed (short-circuited)
                if (!test)
                    cancel.set(true);
                return false;
            }
        }

        @Override
        public Comparator<? super T> getComparator() {
            return s.getComparator();
        }

        @Override
        public void accept(T t) {
            count = (count + 1) & CANCEL_CHECK_COUNT;
            this.t = t;
        }

        @Override
        public Spliterator<T> trySplit() {
            return null;
        }
    }
    return StreamSupport.stream(new Taking(stream.spliterator()), stream.isParallel()).onClose(stream::close);
}

다음은 ints에서 수행 된 버전입니다-질문에 나와 있습니다.

용법:

StreamUtil.takeWhile(IntStream.iterate(1, n -> n + 1), n -> n < 10);

StreamUtil의 코드는 다음과 같습니다.

import java.util.PrimitiveIterator;
import java.util.Spliterators;
import java.util.function.IntConsumer;
import java.util.function.IntPredicate;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;

public class StreamUtil
{
    public static IntStream takeWhile(IntStream stream, IntPredicate predicate)
    {
        return StreamSupport.intStream(new PredicateIntSpliterator(stream, predicate), false);
    }

    private static class PredicateIntSpliterator extends Spliterators.AbstractIntSpliterator
    {
        private final PrimitiveIterator.OfInt iterator;
        private final IntPredicate predicate;

        public PredicateIntSpliterator(IntStream stream, IntPredicate predicate)
        {
            super(Long.MAX_VALUE, IMMUTABLE);
            this.iterator = stream.iterator();
            this.predicate = predicate;
        }

        @Override
        public boolean tryAdvance(IntConsumer action)
        {
            if (iterator.hasNext()) {
                int value = iterator.nextInt();
                if (predicate.test(value)) {
                    action.accept(value);
                    return true;
                }
            }

            return false;
        }
    }
}

라이브러리 AbacusUtil로 이동 하십시오 . 원하는 정확한 API를 제공합니다.

IntStream.iterate(1, n -> n + 1).takeWhile(n -> n < 10).forEach(System.out::println);

선언 ： 저는 AbacusUtil의 개발자입니다.

단락 터미널 조작을 제외하고는 스트림을 중단 할 수 없으며, 일부 스트림 값은 값에 관계없이 처리되지 않습니다. 그러나 스트림에서 작업을 피하려면 스트림에 변환 및 필터를 추가하십시오.

import java.util.Objects;

class ThingProcessor
{
    static Thing returnNullOnCondition(Thing thing)
    {    return( (*** is condition met ***)? null : thing);    }

    void processThings(Collection<Thing> thingsCollection)
    {
        thingsCollection.stream()
        *** regular stream processing ***
        .map(ThingProcessor::returnNullOnCondition)
        .filter(Objects::nonNull)
        *** continue stream processing ***
    }
} // class ThingProcessor

그러면 사물이 특정 조건을 충족 할 때 사물 스트림을 null로 변환 한 다음 null을 필터링합니다. 부작용에 기꺼이 만족한다면, 어떤 일이 발생하면 조건 값을 true로 설정할 수 있으므로 그 이후의 모든 일이 그 값에 관계없이 필터링됩니다. 그러나 그렇지 않은 경우에도 처리하지 않으려는 스트림에서 값을 필터링하여 많은 (아직은 아니지만) 처리를 절약 할 수 있습니다.

비슷한 요구 사항조차 있었지만 웹 서비스를 호출하면 실패하면 3 번 다시 시도하십시오. 여러 번의 시도 후에도 실패하면 이메일 알림을 보내십시오. 인터넷 검색을 많이 한 후에 anyMatch()구세주가되었습니다. 내 샘플 코드는 다음과 같습니다. 다음 예제 에서 첫 번째 반복 자체에서 webServiceCall 메소드가 true를 리턴 하면 을 호출 한대로 스트림이 더 이상 반복되지 않습니다 anyMatch(). 나는 이것이 당신이 찾고있는 것이라고 믿습니다.

import java.util.stream.IntStream;

import io.netty.util.internal.ThreadLocalRandom;

class TrialStreamMatch {

public static void main(String[] args) {        
    if(!IntStream.range(1,3).anyMatch(integ -> webServiceCall(integ))){
         //Code for sending email notifications
    }
}

public static boolean webServiceCall(int i){
    //For time being, I have written a code for generating boolean randomly
    //This whole piece needs to be replaced by actual web-service client code
    boolean bool = ThreadLocalRandom.current().nextBoolean();
    System.out.println("Iteration index :: "+i+" bool :: "+bool);

    //Return success status -- true or false
    return bool;
}

수행 될 정확한 양의 회개를 알고 있다면

IntStream
          .iterate(1, n -> n + 1)
          .limit(10)
          .forEach(System.out::println);

    IntStream.iterate(1, n -> n + 1)
    .peek(System.out::println) //it will be executed 9 times
    .filter(n->n>=9)
    .findAny();

피크 대신 mapToObj를 사용하여 최종 객체 또는 메시지를 반환 할 수 있습니다

    IntStream.iterate(1, n -> n + 1)
    .mapToObj(n->{   //it will be executed 9 times
            if(n<9)
                return "";
            return "Loop repeats " + n + " times";});
    .filter(message->!message.isEmpty())
    .findAny()
    .ifPresent(System.out::println);

다른 문제가있는 경우 다른 솔루션이 필요할 수 있지만 현재 문제에 대해서는 다음과 같이 진행하십시오.

IntStream
    .iterate(1, n -> n + 1)
    .limit(10)
    .forEach(System.out::println);

약간 벗어난 주제 일지 모르지만 이것이 우리가 가진 List<T>것입니다.Stream<T> 입니다.

먼저 takeutil 메소드 가 필요합니다 . 이 방법은 첫 번째 n요소를 사용합니다.

static <T> List<T> take(List<T> l, int n) {
    if (n <= 0) {
        return newArrayList();
    } else {
        int takeTo = Math.min(Math.max(n, 0), l.size());
        return l.subList(0, takeTo);
    }
}

그냥 작동합니다 scala.List.take

    assertEquals(newArrayList(1, 2, 3), take(newArrayList(1, 2, 3, 4, 5), 3));
    assertEquals(newArrayList(1, 2, 3), take(newArrayList(1, 2, 3), 5));

    assertEquals(newArrayList(), take(newArrayList(1, 2, 3), -1));
    assertEquals(newArrayList(), take(newArrayList(1, 2, 3), 0));

이제는 다음을 takeWhile기반으로 메소드 를 작성하는 것이 매우 간단합니다 .take

static <T> List<T> takeWhile(List<T> l, Predicate<T> p) {
    return l.stream().
            filter(p.negate()).findFirst(). // find first element when p is false
            map(l::indexOf).        // find the index of that element
            map(i -> take(l, i)).   // take up to the index
            orElse(l);  // return full list if p is true for all elements
}

다음과 같이 작동합니다.

    assertEquals(newArrayList(1, 2, 3), takeWhile(newArrayList(1, 2, 3, 4, 3, 2, 1), i -> i < 4));

이 구현은 목록을 몇 번 부분적으로 반복하지만 추가 O(n^2)작업을 추가하지는 않습니다 . 그것이 허용되기를 바랍니다.

나는 이것을 구현함으로써 또 다른 빠른 해결책을 가지고 있습니다 (실제로 부정확하지만 아이디어를 얻습니다).

public static void main(String[] args) {
    System.out.println(StreamUtil.iterate(1, o -> o + 1).terminateOn(15)
            .map(o -> o.toString()).collect(Collectors.joining(", ")));
}

static interface TerminatedStream<T> {
    Stream<T> terminateOn(T e);
}

static class StreamUtil {
    static <T> TerminatedStream<T> iterate(T seed, UnaryOperator<T> op) {
        return new TerminatedStream<T>() {
            public Stream<T> terminateOn(T e) {
                Builder<T> builder = Stream.<T> builder().add(seed);
                T current = seed;
                while (!current.equals(e)) {
                    current = op.apply(current);
                    builder.add(current);
                }
                return builder.build();
            }
        };
    }
}

Java Stream 라이브러리 만 사용하려는 시도는 다음과 같습니다.

        IntStream.iterate(0, i -> i + 1)
        .filter(n -> {
                if (n < 10) {
                    System.out.println(n);
                    return false;
                } else {
                    return true;
                }
            })
        .findAny();