java - জাভা 8 মানচিত্র এবং flatMap পদ্ধতি মধ্যে পার্থক্য কি?




java-8 java-stream (15)

জাভা 8 তে, Stream.map এবং Stream.flatMap পদ্ধতিগুলির মধ্যে পার্থক্য কী?


Answers

map এবং flatMap উভয়ই একটি Stream<T> প্রয়োগ করা যেতে পারে এবং তারা উভয়ই একটি Stream<R> ফিরে দেয়। পার্থক্য হল যে map অপারেশন প্রতিটি ইনপুট মানের জন্য একটি আউটপুট মান উত্পন্ন করে, তবে flatMap অপারেশন প্রতিটি ইনপুট মানের জন্য একটি নির্বিচার সংখ্যা (শূন্য বা আরো) মান উত্পন্ন করে।

এই প্রতিটি অপারেশন আর্গুমেন্ট প্রতিফলিত হয়।

map অপারেশন একটি Function নেয়, যা ইনপুট স্ট্রিমের প্রতিটি মানের জন্য বলা হয় এবং আউটপুট প্রবাহে প্রেরিত একটি ফলাফল মান উত্পন্ন করে।

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

flatMap ম্যাপার ফাংশনটির জন্য flatMap Stream.empty() যদি শূন্য মানগুলি পাঠাতে চায়, অথবা Stream.of(a, b, c) কিছু মান ফেরত দিতে চায় তবে এটি ফেরত দিতে হবে। কিন্তু অবশ্যই কোন স্ট্রিম ফিরে যেতে পারে।


একটি পরিষ্কার ধারণা পেতে সম্পূর্ণ পোস্টটি দিয়ে যান, মানচিত্র বনাম ফ্ল্যাটম্যাপ: তালিকা থেকে প্রতিটি শব্দের দৈর্ঘ্য ফিরিয়ে আনতে , আমরা নীচের মতো কিছু করব।

উদাহরণ স্বরূপ:-
একটি তালিকা ["স্ট্যাক", "ওউভভার"] বিবেচনা করুন এবং আমরা ["স্ট্যাকওভার"] এর মত একটি তালিকা ফেরত দেওয়ার চেষ্টা করছি (তালিকা থেকে কেবলমাত্র অনন্য অক্ষরগুলি ফেরত পাঠানো) প্রাথমিকভাবে, আমরা একটি তালিকা ফেরত দিতে নীচের মতো কিছু করব ["স্ট্যাকওভার "] [" স্ট্যাক "," ওউভভার "] থেকে

public class WordMap {
  public static void main(String[] args) {
    List<String> lst = Arrays.asList("STACK","OOOVER");
    lst.stream().map(w->w.split("")).distinct().collect(Collectors.toList());
  }
}

এখানে ইস্যুটি হ'ল, ল্যামডা মানচিত্রের পদ্ধতিতে প্রেরিত প্রতিটি শব্দটির জন্য একটি স্ট্রিং অ্যারে প্রদান করে, তাই মানচিত্র পদ্ধতির দ্বারা ফেরত আসা স্ট্রীমটি আসলে প্রবাহের প্রবাহের মতো, তবে আমাদের যা দরকার তা হলো অক্ষরের একটি প্রবাহ উপস্থাপন করতে স্ট্রীম, নীচের চিত্রটি চিত্রিত করে সমস্যা।

চিত্র একটি:

আপনি মনে করতে পারেন, আমরা flatmap ব্যবহার করে এই সমস্যা সমাধান করতে পারেন,
ঠিক আছে, আসুন দেখি কিভাবে মানচিত্র এবং অ্যারে ব্যবহার করে এটি সমাধান করবেন। স্ট্রীম সবার আগে আপনাকে অ্যারের স্ট্রিমের পরিবর্তে অক্ষরের একটি স্ট্রিম দরকার। Arrays.stream () নামে একটি পদ্ধতি রয়েছে যা একটি অ্যারে নেয় এবং একটি স্ট্রিম তৈরি করে, উদাহরণস্বরূপ:

