अगर जावा 8 स्ट्रीम खाली है तो कैसे जांचें?

Question 1

अगर कोई Streamखाली नहीं है तो मैं कैसे जांच कर सकता हूं कि वह गैर-टर्मिनल ऑपरेशन के रूप में खाली है या नहीं।

मूल रूप से, मैं नीचे दिए गए कोड के बराबर कुछ देख रहा हूं, लेकिन धारा के बीच में सामग्री के बिना। विशेष रूप से, एक टर्मिनल ऑपरेशन द्वारा स्ट्रीम वास्तव में खपत होने से पहले चेक नहीं होना चाहिए।

public Stream<Thing> getFilteredThings() {
    Stream<Thing> stream = getThings().stream()
                .filter(Thing::isFoo)
                .filter(Thing::isBar);
    return nonEmptyStream(stream, () -> {
        throw new RuntimeException("No foo bar things available")   
    });
}

private static <T> Stream<T> nonEmptyStream(Stream<T> stream, Supplier<T> defaultValue) {
    List<T> list = stream.collect(Collectors.toList());
    if (list.isEmpty()) list.add(defaultValue.get());
    return list.stream();
}

Question 2

यदि आप सीमित समानांतर कैपब्लॉबिलिटी के साथ रह सकते हैं, तो निम्न समाधान काम करेगा:

private static <T> Stream<T> nonEmptyStream(
    Stream<T> stream, Supplier<RuntimeException> e) {

    Spliterator<T> it=stream.spliterator();
    return StreamSupport.stream(new Spliterator<T>() {
        boolean seen;
        public boolean tryAdvance(Consumer<? super T> action) {
            boolean r=it.tryAdvance(action);
            if(!seen && !r) throw e.get();
            seen=true;
            return r;
        }
        public Spliterator<T> trySplit() { return null; }
        public long estimateSize() { return it.estimateSize(); }
        public int characteristics() { return it.characteristics(); }
    }, false);
}

यहाँ कुछ उदाहरण कोड का उपयोग किया गया है:

List<String> l=Arrays.asList("hello", "world");
nonEmptyStream(l.stream(), ()->new RuntimeException("No strings available"))
  .forEach(System.out::println);
nonEmptyStream(l.stream().filter(s->s.startsWith("x")),
               ()->new RuntimeException("No strings available"))
  .forEach(System.out::println);

(कुशल) समानांतर निष्पादन के साथ समस्या यह है कि बंटवारे का समर्थन करने के लिए Spliteratorथ्रेड-सुरक्षित तरीके की आवश्यकता होती है ताकि यह ध्यान दिया जा सके कि किसी भी टुकड़े ने थ्रेड-सुरक्षित तरीके से कोई मूल्य देखा है या नहीं। तब निष्पादित किए गए टुकड़ों में से अंतिम को tryAdvanceयह महसूस करना होगा कि उपयुक्त अपवाद को फेंकने के लिए यह अंतिम है (और यह भी अग्रिम नहीं हो सकता है)। इसलिए मैंने यहाँ विभाजन के लिए समर्थन नहीं जोड़ा।

Question 3

अन्य उत्तर और टिप्पणियाँ सही हैं कि किसी स्ट्रीम की सामग्री की जांच करने के लिए, एक टर्मिनल ऑपरेशन जोड़ना होगा, जिससे स्ट्रीम को "उपभोग" किया जा सके। हालांकि, कोई भी ऐसा कर सकता है और परिणाम को एक धारा में बदल सकता है, बिना स्ट्रीम के पूरी सामग्री को बफर किए बिना। यहाँ कुछ उदाहरण दिए गए हैं:

static <T> Stream<T> throwIfEmpty(Stream<T> stream) {
    Iterator<T> iterator = stream.iterator();
    if (iterator.hasNext()) {
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false);
    } else {
        throw new NoSuchElementException("empty stream");
    }
}

