Java 8では、Stream.map()とStream.flatMap()メソッドの違いは何ですか？

mapとflatMapは両方に適用できStream<T>、両方ともを返しますStream<R>。違いは、map演算は各入力値に対して1つの出力値をflatMap生成するのに対し、演算は各入力値に対して任意の数（ゼロ以上）の値を生成することです。

これは、各操作の引数に反映されます。

map動作は、かかるFunction入力ストリーム内の各値のために呼び出され、出力ストリームに送信される1つの結果値を生成します。

flatMap操作は、概念的に一つの値を消費した値の任意の数を生成したい機能を取ります。ただし、Javaでは、メソッドはゼロまたは1つの値しか返せないため、メソッドが任意の数の値を返すのは面倒です。のマッパー関数flatMapが値を取り、配列またはListその後、出力に送信されます。これがストリームライブラリである場合、任意の数の戻り値を表す特に適切な方法は、マッパー関数自体がストリームを返すことです！マッパーによって返されたストリームからの値は、ストリームから排出され、出力ストリームに渡されます。マッパー関数の各呼び出しによって返される値の「塊」は、出力ストリームではまったく区別されないため、出力は「平坦化」されているといいます。

典型的な使用法は、マッパー関数が0の値を送信したい場合flatMapに返すStream.empty()か、またはStream.of(a, b, c)複数の値を返したい場合などです。ただし、もちろん、任意のストリームを返すことができます。

Stream.flatMapは、その名前から推測できるように、mapとflat操作の組み合わせです。つまり、まず要素に関数を適用し、次にそれを平坦化します。Stream.map関数をストリームに適用するだけで、ストリームをフラット化しません。

ストリームのフラット化の内容を理解するために、[ [1,2,3],[4,5,6],[7,8,9] ]「2つのレベル」のような構造を考えます。これを平坦化するということは、「1レベル」の構造に変換することを意味します[ 1,2,3,4,5,6,7,8,9 ]。

より実用的な観点を得るために2つの例を挙げたいと思います：
マップを使用する最初の例：

@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);
}   

最初の例では特別なことは何もありません。a は大文字のFunctionを返すためStringに適用されます。

を使用する2番目の例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);
}

2番目の例では、リストのストリームが渡されます。整数のストリームではありません！
変換関数を（マップを介して）使用する必要がある場合、最初にストリームを別の何か（ストリームの整数）にフラット化する必要があります。
flatMapが削除されると、次のエラーが返されます。演算子+は、引数の型リスト（int）に対して未定義です。
整数のリストに+ 1を適用することはできません！

明確なアイデアを得るために、投稿を完全に読んでください。

マップとflatMap：

リストから各単語の長さを返すには、以下のようにします。

下記のショートバージョン

以下に示す2つのリストを収集すると

フラットマップなし => [1,2]、[1,1] => [[1,2]、[1,1]]ここでは2つのリストがリスト内に配置されているため、出力はリストを含むリストになります

フラット地図 => [1,2]、[1,1] => [1,2,1,1]ここでは、2つのリストが平坦化され、出力要素のみを含むリストになるようだけ値は、リストに配置されます

基本的には、すべてのオブジェクトを1つにマージします

##詳細なバージョンを以下に示します：-

例：-
リスト["STACK"、 "OOOVVVER"]を考えて、["STACKOVER"]のようなリストを返そうとしている（そのリストから一意の文字のみを返す）最初は、以下のようなことをして、リスト [「STACKOVER」] から [「STACK」、「OOOVVVER」]

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());
  }
}

ここでの問題は、mapメソッドに渡されたLambdaが各単語のString配列を返すため、mapメソッドから返されるストリームは実際にはStream型ですが、文字のストリームを表すにはStreamが必要です。下の画像は、問題。

図A：

この問題はflatmapを使用して解決できます。OK、mapとArrays.stream
を使用してこれを解決する方法を見てみましょう。 まず、配列のストリームではなく文字のストリームが必要です。たとえば、配列を取得してストリームを生成する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());