String[] arrayOfWords = {"STACK", "OOOVVVER"};
Stream<String> streamOfWords = Arrays.stream(arrayOfWords);
streamOfWords.map(s->s.split("")) //Converting word in to array of letters
    .map(Arrays::stream).distinct() //Make array in to separate stream
    .collect(Collectors.toList());

উপরোক্ত এখনও কাজ করে না, কারণ আমরা এখন স্ট্রিমগুলির তালিকা (আরও অবিকল, প্রবাহ>) দিয়ে শেষ করছি, পরিবর্তে, আমাদের প্রথমে প্রতিটি অক্ষরকে আলাদা আলোর অক্ষরে রূপান্তর করতে হবে এবং তারপরে প্রতিটি অ্যারে একটি পৃথক প্রবাহে পরিণত করতে হবে

ফ্ল্যাটম্যাপ ব্যবহার করে আমরা নীচের সমস্যাটি সমাধান করতে সক্ষম হব:

String[] arrayOfWords = {"STACK", "OOOVVVER"};
Stream<String> streamOfWords = Arrays.stream(arrayOfWords);
streamOfWords.map(s->s.split("")) //Converting word in to array of letters
    .flatMap(Arrays::stream).distinct() //flattens each generated stream in to a single stream
    .collect(Collectors.toList());

ফ্ল্যাটম্যাপ প্রতিটি অ্যারের সাথে স্ট্রিমের সাথে নয় তবে সেই প্রবাহের সাথে ম্যাপিং সঞ্চালন করবে। মানচিত্র (অ্যারে :: স্ট্রীম) ব্যবহার করে তৈরি হওয়া প্রতিটি পৃথক স্ট্রিমগুলি একক প্রবাহে মার্জ হয়ে যায়। চিত্র বি ফ্ল্যাটম্যাপ পদ্ধতি ব্যবহার করার প্রভাবকে চিত্রিত করে। চিত্র A. এ চিত্রটি কি করে তা তুলনা করুন

ফ্ল্যাটম্যাপ পদ্ধতিটি আপনাকে অন্য প্রবাহের সাথে একটি প্রবাহের প্রতিটি মান প্রতিস্থাপন করতে দেয় এবং তারপরে সমস্ত উত্পন্ন প্রবাহগুলিকে একক প্রবাহে যোগ দেয়।


মানচিত্র () এবং flatMap ()

  1. map()

শুধু একটি ফাংশন লাম্বদা প্যারামিটার যেখানে T টি উপাদান এবং R টি টি ব্যবহার করে ফিরে আসা উপাদান। শেষে আমরা টাইপ R এর বস্তুর সাথে একটি স্ট্রিম পাবেন। একটি সাধারণ উদাহরণ হতে পারে:

Stream
  .of(1,2,3,4,5)
  .map(myInt -> "preFix_"+myInt)
  .forEach(System.out::println);

এটি কেবল টাইপ Integer 1 থেকে 5 টি উপাদানগুলি নেয়, মানটি "prefix_"+integer_value Integer সহ String থেকে একটি নতুন উপাদান তৈরি করতে প্রতিটি উপাদান ব্যবহার করে এবং এটি প্রিন্ট করে।

  1. flatMap()

এটা জানাতে দরকারী যে flapMap () একটি ফাংশন F<T, R> যেখানে থাকে

  • টি একটি প্রকার যা থেকে একটি স্ট্রিম / সঙ্গে নির্মিত হতে পারে । এটি একটি তালিকা (টি। স্ট্রিম ()), একটি অ্যারে (Arrays.stream (someArray)), ইত্যাদি হতে পারে। যা কোনও স্ট্রীমের সাথে / বা ফর্মের সাথে হতে পারে। নিচের উদাহরণে প্রতিটি দেবীর অনেকগুলি ভাষা আছে, তাই ডিভ। ভাষা একটি তালিকা এবং একটি lambda পরামিতি ব্যবহার করা হবে।

  • R টি ব্যবহার করে নির্মিত স্ট্রিমটি হল স্ট্রিং। আমাদের জানা আছে যে আমাদের অনেকগুলি টি টি রয়েছে, আমরা স্বাভাবিকভাবে R থেকে অনেক স্ট্রিমগুলি পাবেন। টাইপ R থেকে এই সমস্ত স্ট্রিমগুলি এখন টাইপ R থেকে একক 'সমতল' প্রবাহে মিলিত হবে। ।

