java - মওয - জাভার ব্যবহার




দুটি জাভা 8 স্ট্রীম, বা একটি প্রবাহে অতিরিক্ত উপাদান যোগ করা হচ্ছে (6)

আমি এই মত স্ট্রিম বা অতিরিক্ত উপাদান যোগ করতে পারেন:

Stream stream = Stream.concat(stream1, Stream.concat(stream2, Stream.of(element));

এবং আমি নতুন স্টাফ যোগ করতে পারি যেমনটি আমি যেতে চাই:

Stream stream = Stream.concat(
                       Stream.concat(
                              stream1.filter(x -> x!=0), stream2)
                              .filter(x -> x!=1),
                                  Stream.of(element))
                                  .filter(x -> x!=2);

কিন্তু এই কুৎসিত, কারণ concat স্ট্যাটিক। concat একটি উদাহরণ পদ্ধতি ছিল, উপরের উদাহরণ পড়তে অনেক সহজ হবে:

 Stream stream = stream1.concat(stream2).concat(element);

এবং

 Stream stream = stream1
                 .filter(x -> x!=0)
                 .concat(stream2)
                 .filter(x -> x!=1)
                 .concat(element)
                 .filter(x -> x!=2);

আমার প্রশ্ন হল:

1) concat স্ট্যাটিক কেন কোন ভাল কারণ আছে? অথবা আমি অনুপস্থিত কিছু সমতুল্য উদাহরণ পদ্ধতি আছে?

2) কোন ক্ষেত্রে, এই কাজ করার একটি ভাল উপায় আছে?


আপনি গুওয়া Streams ব্যবহার করতে পারেন . concat(Stream<? extends T>... streams) পদ্ধতি, যা স্ট্যাটিক আমদানিগুলির সাথে খুব ছোট হবে:

Stream stream = concat(stream1, stream2, of(element));

আপনি যদি 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));
}

অবশ্যই উল্লেখ করা উচিত যে এই সমাধান সঙ্গে একটি ত্রুটি আছে। সংগ্রহ স্ট্রিমের সব উপাদান খায় যে একটি চূড়ান্ত অপারেশন। এর উপরে, সংগ্রাহক কনট্যাটটি শৃঙ্খলে ব্যবহৃত প্রতিটি সময় একটি মধ্যবর্তী অ্যারেলিস্ট তৈরি করে। উভয় অপারেশন আপনার প্রোগ্রামের আচরণের উপর একটি উল্লেখযোগ্য প্রভাব হতে পারে। যাইহোক, যদি পঠনযোগ্যতা কর্মক্ষমতা চেয়ে আরো গুরুত্বপূর্ণ, এটি এখনও একটি খুব সহায়ক পদ্ধতি হতে পারে।


কিভাবে আপনার নিজের কনক্যাট পদ্ধতি লেখার?

public static Stream<T> concat(Stream<? extends T> a, 
                               Stream<? extends T> b, 
                               Stream<? extends T> args)
{
    Stream<T> concatenated = Stream.concat(a, b);
    for (Stream<T> stream : args)
    {
        concatenated = Stream.concat(concatenated, stream);
    }
    return concatenated;
}

এটি অন্তত আপনার প্রথম উদাহরণ অনেক বেশি পঠনযোগ্য করে তোলে।


তৃতীয় পক্ষের লাইব্রেরি cyclops-react ব্যবহার করে আপনি যদি কিছু মনে করেন না cyclops-react একটি বর্ধিত প্রবাহের ধরন থাকে যা আপনাকে এটিকে যোগ / পূর্ববর্তী অপারেটরগুলির মাধ্যমে ঠিক করতে দেয়।

ব্যক্তিগত মান, অ্যারে, iterables, স্ট্রিম বা প্রতিক্রিয়াশীল-স্ট্রিম প্রকাশক যোগ করা এবং উদাহরণ পদ্ধতি হিসাবে preched যাবে।

Stream stream = ReactiveSeq.of(1,2)
                           .filter(x -> x!=0)
                           .append(ReactiveSeq.of(3,4))
                           .filter(x -> x!=1)
                           .append(5)
                           .filter(x -> x!=2);

[ডিসক্লোজার আমি সাইক্লপসের প্রধান বিকাশকারী - প্রতিক্রিয়া]


দুর্ভাগ্যবশত এই উত্তরটি সম্ভবত সামান্য বা কোনও সাহায্যের পক্ষে নয়, তবে আমি এই নকশাটির কারণ খুঁজে পেতে পারি কিনা তা দেখতে জাভা ল্যাম্বা মেলিং লিস্টের ফরেনসিক বিশ্লেষণ করেছি। এই আমি খুঁজে পাওয়া যায় নি।

