दिलचस्प पोस्ट
मैं एंड्रॉइड स्टूडियो में एक एंड्रॉइड एप्लिकेशन कैसे बना सकता हूं जो Google मैप्स एपीआई वी 2 का उपयोग करता है? क्या मुझे अपनी प्रोजेक्ट फाइल को संस्करण नियंत्रण में रखना चाहिए? मैं एएसपी.नेट एमवीसी में पेजिंग कैसे करूं? एक सूची के लिए ViewModel सत्यापन स्विफ्ट बनाम जावा एफएक्स डेस्कटॉप अनुप्रयोगों के लिए यूटीएफ 8 एन्कोडिंग के साथ सीएसवी के लिए एक्सेल सीएसएस चयनकर्ता "फू जिसमें बार होता है" के लिए? 1 डी में एक 2 डी एक्सेल तालिका "फ्लैटन" या "पतन" कैसे करें? एनवीसीएक्स को बढ़ावा देने के साथ एक CUDA फ़ाइल संकलित करने में विफल क्यों है: भावना? क्या ViewModel के बजाय FormCollection का कोई अच्छा कारण है? संपर्क सूची एंड्रॉइड से केवल ईमेल पता प्राप्त करें अजगर, चर लंबाई के बाद डिफ़ॉल्ट कीवर्ड तर्क तर्कसंगत तर्क कैसे स्क्लिट में छवि को ब्लॉब के रूप में संग्रहीत करना और इसे कैसे प्राप्त करना है? Rewrite मॉड्यूल का उपयोग कर पृष्ठों से .aspx को हटाने? मैं जावा अंतरफलक में एक स्थिर विधि को परिभाषित क्यों नहीं कर सकता?

किसी प्रदीप्ति द्वारा स्ट्रीम को सीमित करें

क्या कोई जावा 8 स्ट्रीम ऑपरेशन है जो कि पहले तत्व तक (असीमित रूप से अनंत) Stream तक सीमित होता है जो कि किसी विधेय को पूरा करने में विफल रहता है? कुछ ऐसा है जो दिखता है ( takeWhile ) नीचे दिए गए उदाहरण में ऑपरेशन takeWhile समय और 10 से कम संख्याओं को मुद्रित करेगा?

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

अगर ऐसा कोई ऑपरेशन नहीं है, तो इसे सामान्य तरीके से लागू करने का सबसे अच्छा तरीका क्या है?

वेब के समाधान से एकत्रित समाधान "किसी प्रदीप्ति द्वारा स्ट्रीम को सीमित करें"

जावा 8 Stream साथ इस तरह के एक ऑपरेशन संभव होना चाहिए, लेकिन यह जरूरी नहीं कि कुशलतापूर्वक किया जा सकता है – उदाहरण के लिए, आप जरूरी नहीं कि इस तरह के ऑपरेशन को समानांतर कर सकते, क्योंकि आपको क्रम में तत्वों को देखना होगा।

एपीआई यह करने का एक आसान तरीका प्रदान नहीं करता है, लेकिन क्या संभवतः सबसे सरल तरीका है Stream.iterator() लेना, Iterator को "ले- Spliterator " कार्यान्वयन के लिए लपेटो, और फिर एक Spliterator वापस Spliterator और फिर एक Stream या – शायद – Spliterator को Spliterator , हालांकि यह वास्तव में इस क्रियान्वयन में अब अलग नहीं हो सकता है

यहां पर एक Spliterator पर ले जाने के समय का एक 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 और dropWhile 9 में जोड़ा गया है। आपका उदाहरण कोड

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

जेडीके 9 के तहत संकलित और चलाए जाने के दौरान आप जितने उम्मीद करते हैं उतना ही व्यवहार करेंगे

जेडीके 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); 

स्टूटार्ट मार्क्स उत्तर के लिए अनुवर्ती के रूप में। मेरे स्ट्रीमएक्स लाइब्रेरी में ले लिया गया है takeWhile वर्तमान takeWhile -9 के कार्यान्वयन के साथ संगत है। जब JDK-9 के तहत चल रहा है तो यह केवल MethodHandle.invokeExact कार्यान्वयन ( MethodHandle.invokeExact माध्यम से जो वास्तव में तेज है) को MethodHandle.invokeExact । जब जेडीके -8 के तहत चल रहा है, तो "पॉलीफिल" कार्यान्वयन का उपयोग किया जाएगा। तो मेरी लाइब्रेरी का उपयोग करते हुए इस समस्या का हल हो सकता है:

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