উদাহরণ

বাচরি তৌফিকের উদাহরণ এখানে তার উত্তর সহজ এবং বোঝার সহজ। শুধু স্বচ্ছতার জন্য, বলুন আমাদের ডেভেলপারদের একটি দল আছে:

dev_team = {dev_1,dev_2,dev_3}

, প্রতিটি বিকাশকারী অনেক ভাষা বুদ্ধিমান সঙ্গে:

dev_1 = {lang_a,lang_b,lang_c},
dev_2 = {lang_d},
dev_2 = {lang_e,lang_f}

প্রতিটি dev এর ভাষা পেতে dev_team এ Stream.map () প্রয়োগ করা হচ্ছে:

dev_team.map(dev -> dev.getLanguages())

আপনি এই গঠন দিতে হবে:

{ 
  {lang_a,lang_b,lang_c},
  {lang_d},
  {lang_e,lang_f}
}

যা মূলত একটি List<List<Languages>> /Object[Languages[]] । তাই খুব সুন্দর, না জাভা 8 মত !!

Stream.flatMap() আপনি উপরে ' Stream.flatMap() ' করতে পারেন কারণ এটি উপরের কাঠামোটি নেয়
এবং এটি {lang_a, lang_b, lang_c, lang_d, lang_e, lang_f} , যা মূলত List<Languages>/Language[]/ect হিসাবে ব্যবহার করা যেতে পারে তে পরিণত করে ...

তাই শেষ আপনার কোড এই মত আরো জ্ঞান করবে:

dev_team
   .stream()    /* {dev_1,dev_2,dev_3} */
   .map(dev -> dev.getLanguages()) /* {{lang_a,...,lang_c},{lang_d}{lang_e,lang_f}}} */
   .flatMap(languages ->  languages.stream()) /* {lang_a,...,lang_d, lang_e, lang_f} */
   .doWhateverWithYourNewStreamHere();

অথবা সহজভাবে:

dev_team
       .stream()    /* {dev_1,dev_2,dev_3} */
       .flatMap(dev -> dev.getLanguages().stream()) /* {lang_a,...,lang_d, lang_e, lang_f} */
       .doWhateverWithYourNewStreamHere();

যখন মানচিত্র ব্যবহার করবেন () এবং flatMap () ব্যবহার করুন :

  • map() ব্যবহার করুন map() যখন আপনার প্রবাহ থেকে টাইপের প্রত্যেকটি উপাদান টি এম / র একটি একক উপাদানতে রূপান্তরিত করা হবে বলে মনে করা হয়। ফলটি হল টাইপের একটি ম্যাপিং (1 সূচনা উপাদান -> 1 শেষ উপাদান) এবং উপাদানগুলির নতুন প্রবাহ টাইপ আর ফিরে আসে।

  • flatMap() ব্যবহার করুন যখন আপনার প্রবাহ থেকে টাইপের প্রত্যেকটি উপাদান টি টি R এর উপাদানগুলির একটি সংগ্রহের মধ্যে রূপান্তরিত / রূপান্তরিত করা হয়। ফলটি টাইপের একটি ম্যাপিং (1 সূচনা উপাদান -> এন শেষ উপাদান) । এই সংগ্রহগুলি তারপর R টির উপাদানগুলির একটি নতুন প্রবাহে মার্জ (বা ফ্ল্যাটড ) করা হয়। উদাহরণস্বরূপ এটি নেস্টেড লুপগুলির প্রতিনিধিত্ব করার জন্য উপযোগী।