static <T> Stream<T> defaultIfEmpty(Stream<T> stream, Supplier<T> supplier) {
    Iterator<T> iterator = stream.iterator();
    if (iterator.hasNext()) {
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false);
    } else {
        return Stream.of(supplier.get());
    }
}

मूल रूप से उस पर Iteratorकॉल करने के लिए धारा को एक में बदल hasNext()दें, और यदि सही है, तो Iteratorवापस को एक में बदल दें Stream। यह अक्षम है कि धारा पर सभी बाद के संचालन Iterator's hasNext()और next()विधियों के माध्यम से जाएंगे , जिसका अर्थ यह भी है कि धारा को प्रभावी ढंग से क्रमिक रूप से संसाधित किया जाता है (भले ही यह बाद में समानांतर हो)। हालाँकि, यह आपको इसके सभी तत्वों को बफर किए बिना स्ट्रीम का परीक्षण करने की अनुमति देता है।

संभवतः ए के Spliteratorबजाय इसका उपयोग करने का एक तरीका है Iterator। यह संभावित रूप से रिटर्न स्ट्रीम को समान रूप से चलाने सहित इनपुट स्ट्रीम के समान विशेषताओं की अनुमति देता है।

Question 4

यह कई मामलों में पर्याप्त हो सकता है

stream.findAny().isPresent()

Question 5

किसी भी फ़िल्टर को लागू करने के लिए आपको स्ट्रीम पर एक टर्मिनल ऑपरेशन करना होगा। इसलिए जब तक आप इसका उपभोग नहीं करेंगे तब तक आप यह नहीं जान सकते कि यह खाली होगा।

सबसे अच्छा आप एक findAny()टर्मिनल ऑपरेशन के साथ स्ट्रीम को समाप्त कर सकते हैं , जो किसी भी तत्व को खोजने पर बंद हो जाएगा, लेकिन अगर कोई नहीं है, तो इसे खोजने के लिए सभी इनपुट सूची पर पुनरावृति करना होगा।

यह केवल आपकी मदद करेगा यदि इनपुट सूची में कई तत्व हैं, और पहले कुछ में से एक फिल्टर को पास करता है, क्योंकि सूची से केवल एक छोटा सा उपसमूह आपको उपभोग करना होगा, इससे पहले कि आप जानते हैं कि स्ट्रीम खाली नहीं है।

निश्चित रूप से आपको आउटपुट सूची बनाने के लिए एक नई स्ट्रीम बनानी होगी।

Question 6

मुझे लगता है कि एक बूलियन को मैप करने के लिए पर्याप्त होना चाहिए

कोड में यह है:

boolean isEmpty = anyCollection.stream()
    .filter(p -> someFilter(p)) // Add my filter
    .map(p -> Boolean.TRUE) // For each element after filter, map to a TRUE
    .findAny() // Get any TRUE
    .orElse(Boolean.FALSE); // If there is no match return false

Question 7

स्टुअर्ट के विचार के बाद, इसे इस Spliteratorतरह से किया जा सकता है :

static <T> Stream<T> defaultIfEmpty(Stream<T> stream, Stream<T> defaultStream) {
    final Spliterator<T> spliterator = stream.spliterator();
    final AtomicReference<T> reference = new AtomicReference<>();
    if (spliterator.tryAdvance(reference::set)) {
        return Stream.concat(Stream.of(reference.get()), StreamSupport.stream(spliterator, stream.isParallel()));
    } else {
        return defaultStream;
    }
}

मुझे लगता है कि यह समानांतर धाराओं के साथ काम करता है क्योंकि stream.spliterator()ऑपरेशन धारा को समाप्त कर देगा, और फिर आवश्यकता के अनुसार इसका पुनर्निर्माण करेगा

मेरे उपयोग-मामले में मुझे Streamडिफ़ॉल्ट मान के बजाय डिफ़ॉल्ट की आवश्यकता थी । यह बदलना काफी आसान है अगर यह वह नहीं है जो आपको चाहिए