takeWhile जबकि प्रोटॉनपैक पुस्तकालय द्वारा प्रदान किए गए कार्यों में से एक है।

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

मुझे यकीन है कि इस पर बहुत सुधार किया जा सकता है: (कोई इसे थ्रेड सुरक्षित कर सकता है)

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

सुनिश्चित करने के लिए एक हैक … सुरुचिपूर्ण नहीं है – लेकिन यह काम करता है ~: डी

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

यहां एक संस्करण है जो कि इनट्स पर किया गया है – जैसा कि सवाल में पूछा गया है।

उपयोग:

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

यह स्रोत JDK 9 java.util.stream.Stream.takeWhile (Predicate) से कॉपी किया गया है।

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

मैं इसे लागू करके एक और त्वरित समाधान (जो वास्तव में अशुद्ध है, लेकिन आपको यह विचार मिलता है):

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

पुस्तकालय AbacusUtil प्राप्त करने के लिए जाओ। यह सटीक एपीआई प्रदान करता है जो आप चाहते हैं और अधिक:

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

घोषणा: मैं एबैकस यूटल के डेवलपर हूं।

आप एक लघु-सर्किट टर्मिनल ऑपरेशन को छोड़कर एक स्ट्रीम को रद्द नहीं कर सकते, जो कि उनके मूल्य की परवाह किए बिना कुछ स्ट्रीम मूल्यों को अप्रभावित छोड़ देंगे। लेकिन अगर आप किसी स्ट्रीम पर आपसे परिचालन से बचना चाहते हैं, तो आप स्ट्रीम में ट्रांसफ़ॉर्म और फ़िल्टर जोड़ सकते हैं:

 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 

जब चीजें कुछ स्थिति से मिलती हैं तो वह चीजों की धारा को नल बदल देती है, फिर नल को बाहर निकालता है। यदि आप साइड इफेक्ट्स में शामिल होने को तैयार हैं, तो कुछ चीजों का सामना करने के बाद आप शर्त मान सेट कर सकते हैं, इसलिए सभी चीजें उनके मूल्य के बावजूद फ़िल्टर्ड हो जाएंगी। लेकिन यहां तक ​​कि अगर आप बहुत सारी बचत नहीं कर सकते हैं (यदि बिल्कुल नहीं तो) उस प्रसंस्करण के मूल्यों को फ़िल्टर करके प्रसंस्करण करके जो आप प्रक्रिया नहीं करना चाहते हैं

वास्तव में जावा 8 में बिना किसी अतिरिक्त पुस्तकालयों या जावा 9 का उपयोग करने के दो तरीके हैं।

यदि आप सांत्वना पर 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 

कोई भी अभी तक किसी भी मैच का उल्लेख नहीं किया है। यह इस पोस्ट का कारण है

यहां तक ​​कि मुझे भी इसी तरह की आवश्यकता थी – वेब सेवा शुरू करें, अगर यह असफल हो, तो इसे 3 बार पुन: प्रयास करें यदि ये कई परीक्षणों के बाद भी विफल हो जाता है, तो एक ईमेल अधिसूचना भेजें बहुत कुछ गुगलिंग के बाद, "किसी भी मैच" एक उद्धारकर्ता के रूप में आया। मेरा नमूना कोड निम्नानुसार है निम्न उदाहरण में, यदि "वेबसार्वकॉल" पद्धति पहले रिटर्न में ही सही रिटर्न करती है, तो स्ट्रीम फिर से नहीं चलती क्योंकि हम "किसी भी मैच" को कहते हैं। मेरा मानना ​​है कि आप यही चाहते हैं।

आयात java.util.stream.IntStream;

आयात io.netty.util.internal.ThreadLocalRandom;

क्लास ट्रायलस्ट्रीम मैच {

 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(0, i -> i + 1) .filter(n -> { if (n < 10) { System.out.println(n); return false; } else { return true; } }) .findAny(); 

यदि आपके पास अलग समस्या है, तो अलग समाधान की आवश्यकता हो सकती है, लेकिन आपकी वर्तमान समस्या के लिए, मैं बस इसके साथ जाना होगा:

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