প্রাক জাভা 8:

List<Foo> myFoos = new ArrayList<Foo>();
    for(Foo foo: myFoos){
        for(Bar bar:  foo.getMyBars()){
            System.out.println(bar.getMyName());
        }
    }

জাভা পোস্ট 8

myFoos
    .stream()
    .flat(foo -> foo.getMyBars().stream())
    .forEach(bar -> System.out.println(bar.getMyName()));

আমি নিশ্চিত নই যে আমি এটিকে উত্তর দিতে চাই, কিন্তু প্রত্যেক সময় আমি এমন কাউকে মুখোমুখি হতে দেখি যা বুঝতে পারছি না, আমিও একই উদাহরণ ব্যবহার করছি।

আপনি একটি আপেল আছে কল্পনা। একটি map উদাহরণস্বরূপ বা আপ টু এক ম্যাপিং জন্য apple-juice থেকে যে আপেল রূপান্তরিত করা হয়।

একই আপেলটি গ্রহণ করুন এবং কেবল এটি থেকে বীজ পান, যা flatMap করে, বা অনেকের মধ্যে এক, এক আপেল হিসাবে ইনপুট, আউটপুট হিসাবে অনেক বীজ।


আমি আরও ব্যবহারিক দৃষ্টিকোণ পেতে দুটি উদাহরণ দিতে চাই:
প্রথম উদাহরণ মানচিত্র ব্যবহার করে:

@Test
public void convertStringToUpperCaseStreams() {
    List<String> collected = Stream.of("a", "b", "hello") // Stream of String 
            .map(String::toUpperCase) // Returns a stream consisting of the results of applying the given function to the elements of this stream.
            .collect(Collectors.toList());
    assertEquals(asList("A", "B", "HELLO"), collected);
}   

প্রথম উদাহরণে বিশেষ কিছুই নেই, স্ট্রিংকে বড় হাতের অক্ষরে ফিরিয়ে আনার জন্য একটি Function প্রয়োগ করা হয়।

flatMap ব্যবহার দ্বিতীয় উদাহরণ:

@Test
public void testflatMap() throws Exception {
    List<Integer> together = Stream.of(asList(1, 2), asList(3, 4)) // Stream of List<Integer>
            .flatMap(List::stream)
            .map(integer -> integer + 1)
            .collect(Collectors.toList());
    assertEquals(asList(2, 3, 4, 5), together);
}

দ্বিতীয় উদাহরণে, তালিকার একটি প্রবাহ পাস করা হয়। এটা সংখ্যার একটি প্রবাহ না!
একটি রূপান্তর ফাংশন ব্যবহার করা উচিত (মানচিত্রের মাধ্যমে), তারপরে প্রথম স্ট্রিমটিকে অন্য কিছু (ইন্টিগ্রারের প্রবাহ) এ ফ্ল্যাট করা উচিত।
যদি ফ্ল্যাটম্যাপটি সরিয়ে ফেলা হয় তবে নিম্নোক্ত ত্রুটিটি ফেরত দেওয়া হয়: অপারেটর + যুক্তি তালিকা (গুলি) তালিকা, int- এর জন্য অনির্ধারিত।
ইন্টিগ্রারের তালিকাতে +1 প্রয়োগ করা সম্ভব নয়!


এছাড়াও যদি আপনি পরিচিত সাথে ভাল উপমা C # হতে পারে। মূলত সি # জাভা map এবং সি # Select SelectMany জাভা flatMap । সংগ্রহ একই জন্য Kotlin প্রযোজ্য।


আপনি stream.map থেকে পাস ফাংশন একটি বস্তু ফিরে আছে। এর মানে ইনপুট স্ট্রিমের প্রতিটি বস্তু আউটপুট স্ট্রিমের ঠিক এক বস্তুর ফলাফল।