ストリームのリスト（より正確には、Stream>）になるため、上記はまだ機能しません。代わりに、最初に各単語を個々の文字の配列に変換してから、各配列を個別のストリームにする必要があります。

flatMapを使用すると、この問題を次のように修正できるはずです。

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());

flatMapは、ストリームではなく、そのストリームのコンテンツを使用して各配列のマッピングを実行します。map（Arrays :: stream）の使用中に生成される個々のストリームはすべて、単一のストリームにマージされます。図Bは、flatMapメソッドを使用した効果を示しています。図Aのマップの機能と比較してください。 図B

flatMapメソッドを使用すると、ストリームの各値を別のストリームに置き換え、生成されたすべてのストリームを1つのストリームに結合できます。

1行の答え：flatMapaをに平坦化するのCollection<Collection<T>>に役立ちますCollection<T>。同様に、Optional<Optional<T>>into もフラット化しOptional<T>ます。

あなたが、見ることができるようにmap()のみ：

• 中間タイプは Stream<List<Item>>
• 戻り値の型は List<List<Item>>

とflatMap()：

• 中間タイプは Stream<Item>
• 戻り値の型は List<Item>

これは、すぐ下で使用されているコードのテスト結果です。

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

-------- With flatMap() ----------------------------------
     collect() returns: [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() returns: " + 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() returns: " + flatMapReturn);
  }
}

渡す関数stream.mapは、1つのオブジェクトを返す必要があります。つまり、入力ストリーム内の各オブジェクトは、出力ストリーム内で1つのオブジェクトになります。

渡す関数stream.flatMapは、各オブジェクトのストリームを返します。つまり、関数は各入力オブジェクトに対してオブジェクトをいくつでも返すことができます（なしを含む）。結果のストリームは、1つの出力ストリームに連結されます。

Mapの場合、要素のリストと（関数、アクション）f soがあります。

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

また、フラットマップの場合は、要素リストのリストがあり、（function、action）fがあり、結果をフラット化する必要があります。

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

ここでのほとんどの答えは、単純な問題を複雑にしています。あなたがすでにどのように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)

オラクルのオプションに関する記事は、マップとフラットマップのこの違いを強調しています。

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

残念ながら、このコードはコンパイルできません。どうして？変数computerの型Optional<Computer>はなので、mapメソッドを呼び出すことは完全に正しいことです。ただし、getSoundcard（）はOptionalタイプのオブジェクトを返します。これは、マップ操作の結果がタイプのオブジェクトであることを意味しますOptional<Optional<Soundcard>>。その結果、最も外側のOptionalには別のOptionalが値として含まれているため、getUSB（）メソッドはサポートされていないため、getUSB（）の呼び出しは無効です。

ストリームの場合、flatMapメソッドは関数を引数として取り、別のストリームを返します。この関数は、ストリームの各要素に適用され、ストリームのストリームになります。ただし、flatMapには、生成された各ストリームをそのストリームのコンテンツで置き換える効果があります。つまり、関数によって生成されるすべての個別のストリームは、1つのストリームに融合または「フラット化」されます。ここで必要なのは似たようなものですが、2レベルのOptionalを1つに「フラット化」します。

オプションは、flatMapメソッドもサポートします。その目的は、（map操作と同様に）Optionalの値に変換関数を適用し、結果の2レベルのOptionalを1つにフラット化することです。

したがって、コードを正しくするために、flatMapを使用して次のように書き直す必要があります。

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

最初のflatMapはのOptional<Soundcard>代わりにが返されることを保証しOptional<Optional<Soundcard>>、2番目のflatMapはを返すために同じ目的を達成しOptional<USB>ます。getVersion（）はOptionalオブジェクトではなくStringを返すため、3番目の呼び出しはmap（）である必要があることに注意してください。

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

私はこれに答えるつもりかどうかは定かではありませんが、これを理解していない誰かに直面するたびに、私は同じ例を使用します。