প্রারম্ভে Stream.concat (প্রবাহ) জন্য একটি উদাহরণ পদ্ধতি ছিল।

মেইলিং লিস্টে আমি স্পষ্টভাবে দেখতে পাচ্ছি যে পদ্ধতিটি মূলত একটি ইনস্ট্যান্স পদ্ধতি হিসাবে প্রয়োগ করা হয়েছিল, আপনি পল স্যান্ডোজ দ্বারা এই থ্রেডে পড়তে পারেন, কনক্যাট অপারেশন সম্পর্কে।

এর মধ্যে তারা সেই বিষয়গুলি নিয়ে আলোচনা করে যা সেই ক্ষেত্রে থেকে প্রবাহিত হতে পারে যার মধ্যে প্রবাহটি অসীম হতে পারে এবং সেই ক্ষেত্রে কোন সংযোজন মানে কী হতে পারে, তবে আমি মনে করি না যে এটি সংশোধন করার কারণ ছিল।

আপনি এই অন্যান্য থ্রেডটিতে দেখেন যে, জেডিকে 8 এর কিছু প্রাথমিক ব্যবহারকারী নকল আর্গুমেন্টগুলির সাথে ব্যবহৃত যখন কনট্যাট ইনস্ট্যান্স পদ্ধতির আচরণ সম্পর্কে প্রশ্ন করেছে।

এই অন্যান্য থ্রেড প্রকাশ করে যে, কনট্যাট পদ্ধতির নকশা আলোচনার অধীনে ছিল।

Streams.concat থেকে Refactored (স্ট্রিম, প্রবাহ)

কিন্তু কোন ব্যাখ্যা ছাড়া, হঠাৎ, পদ্ধতি স্ট্যাটিক পদ্ধতিতে পরিবর্তিত হয়, আপনি স্ট্রিম সংমিশ্রণ সম্পর্কে এই থ্রেডে দেখতে পারেন। এটি সম্ভবত একমাত্র মেইল ​​থ্রেড যা এই পরিবর্তনের বিষয়ে কিছুটা হালকা করে ফেলে, তবে আমার জন্য পুনঃসংযোগের কারণ নির্ধারণ করার জন্য এটি যথেষ্ট পরিষ্কার ছিল না। কিন্তু তারা দেখতে পারে যে তারা এমন একটি concat যা তারা Stream এবং হেল্পার Stream Streams concat পদ্ধতিটি সরানোর পরামর্শ দেয়।

Stream.concat থেকে Refactored (স্ট্রিম, প্রবাহ)

পরে, এটি Streams থেকে Stream আবার সরানো হয় , কিন্তু এখনো আবার, যে জন্য কোন ব্যাখ্যা।

সুতরাং, নিচের লাইনটি, নকশাটির কারণটি আমার জন্য পুরোপুরি স্পষ্ট নয় এবং আমি একটি ভাল ব্যাখ্যা খুঁজে পাচ্ছি না। আমি এখনও আপনি মেইলিং তালিকা প্রশ্ন জিজ্ঞাসা করতে পারে অনুমান।

প্রবাহ Concatenation জন্য কিছু বিকল্প

মাইকেল হিকসন এই অন্যান্য থ্রেড আলোচনা / একত্রিত স্ট্রিমস অন্য উপায় সম্পর্কে জিজ্ঞাসা / আলোচনা

  1. দুটি স্ট্রিম একত্রিত করার জন্য, আমাকে এটা করা উচিত:

    Stream.concat(s1, s2)

    এটা না:

    Stream.of(s1, s2).flatMap(x -> x)

    ঠিক আছে?

  2. আরো দুই স্ট্রিম একত্রিত করার জন্য, আমি এটা করা উচিত:

    Stream.of(s1, s2, s3, ...).flatMap(x -> x)

    এটা না:

    Stream.of(s1, s2, s3, ...).reduce(Stream.empty(), Stream::concat)

    ঠিক আছে?


শুধু কর:

Stream.of(stream1, stream2, Stream.of(element)).flatMap(identity());

যেখানে identity() হল Function.identity() এর স্ট্যাটিক ইমপোর্ট।

এক প্রবাহে একাধিক প্রবাহকে একত্রিত করা একটি প্রবাহকে সমতলকরণের মতো একই।

যাইহোক, দুর্ভাগ্যবশত, কিছু কারণে Stream flatMap() পদ্ধতি নেই, তাই আপনাকে পরিচয় ফাংশনের সাথে flatMap() ব্যবহার করতে হবে।





java-stream