আপনি stream.flatMap পাস ফাংশন প্রতিটি বস্তুর জন্য একটি প্রবাহ ফিরে। এর মানে হল ফাংশন প্রতিটি ইনপুট বস্তুর (কোনটি সহ) এর জন্য কোনও বস্তুর কোনও সংখ্যা ফেরত দিতে পারে। ফলে স্ট্রিম তারপর এক আউটপুট স্ট্রিম সংহত করা হয়।


ওপ্যাকালের নিবন্ধটি ঐচ্ছিক মানচিত্র এবং ফ্ল্যাটম্যাপের মধ্যে এই পার্থক্যটি তুলে ধরেছে:

String version = computer.map(Computer::getSoundcard)
                  .map(Soundcard::getUSB)
                  .map(USB::getVersion)
                  .orElse("UNKNOWN");

দুর্ভাগ্যবশত, এই কোড কম্পাইল না। কেন? পরিবর্তনশীল কম্পিউটার টাইপ Optional<Computer> , তাই এটি মানচিত্র পদ্ধতি কল করতে পুরোপুরি সঠিক। যাইহোক, getSoundcard () টাইপ ঐচ্ছিক টাইপ একটি বস্তু ফেরত। এর অর্থ হল মানচিত্র ক্রিয়াকলাপের ফলাফলটি Optional<Optional<Soundcard>> টাইপের একটি বস্তু। ফলস্বরূপ, getUSB () এর কলটি অবৈধ কারণ বাইরের সর্বাধিক ঐচ্ছিকটি তার মূল্য অন্য একটি বিকল্পের সাথে যুক্ত থাকে, যা অবশ্যই getUSB () পদ্ধতিটিকে সমর্থন করে না।

স্ট্রিমগুলির সাথে, ফ্ল্যাটম্যাপ পদ্ধতিটি একটি ফাংশনকে একটি যুক্তি হিসাবে নেয়, যা অন্য প্রবাহটি প্রদান করে। এই ফাংশন একটি প্রবাহের প্রতিটি উপাদান প্রয়োগ করা হয়, যা প্রবাহগুলির একটি প্রবাহে পরিনত হবে। যাইহোক, ফ্ল্যাটম্যাপটি সেই প্রবাহের সামগ্রীর দ্বারা প্রতিটি উত্পন্ন প্রবাহ প্রতিস্থাপন করার প্রভাব রয়েছে। অন্য কথায়, ফাংশন দ্বারা উত্পন্ন সমস্ত আলাদা স্ট্রিমগুলি একক প্রবাহে মিলিত বা "ফেটে যাওয়া" হয়ে যায়। আমরা এখানে যা চাই তা অনুরূপ কিছু, তবে আমরা একটিতে দুটি স্তরের ঐচ্ছিক "ফ্ল্যাট" করতে চাই

ঐচ্ছিক একটি flatMap পদ্ধতি সমর্থন করে। এর উদ্দেশ্য হল রূপান্তর ফাংশনটিকে ঐচ্ছিক মান (ঠিক মানচিত্র ক্রিয়াকলাপের মতো) এর উপর প্রয়োগ করা এবং তারপরে দুই-স্তরীয় ঐচ্ছিককে একক মধ্যে ফ্ল্যাট করা

সুতরাং, আমাদের কোডটি সঠিক করার জন্য, ফ্ল্যাটম্যাপ ব্যবহার করে নিম্নরূপ এটি পুনঃলিখন করতে হবে:

String version = computer.flatMap(Computer::getSoundcard)
                   .flatMap(Soundcard::getUSB)
                   .map(USB::getVersion)
                   .orElse("UNKNOWN");

প্রথম ফ্ল্যাটম্যাপটি নিশ্চিত করে যে একটি Optional<Soundcard> একটি Optional<Optional<Soundcard>> পরিবর্তে ফেরত পাঠানো হয় এবং দ্বিতীয় ফ্ল্যাটম্যাপ একই উদ্দেশ্যে একটি Optional<USB> ফেরত পাঠায়। মনে রাখবেন যে তৃতীয় কলটি কেবল একটি মানচিত্র () হতে হবে কারণ) getVersion () একটি ঐচ্ছিক বস্তুর পরিবর্তে একটি স্ট্রিং প্রদান করে।