あなたがリンゴを持っていると想像してください。A mapは、そのリンゴをapple-juice、たとえば、1対1のマッピングに変換しています。

同じリンゴを取り、種子だけを取り出します。flatMapつまり、1対多、1つのリンゴを入力として、多くのシードを出力として使用します。

map（）およびflatMap（）

1. map()

関数はラムダパラメータを取り、Tは要素、RはTを使用して作成された戻り要素を受け取ります。最後に、タイプRのオブジェクトを持つストリームが作成されます。簡単な例は次のとおりです。

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

それは単純にTypeの要素1から5を取りInteger、各要素を使用してString、値"prefix_"+integer_valueを持つタイプから新しい要素を構築し、それを出力します。

2. flatMap()

flatMap（）関数取ることを知っておくと便利ですF<T, R>どこに

• Tは、Streamをから/で構築できる型です。これは、リスト（T.stream（））、配列（Arrays.stream（someArray））など、Streamの元となるフォーム、またはフォームの元となるものであれば何でもかまいません。以下の例では、各開発者には多くの言語があるため、開発者です。言語はリストであり、ラムダパラメータを使用します。

• Rは、Tを使用して構築される結果のストリームです。Tのインスタンスが多いことを知っていると、当然、Rからのストリームも多くなります。タイプRからのこれらすべてのストリームは、タイプRからの単一の「フラット」ストリームに結合されます。。

例

Bachiri Taoufiqの例は、 ここでの答えがシンプルで理解しやすいと考えています。わかりやすくするために、開発者のチームがあるとします。

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}

適用 Stream.mapを（）各DEVの言語を取得するにはdev_teamに：

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

この構造を与えるでしょう：

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

これは基本的にList<List<Languages>> /Object[Languages[]]です。それほどきれいではなく、Java8ライクでもありません。

でStream.flatMap()、それは上記の構造とるよう、あなたの事を「フラット化」することができます
し、に変わり、それを{lang_a, lang_b, lang_c, lang_d, lang_e, lang_f}基本的に使用することができ、List<Languages>/Language[]/etc...

したがって、最終的には、コードは次のように理解しやすくなります。

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();

map（）とflatMap（）を使用する場合：

• map()ストリームのタイプTの各要素がタイプRの単一の要素にマップ/変換されることになっている場合に使用します。結果は、タイプ（1開始要素-> 1終了要素）とタイプRの要素の新しいストリームのマッピングになります。返されます。

• flatMap()ストリームからのタイプTの各要素がタイプRの要素のコレクションにマップ/変換されることになっている場合に使用します。結果はタイプ（1開始要素-> n終了要素）のマッピングになります。これらのコレクションは、R型の要素の新しいストリームにマージ（またはフラット化）されます。これは、たとえばネストされたループを表す場合に役立ちます。

Java 8より前：

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

Java 8以降

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

Map：-このメソッドは、1つの関数を引数として取り、渡された関数をストリームのすべての要素に適用することによって生成された結果で構成される新しいストリームを返します。

想像してみてください、私は整数値のリスト（1,2,3,4,5）と、渡された整数の2乗の論理を持つ1つの関数インターフェイスを持っています。（e-> e * e）。

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]

ご覧のとおり、出力は、値が入力ストリームの値の2乗である新しいストリームです。

[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：-このメソッドは1つの関数を引数として取り、この関数は1つのパラメーターTを入力引数として受け入れ、パラメーターRの1つのストリームを戻り値として返します。この関数がこのストリームの各要素に適用されると、新しい値のストリームが生成されます。各要素によって生成されたこれらの新しいストリームのすべての要素は、このメソッドの戻り値となる新しいストリームにコピーされます。

想像してみてください。学生のオブジェクトのリストがあり、各学生が複数の科目を選択できます。

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]

ご覧のとおり、出力は新しいストリームであり、その値は入力ストリームの各要素によって返されるストリームのすべての要素のコレクションです。

