मैं जावा 8 स्ट्रीम को अमरुद इम्युनटेबल कॉलेक्शन में कैसे जमा कर सकता हूं?

Question 1

मैं निम्नलिखित करना चाहूंगा:

List<Integer> list = IntStream.range(0, 7).collect(Collectors.toList());

लेकिन इस तरह से कि परिणामी सूची अमरूद का एक कार्यान्वयन है ImmutableList।

मुझे पता है कि मैं कर सकता था

List<Integer> list = IntStream.range(0, 7).collect(Collectors.toList());
List<Integer> immutableList = ImmutableList.copyOf(list);

लेकिन मैं इसे सीधे इकट्ठा करना चाहूंगा। मैंने कोशिश की

List<Integer> list = IntStream.range(0, 7)
    .collect(Collectors.toCollection(ImmutableList::of));

लेकिन इसने एक अपवाद को फेंक दिया:

java.lang.UnsupportedOperationException पर com.google.common.collect.ImmutableCollection.add (ImmutableCollection.java:96)

Question 2

toImmutableList()एलेक्सिस के स्वीकार किए जाते हैं जवाब में विधि अब में शामिल है अमरूद 21 और रूप में इस्तेमाल किया जा सकता है:

ImmutableList<Integer> list = IntStream.range(0, 7)
    .boxed()
    .collect(ImmutableList.toImmutableList());

संपादित करें: हटाया @Betaसे ImmutableList.toImmutableListमें अक्सर उपयोग एपीआई के साथ रिलीज 27.1 ( 6242bdd )।

Question 3

यह वह जगह है जहाँ collectingAndThenकलेक्टर उपयोगी है:

List<Integer> list = IntStream.range(0, 7).boxed()
                .collect(collectingAndThen(toList(), ImmutableList::copyOf));

यह Listआपके द्वारा निर्मित परिवर्तन पर लागू होता है ; परिणामस्वरूप ImmutableList।

या आप अंत में सीधे एकत्रित कर सकते हैं Builderऔर कॉल कर सकते हैं build():

List<Integer> list = IntStream.range(0, 7)
                .collect(Builder<Integer>::new, Builder<Integer>::add, (builder1, builder2) -> builder1.addAll(builder2.build()))
                .build();

यदि यह विकल्प आपके लिए थोड़ा-सा है और आप इसे कई जगहों पर उपयोग करना चाहते हैं, तो आप अपना खुद का कलेक्टर बना सकते हैं:

class ImmutableListCollector<T> implements Collector<T, Builder<T>, ImmutableList<T>> {
    @Override
    public Supplier<Builder<T>> supplier() {
        return Builder::new;
    }

    @Override
    public BiConsumer<Builder<T>, T> accumulator() {
        return (b, e) -> b.add(e);
    }

    @Override
    public BinaryOperator<Builder<T>> combiner() {
        return (b1, b2) -> b1.addAll(b2.build());
    }

    @Override
    public Function<Builder<T>, ImmutableList<T>> finisher() {
        return Builder::build;
    }

    @Override
    public Set<Characteristics> characteristics() {
        return ImmutableSet.of();
    }
}

और फिर:

List<Integer> list = IntStream.range(0, 7)
                              .boxed()
                              .collect(new ImmutableListCollector<>());

यदि टिप्पणी में लिंक गायब हो जाता है; मेरे दूसरे दृष्टिकोण को एक स्थिर उपयोगिता विधि में परिभाषित किया जा सकता है जो बस उपयोग करता है Collector.of। यह आपकी अपनी Collectorकक्षा बनाने की तुलना में सरल है ।

public static <T> Collector<T, Builder<T>, ImmutableList<T>> toImmutableList() {
    return Collector.of(Builder<T>::new, Builder<T>::add, (l, r) -> l.addAll(r.build()), Builder<T>::build);
}

और उपयोग:

 List<Integer> list = IntStream.range(0, 7)
                               .boxed()
                               .collect(toImmutableList());

Question 4

हालांकि मेरे सवाल का सीधा जवाब नहीं है (यह कलेक्टरों का उपयोग नहीं करता है), यह एक बहुत ही सुंदर दृष्टिकोण है जो मध्यवर्ती संग्रहों का उपयोग नहीं करता है:

Stream<Integer> stream = IntStream.range(0, 7).boxed();
List<Integer> list = ImmutableList.copyOf(stream.iterator());

स्रोत ।

Question 5

BTW: JDK 10 के बाद से यह शुद्ध जावा में किया जा सकता है:

List<Integer> list = IntStream.range(0, 7)
    .collect(Collectors.toUnmodifiableList());

भी toUnmodifiableSetऔर toUnmodifiableMapउपलब्ध है।

कलेक्टर के अंदर के माध्यम से किया गया था List.of(list.toArray())

Question 6

FYI करें, जावा 8 के बिना अमरूद में ऐसा करने का एक उचित तरीका है:

ImmutableSortedSet<Integer> set = ContiguousSet.create(
    Range.closedOpen(0, 7), DiscreteDomain.integers());
ImmutableList<Integer> list = set.asList();

यदि आपको वास्तव में Listशब्दार्थ की आवश्यकता नहीं है और बस एक का उपयोग कर सकते हैं NavigableSet, तो यह और भी बेहतर है क्योंकि ContiguousSetइसमें वास्तव में सभी तत्वों को संग्रहीत नहीं करना है (बस Rangeऔर DiscreteDomain)।