http://www.oracle.com/technetwork/articles/java/java8-optional-2175753.html


স্ট্রিম অপারেশন flatMap এবং map ইনপুট হিসাবে একটি ফাংশন গ্রহণ।

flatMap ফাংশনটি স্ট্রিমের প্রতিটি উপাদানটির জন্য একটি নতুন স্ট্রিম ফেরত প্রত্যাশা করে এবং একটি স্ট্রীম প্রদান করে যা প্রতিটি উপাদানটির জন্য ফাংশন দ্বারা ফেরত আসা স্ট্রিমগুলির সমস্ত উপাদানগুলিকে flatMap । অন্য কথায়, flatMap সাহায্যে উৎস থেকে প্রতিটি উপাদানটির জন্য ফাংশন দ্বারা একাধিক উপাদান তৈরি করা হবে। http://www.zoftino.com/java-stream-examples#flatmap-operation

map ফাংশন প্রত্যাশিত একটি রূপান্তর মান ফিরে এবং রূপান্তর উপাদান ধারণকারী একটি নতুন স্ট্রিম ফিরে। অন্য কথায়, map , উত্স থেকে প্রতিটি উপাদান জন্য, ফাংশন দ্বারা একটি রূপান্তরিত উপাদান তৈরি করা হবে। http://www.zoftino.com/java-stream-examples#map-operation


আমার একটি অনুভূতি আছে যে এখানে বেশিরভাগ উত্তরগুলি সাধারণ সমস্যাটিকে জটিল করে তুলেছে। যদি আপনি ইতিমধ্যে বুঝতে পারেন যে কিভাবে map কাজ করে তা বোঝার পক্ষে মোটামুটি সহজ হওয়া উচিত।

map() ব্যবহার করার সময় আমরা অবাঞ্ছিত নেস্টেড কাঠামোর সাথে শেষ করতে পারি এমন ক্ষেত্রেও, flatMap() পদ্ধতিটি মোড়ানো এড়ানো এটিকে অতিক্রম করতে ডিজাইন করা হয়েছে।

উদাহরণ:

1

List<List<Integer>> result = Stream.of(Arrays.asList(1), Arrays.asList(2, 3))
  .collect(Collectors.toList());

আমরা flatMap ব্যবহার করে নেস্টেড তালিকা থাকার এড়াতে পারেন:

List<Integer> result = Stream.of(Arrays.asList(1), Arrays.asList(2, 3))
  .flatMap(i -> i.stream())
  .collect(Collectors.toList());

2

Optional<Optional<String>> result = Optional.of(42)
      .map(id -> findById(id));

Optional<String> result = Optional.of(42)
      .flatMap(id -> findById(id));

কোথায়:

private Optional<String> findById(Integer id)

একটি মানচিত্রের জন্য আমাদের উপাদানগুলির একটি তালিকা রয়েছে এবং একটি (ফাংশন, অ্যাকশন) f তাই:

[a,b,c] f(x) => [f(a),f(b),f(c)]

এবং ফ্ল্যাট ম্যাপের জন্য আমাদের উপাদান তালিকাগুলির একটি তালিকা রয়েছে এবং আমাদের একটি (ফাংশন, অ্যাকশন) f আছে এবং আমরা ফলাফলটি ফ্ল্যাটড করতে চাই:

[[a,b],[c,d,e]] f(x) =>[f(a),f(b),f(c),f(d),f(e)]

এক লাইন উত্তর: flatMap একটি Collection<Collection<T>> একটি Collection<Collection<T>> flatMap করতে সহায়তা করে । একইভাবে, এটি একটি Optional<Optional<T>> Optional<T> করা হবে।