[S1、S2、S3]-> [{"history"、 "math"、 "geography"}、{"economics"、 "biology"}、{"science"、 "math"}]->固有の主題をとる- > [経済学、生物学、地理学、科学、歴史、数学]

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

.mapはA-> Bマッピング用です

Stream.of("dog", "cat")              // stream of 2 Strings
    .map(s -> s.length())            // stream of 2 Integers: [3, 3]

任意のアイテムAを任意のアイテムに変換しますB。Javadoc

.flatMapはA-> Stream <B>連結用です

Stream.of("dog", "cat")             // stream of 2 Strings
    .flatMapToInt(s -> s.chars())   // stream of 6 ints:      [d, o, g, c, a, t]

it --1は任意のアイテムAをStream< B>に変換し、次に--2はすべてのストリームを1つの（フラット）ストリームに連結します。Javadoc

注1：後者の例は、オブジェクトのストリーム（Stream）ではなく、プリミティブのストリーム（IntStream）にフラット化されていますが、それでもの概念を示してい.flatMapます。

注2：名前にかかわらず、String.chars（）メソッドはintを返します。実際の収集がされるように：[100, 111, 103, 99, 97, 116] であり、ここで100のコードである'd'、111のコードである'o'等再度、例示の目的のためには、[D、O、G、C、T]として提示されます。

簡単な答え。

このmap操作ではStream、Stream.EXStream<Stream<Integer>>

flatMap操作はStream何かを生成するだけです。EXStream<Integer>

また、よく知っている場合は、C＃でも同様のことが言えます。基本的に、C＃Selectはjava mapおよびC＃SelectManyjavaに似ていflatMapます。コレクションのKotlinにも同じことが当てはまります。

これは初心者にとって非常に混乱します。基本的な違いはmap、リスト内のエントリごとに1つのアイテムを出力することで、flatMap基本的にはmap+ flatten演算です。より明確にするために、複数の値が必要な場合、たとえばループが配列を返すことが期待される場合は、flatMapを使用してください。この場合、flatMapは非常に役立ちます。

私はこれについてブログを書いています、あなたはここでそれをチェックすることができます。

操作flatMapをストリーミングしmap、関数を入力として受け入れます。

flatMapは、関数がストリームの各要素に対して新しいストリームを返すことを期待し、各要素に対して関数が返すストリームのすべての要素を組み合わせたストリームを返します。つまり、を使用するとflatMap、ソースの要素ごとに、関数によって複数の要素が作成されます。http://www.zoftino.com/java-stream-examples#flatmap-operation

map関数が変換された値を返すことを期待し、変換された要素を含む新しいストリームを返します。つまり、ではmap、ソースの要素ごとに、変換された要素が関数によって1つ作成されます。 http://www.zoftino.com/java-stream-examples#map-operation

flatMap()また、ストリームの部分的な遅延評価を利用します。最初のストリームを読み取り、必要な場合にのみ次のストリームに移動します。動作はここで詳細に説明されています：flatMapは遅延が保証されていますか？

map()反復（1レベルのforループ）と考えるflatmap()と、2レベルの反復（入れ子forループのような）です。（各反復要素を入力しfoo、それfoo.getBarList()を繰り返しますbarList）

map()：ストリームを取得し、すべての要素に対して何かを行い、すべてのプロセスの単一の結果を収集し、別のストリームを出力します。「何かをする」の定義は暗示的です。いずれかの要素の処理の結果がnullでnullある場合、最終ストリームを構成するために使用されます。したがって、結果のストリームの要素の数は、入力ストリームの数と等しくなります。

flatmap()：要素/ストリームのストリームと関数（明示的な定義）を取り、各ストリームの各要素に関数を適用し、中間ストリームをすべて収集してより大きなストリームにします（「平坦化」）。要素の処理の結果がである場合、null「平坦化」の最終ステップに空のストリームが提供されます。結果のストリームの要素数は、入力が複数のストリームである場合、すべての入力に含まれるすべての要素の合計です。