यदि आप Stream.concat और Stream.of के लिए स्थैतिक आयात जोड़ते हैं , तो पहला उदाहरण निम्नानुसार लिखा जा सकता है:
Stream<Foo> stream = concat(stream1, concat(stream2, of(element)));
जेनेरिक नामों के साथ स्थैतिक तरीकों को आयात करने के परिणामस्वरूप कोड हो सकता है जिसे पढ़ना और बनाए रखना मुश्किल हो जाता है ( नाम स्थान प्रदूषण )। इसलिए, अधिक अर्थपूर्ण नामों के साथ अपने स्वयं के स्थिर तरीकों को बनाना बेहतर हो सकता है । हालांकि, प्रदर्शन के लिए मैं इस नाम के साथ रहूंगा।
public static <T> Stream<T> concat(Stream<? extends T> lhs, Stream<? extends T> rhs) {
return Stream.concat(lhs, rhs);
}
public static <T> Stream<T> concat(Stream<? extends T> lhs, T rhs) {
return Stream.concat(lhs, Stream.of(rhs));
}
इन दो स्थिर तरीकों (वैकल्पिक रूप से स्थिर आयात के साथ संयोजन में) के साथ, दो उदाहरण इस प्रकार लिखे जा सकते हैं:
Stream<Foo> stream = concat(stream1, concat(stream2, element));
Stream<Foo> stream = concat(
concat(stream1.filter(x -> x!=0), stream2).filter(x -> x!=1),
element)
.filter(x -> x!=2);
कोड अब काफी छोटा है। हालाँकि, मैं मानता हूँ कि पठनीयता में सुधार नहीं हुआ है। तो मेरे पास एक और उपाय है।
बहुत सारी स्थितियों में, कलेक्टरों का उपयोग धाराओं की कार्यक्षमता को बढ़ाने के लिए किया जा सकता है। नीचे दो कलेक्टरों के साथ , दो उदाहरण इस प्रकार लिखे जा सकते हैं:
Stream<Foo> stream = stream1.collect(concat(stream2)).collect(concat(element));
Stream<Foo> stream = stream1
.filter(x -> x!=0)
.collect(concat(stream2))
.filter(x -> x!=1)
.collect(concat(element))
.filter(x -> x!=2);
आपके इच्छित सिंटैक्स और ऊपर के सिंटैक्स के बीच एकमात्र अंतर यह है कि आपको कॉनकट (...) को कलेक्ट (कॉनकट ) (...) से बदलना होगा । दो स्थिर तरीकों को निम्नानुसार लागू किया जा सकता है (वैकल्पिक रूप से स्थैतिक आयात के साथ संयोजन में उपयोग किया जाता है):
private static <T,A,R,S> Collector<T,?,S> combine(Collector<T,A,R> collector, Function<? super R, ? extends S> function) {
return Collector.of(
collector.supplier(),
collector.accumulator(),
collector.combiner(),
collector.finisher().andThen(function));
}
public static <T> Collector<T,?,Stream<T>> concat(Stream<? extends T> other) {
return combine(Collectors.toList(),
list -> Stream.concat(list.stream(), other));
}
public static <T> Collector<T,?,Stream<T>> concat(T element) {
return concat(Stream.of(element));
}
बेशक इस समाधान के साथ एक खामी है जिसका उल्लेख किया जाना चाहिए। संग्रह एक अंतिम ऑपरेशन है जो धारा के सभी तत्वों का उपभोग करता है। उसके शीर्ष पर, कलेक्टर समापक एक मध्यस्थ ArrayList बनाता है जो हर बार श्रृंखला में उपयोग किया जाता है। दोनों ऑपरेशन आपके कार्यक्रम के व्यवहार पर महत्वपूर्ण प्रभाव डाल सकते हैं। हालाँकि, यदि पठनीयता प्रदर्शन से अधिक महत्वपूर्ण है , तो यह अभी भी एक बहुत ही उपयोगी दृष्टिकोण हो सकता है।