আপনি দেখতে পারেন, map() কেবলমাত্র:

  • মধ্যবর্তী প্রকার Stream<List<Item>>
  • রিটার্ন টাইপ List<List<Item>>

এবং flatMap() :

  • মধ্যবর্তী প্রকার Stream<Item>
  • ফেরত ধরন List<Item>

নীচের ডান কোড ব্যবহার করে পরীক্ষার ফলাফল :

-------- Without flatMap() -------------------------------
     collect return: [[Laptop, Phone], [Mouse, Keyboard]]

-------- With flatMap() ----------------------------------
     collect return: [Laptop, Phone, Mouse, Keyboard]

কোড ব্যবহার করা হয়েছে :

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

public class Parcel {
  String name;
  List<String> items;

  public Parcel(String name, String... items) {
    this.name = name;
    this.items = Arrays.asList(items);
  }

  public List<String> getItems() {
    return items;
  }

  public static void main(String[] args) {
    Parcel amazon = new Parcel("amazon", "Laptop", "Phone");
    Parcel ebay = new Parcel("ebay", "Mouse", "Keyboard");
    List<Parcel> parcels = Arrays.asList(amazon, ebay);

    System.out.println("-------- Without flatMap() ---------------------------");
    List<List<String>> mapReturn = parcels.stream()
      .map(Parcel::getItems)
      .collect(Collectors.toList());
    System.out.println("\t collect return: " + mapReturn);

    System.out.println("\n-------- With flatMap() ------------------------------");
    List<String> flatMapReturn = parcels.stream()
      .map(Parcel::getItems)
      .flatMap(Collection::stream)
      .collect(Collectors.toList());
    System.out.println("\t collect return: " + flatMapReturn);
  }
}

মানচিত্র: - এই পদ্ধতিটি একটি ফাংশনটিকে একটি আর্গুমেন্ট হিসাবে গ্রহণ করে এবং প্রবাহের সমস্ত উপাদানগুলিতে প্রেরিত ফাংশন প্রয়োগ করে উত্পন্ন ফলাফলগুলি সহ একটি নতুন স্ট্রিম প্রদান করে।

আসুন কল্পনা করি, আমার পূর্ণসংখ্যা মানগুলির তালিকা রয়েছে (1,2,3,4,5) এবং এক ফাংশন ইন্টারফেস যার যুক্তিটি পূর্ণ পূর্ণসংখ্যাটির বর্গক্ষেত্র। (ই -> ই * ই)।

List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> newList = intList.stream().map( e -> e * e ).collect(Collectors.toList());

System.out.println(newList);

আউটপুট: -

[1, 4, 9, 16, 25]

আপনি দেখতে পারেন, একটি আউটপুট একটি নতুন স্ট্রিম যার মান ইনপুট স্ট্রিমের মানগুলির বর্গক্ষেত্র।

[1, 2, 3, 4, 5] -> apply e -> e * e -> [ 1*1, 2*2, 3*3, 4*4, 5*5 ] -> [1, 4, 9, 16, 25 ]

http://codedestine.com/java-8-stream-map-method/

FlatMap: - এই পদ্ধতিটি একটি ফাংশন হিসাবে একটি যুক্তি হিসাবে নেয়, এই ফাংশন একটি ইনপুট যুক্তি হিসাবে একটি প্যারামিটার T গ্রহণ করে এবং একটি ফিরতি মূল্য হিসাবে পরামিতির একটি স্ট্রীম প্রদান করে। যখন এই ফাংশনটি এই প্রবাহের প্রতিটি উপাদানতে প্রয়োগ করা হয়, তখন এটি নতুন মানগুলির একটি প্রবাহ তৈরি করে। প্রতিটি উপাদান দ্বারা উত্পন্ন এই নতুন স্ট্রিমের সমস্ত উপাদানের তারপর একটি নতুন প্রবাহে অনুলিপি করা হয়, যা এই পদ্ধতির ফেরত মান হবে।

চলো চিত্র, আমার ছাত্র বস্তুর একটি তালিকা আছে, যেখানে প্রতিটি ছাত্র একাধিক বিষয় বেছে নিতে পারে।

List<Student> studentList = new ArrayList<Student>();

  studentList.add(new Student("Robert","5st grade", Arrays.asList(new String[]{"history","math","geography"})));
  studentList.add(new Student("Martin","8st grade", Arrays.asList(new String[]{"economics","biology"})));
  studentList.add(new Student("Robert","9st grade", Arrays.asList(new String[]{"science","math"})));

  Set<Student> courses = studentList.stream().flatMap( e -> e.getCourse().stream()).collect(Collectors.toSet());

  System.out.println(courses);

আউটপুট: -

[economics, biology, geography, science, history, math]

আপনি দেখতে পারেন, একটি আউটপুট একটি নতুন স্ট্রিম যার মানগুলি স্ট্রিমগুলির সকল উপাদানগুলির সংগ্রহ যা ইনপুট স্ট্রিমের প্রতিটি উপাদান দ্বারা ফেরত পাঠায়।

[এস 1, এস 2, এস 3] -> [{"ইতিহাস", "গণিত", "ভূগোল"}, {"অর্থনীতি", "জীববিজ্ঞান"}, {"বিজ্ঞান", "গণিত"}]>> অনন্য বিষয়গুলি গ্রহণ করুন - > [অর্থনীতি, জীববিজ্ঞান, ভূগোল, বিজ্ঞান, ইতিহাস, গণিত]

http://codedestine.com/java-8-stream-flatmap-method/


Stream.flatMap , এটির নাম অনুসারে অনুমান করা যেতে পারে, এটি একটি map এবং একটি flat অপারেশন। এর অর্থ হল আপনি প্রথমে আপনার উপাদানের একটি ফাংশন প্রয়োগ করুন এবং তারপরে এটি ফ্ল্যাট করুন। Stream.map শুধুমাত্র স্ট্রিম flattening ছাড়া স্ট্রিম একটি ফাংশন প্রযোজ্য।

কোন প্রবাহকে [ [1,2,3],[4,5,6],[7,8,9] ] তা বোঝার জন্য [ [1,2,3],[4,5,6],[7,8,9] ] এমন একটি কাঠামো বিবেচনা করুন যা "দুই স্তরের"। ফ্ল্যাটিং মানে এটি একটি "এক স্তরের" কাঠামোর রূপান্তর: [ 1,2,3,4,5,6,7,8,9 ]


সংক্ষেপে:

  • getPath() পাথ স্ট্রিংটি পায় যা File অবজেক্টের সাথে তৈরি হয়েছিল এবং এটি আপেক্ষিক বর্তমান ডিরেক্টরি হতে পারে।
  • getAbsolutePath() যদি এটি আপেক্ষিক হয় তবে এটি বর্তমান সম্পর্কিত ডিরেক্টরিটির বিপরীতে সমাধান করার পরে পথের স্ট্রিং পায়, যার ফলে সম্পূর্ণরূপে যোগ্য পথ তৈরি হয়।
  • getCanonicalPath() বর্তমান ডিরেক্টরিটির বিরুদ্ধে কোনও আপেক্ষিক পথ সমাধান করার পরে পথের স্ট্রিং পায় এবং কোনও আপেক্ষিক পথ ( . এবং .. ) সরান এবং কোনও ফাইল সিস্টেম কোনও ফাইলটি ফেরত পাঠায় যা ফাইল সিস্টেমটি ফাইল সিস্টেমকে উল্লেখ করার জন্য ক্যানোনিক্যাল উপায়ে বিবেচনা করে বস্তু যা এটা নির্দেশ করে।

এছাড়াও, এদের প্রত্যেকের একটি ফাইল সমতুল্য যা সংশ্লিষ্ট File বস্তুটি ফেরত দেয়।





java java-8 java-stream