Java 8에서 Stream.map()와 Stream.flatMap()메소드 의 차이점은 무엇 입니까?

모두 map와 flatMapA를 적용 할 수 Stream<T>및 수익 a를 둘 Stream<R>. 차이점은 map연산이 각 입력 값에 대해 하나의 출력 값을 flatMap생성하는 반면, 연산은 각 입력 값에 대해 임의의 숫자 (0 이상) 값을 생성한다는 것입니다.

이는 각 작업에 대한 인수에 반영됩니다.

이 map연산은 Function입력 스트림의 각 값에 대해 호출되는 하나의 결과 값을 생성하여 출력 스트림으로 전송합니다.

flatMap동작을 개념적으로 하나 개의 값을 소비 값의 임의의 수를 생성하기 원하는 기능 걸린다. 그러나 Java에서는 메소드가 0 또는 하나의 값만 리턴 할 수 있으므로 메소드가 임의의 수의 값을 리턴하는 것은 번거 롭습니다. 매퍼 함수 flatMap가 값 을 가져 와서 배열 또는 배열을 반환하는 API를 상상할 수 있습니다 .List값으로 설정되어 출력으로 전송됩니다. 이것이 스트림 라이브러리라는 점을 감안할 때, 임의의 수의 반환 값을 나타내는 적절한 방법은 매퍼 함수 자체가 스트림을 반환하는 것입니다! 매퍼가 반환 한 스트림의 값은 스트림에서 배출되어 출력 스트림으로 전달됩니다. 매퍼 함수에 대한 각 호출에 의해 리턴 된 값의 "클럼프"는 출력 스트림에서 전혀 구별되지 않으므로 출력이 "평평하게"있다고합니다.

일반적으로 0 값을 보내려는 경우 또는 여러 값을 반환하려는 경우 flatMap반환 하는 매퍼 함수가 사용 됩니다. 물론 모든 스트림을 반환 할 수 있습니다.Stream.empty()Stream.of(a, b, c)

Stream.flatMap이름에서 알 수 있듯이 a map와 flat연산 의 조합입니다 . 즉, 먼저 요소에 함수를 적용한 다음 평평하게합니다. Stream.map스트림을 평탄화하지 않고 스트림에만 함수를 적용합니다.

스트림의 평탄화 가 무엇인지 이해하려면 [ [1,2,3],[4,5,6],[7,8,9] ]"2 레벨" 과 같은 구조를 고려하십시오 . 이를 평탄화한다는 것은 "한 수준"구조로 변환하는 것을 의미합니다 [ 1,2,3,4,5,6,7,8,9 ].

좀 더 실용적인 관점 을 얻기 위해 두 가지 예를 제시하고 싶습니다
.

@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를 반환하는 데 적용됩니다 String.

다음을 사용하는 두 번째 예 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);
}

두 번째 예에서는 Stream of List가 전달됩니다. 정수 스트림이 아닙니다!
변환 기능을 사용해야하는 경우 (맵을 통해) 먼저 스트림을 다른 것 (정수 스트림)으로 평면화해야합니다.
flatMap이 제거되면 다음 오류가 리턴됩니다. 연산자 +는 인수 유형 List, int에 대해 정의되지 않았습니다.
정수 목록에 + 1을 적용 할 수 없습니다!

명확한 아이디어를 얻으려면 게시물을 완전히 살펴보십시오.

지도 대 평면지도 :

목록에서 각 단어의 길이를 반환하려면 다음과 같이하십시오.

아래에 주어진 짧은 버전

아래에 주어진 두 목록을 수집 할 때

플랫 맵이 없는 경우 => [1,2], [1,1] => [[1,2], [1,1]] 여기에 두 개의 목록이 목록에 배치되므로 목록이 포함 된 목록이 출력됩니다.

함께 평면지도 => [1,2], [1,1] => [1,2,1,1] 다음 두 개의리스트가 평평하고 출력 요소만을 포함하는리스트 수 있도록 값만이리스트에 배치되고

기본적으로 모든 객체를 하나로 병합합니다.

자세한 내용은 다음과 같습니다.

예를 들면 : -은
목록 고려 [ "스택", "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, 우리가 사용하여이 문제를 해결하는 방법을 볼 수 있도록 지도 하고 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 메소드를 사용하면 스트림의 각 값을 다른 스트림으로 교체 한 다음 생성 된 모든 스트림을 단일 스트림으로 결합 할 수 있습니다.

한 줄로 답변 : flatMapa Collection<Collection<T>>로 평평하게하는 데 도움이됩니다Collection<T> . 같은 방식으로, 또한 평평하게됩니다 Optional<Optional<T>>에를 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는 하나의 객체를 반환해야합니다. 즉, 입력 스트림의 각 객체는 출력 스트림에서 정확히 하나의 객체가됩니다.

전달하는 stream.flatMap함수는 각 객체에 대한 스트림 을 반환합니다. 즉, 함수는 각 입력 개체에 대해 여러 개체를 반환 할 수 있습니다 (없음 포함). 결과 스트림은 하나의 출력 스트림에 연결됩니다.

Map의 경우 요소 목록과 (함수, 동작) 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)]

나는 대부분의 대답이 간단한 문제를 너무 복잡하게 생각합니다. 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)

Optional에 관한 오라클의 기사는 맵과 플랫 맵의 차이점을 강조합니다.

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

불행히도이 코드는 컴파일되지 않습니다. 왜? 가변 컴퓨터는 유형 Optional<Computer>이므로 map 메소드를 호출하는 것이 완벽합니다. 그러나 getSoundcard ()는 Optional 유형의 객체를 반환합니다. 이는 맵 조작의 결과가 유형의 오브젝트임을 의미합니다 Optional<Optional<Soundcard>>. 결과적으로 getUSB () 호출은 유효하지 않습니다. 가장 바깥 쪽 Optional에는 다른 Optional 값이 포함되어 있기 때문에 유효하지 않습니다. 물론 getUSB () 메서드를 지원하지 않습니다.

스트림의 경우 flatMap 메소드는 함수를 인수로 사용하여 다른 스트림을 리턴합니다. 이 함수는 스트림의 각 요소에 적용되어 스트림 스트림을 생성합니다. 그러나 flatMap은 생성 된 각 스트림을 해당 스트림의 내용으로 바꾸는 효과가 있습니다. 다시 말해, 함수에 의해 생성 된 모든 개별 스트림은 하나의 단일 스트림으로 통합되거나 "평탄화"됩니다. 여기서 우리가 원하는 것은 비슷하지만, 2- 레벨 옵션을 하나로 "평평하게"하고 싶습니다 .

선택 사항은 flatMap 메소드도 지원합니다. 그 목적은 (맵 연산과 마찬가지로) Optional 값에 변환 함수를 적용한 다음 결과적인 2 단계 Optional을 단일 항목으로 병합하는 것 입니다.

따라서 코드를 올바르게 작성하려면 flatMap을 사용하여 다음과 같이 코드를 다시 작성해야합니다.

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

첫 번째 flatMap은을 Optional<Soundcard>대신 하여 a 가 반환 되도록하고 두 번째 flatMap은을 반환 Optional<Optional<Soundcard>>하는 동일한 목적을 달성합니다 Optional<USB>. getVersion ()은 Optional 객체가 아닌 String을 반환하므로 세 번째 호출은 map ()이어야합니다.

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

나는 이것에 대답해야한다고 확신하지 못하지만, 이것을 이해하지 못하는 사람을 만날 때마다 동일한 예를 사용합니다.

사과가 있다고 상상해보십시오. A map는 그 사과를 apple-juice예를 들어 또는 일대일 매핑으로 변환하고 있습니다.

같은 사과를 꺼내서 씨앗을 꺼냅니다. 즉 flatMap, 일대 다 , 사과는 입력으로, 씨앗은 많은 것으로 산출합니다.

map () 및 flatMap ()

1. map()

T는 element이고 R은 return element를 사용하여 람다 매개 변수를 함수로 가져옵니다. 마지막에는 Type R의 객체가있는 Stream이 있습니다. 간단한 예는 다음과 같습니다.

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

단순히 Type의 1 ~ 5 요소를 가져 와서 Integer각 요소를 사용 String하여 값 으로 type에서 새 요소를 작성 "prefix_"+integer_value하고 인쇄합니다.

2. flatMap()

flatMap () 함수 F<T, R>는

• T는 에서 /으로 스트림을 빌드 할 수 있는 유형 입니다 . List (T.stream ()), Array (Arrays.stream (someArray)) 등이 될 수 있습니다. 아래 예제에서 각 개발자는 많은 언어를 가지고 있으므로 dev. 언어는 목록이며 람다 매개 변수를 사용합니다.

• 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}

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[]]. 별로 예쁘지도 않고 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 유형의 새로운 요소 스트림에 병합 (또는 병합 )됩니다. 예를 들어 중첩 루프 를 나타내는 데 유용합니다 .

프리 자바 8 :

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

포스트 자바 8

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

Map :-이 메소드는 하나의 함수를 인수로 사용하여 전달 된 함수를 스트림의 모든 요소에 적용하여 생성 된 결과로 구성된 새 스트림을 리턴합니다.

정수 값 (1,2,3,4,5) 목록과 논리가 전달 된 정수의 제곱 인 함수 인터페이스가 있다고 가정 해 봅시다. (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]

보다시피, 출력은 값이 입력 스트림의 제곱 값인 새로운 스트림입니다.

[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를 입력 인수로 받아들이고 매개 변수 R의 하나의 스트림을 리턴 값으로 리턴합니다. 이 함수를이 스트림의 각 요소에 적용하면 새로운 값의 스트림이 생성됩니다. 그런 다음 각 요소에 의해 생성 된 이러한 새 스트림의 모든 요소가 새 스트림으로 복사되며이 스트림은이 메소드의 리턴 값입니다.

이미지를 보도록하겠습니다. 각 학생이 여러 과목을 선택할 수있는 학생 대상 목록이 있습니다.

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]-> [{ "역사", "수학", "지리학"}, { "경제학", "생물학"}, { "과학", "수학"}]-> 고유 한 과목 수강- > [경제학, 생물학, 지리학, 과학, 역사, 수학]

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. 자바 독

.flatMap을 위한 A -> 스트림 <B> concatinating

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

--1은 모든 항목을 A로 변환 Stream< B>한 다음 –2는 모든 스트림을 하나의 (평평한) 스트림으로 연결합니다. 자바 독

참고 1 : 후자의 예제는 객체 스트림 (Stream) 대신 프리미티브 스트림 (IntStream)으로 전개되지만 여전히 아이디어를 보여줍니다 .flatMap.

참고 2 : 이름에도 불구하고 String.chars () 메서드는 정수를 반환합니다. 실제 수집 될 수 있도록 : [100, 111, 103, 99, 97, 116] 여기서 100의 코드이며 'd', 111의 코드 'o'등 다시, 예시의 목적을 위해, 그것은 [D, O, G, C, A, t]로서 제시합니다.

간단한 대답.

map동작은 생산할 수 Stream의 Stream.EX을Stream<Stream<Integer>>

flatMap작업은 Stream무언가 만 생성 합니다. 전의Stream<Integer>

또한 익숙하다면 C # 과도 유추 할 수 있습니다. 기본적으로 C # Select은 java map및 C # SelectManyjava 와 유사합니다 flatMap. 코 틀린의 컬렉션에도 동일하게 적용됩니다.

초보자에게는 매우 혼란 스럽습니다. 기본적인 차이점은 map목록의 각 항목마다 하나의 항목을 내 보내며 flatMap기본적으로 map+ flatten작업입니다. 더 명확하게, 하나 이상의 값이 필요할 때 flatMap을 사용하십시오. 예를 들어, 배열을 리턴하기 위해 루프를 기대할 경우 flatMap이이 경우에 실제로 도움이됩니다.

이에 대한 블로그를 작성했습니다 . 여기에서 확인할 수 있습니다 .

작업 스트림 flatMap및 map입력 등의 기능을 동의합니다.

flatMap함수는 스트림의 각 요소에 대해 새 스트림을 반환하고 각 요소에 대해 함수가 반환 한 스트림의 모든 요소를 ​​결합하는 스트림을 반환합니다. 다시 말해 flatMap소스의 각 요소에 대해를 사용하면 함수에 의해 여러 요소가 만들어집니다. http://www.zoftino.com/java-stream-examples#flatmap-operation

map함수가 변환 된 값을 리턴하고 변환 된 요소를 포함하는 새 스트림을 리턴합니다. 다시 말해 map소스의 각 요소에 대해를 사용하면 변환 된 요소 하나가 함수에 의해 만들어집니다. http://www.zoftino.com/java-stream-examples#map-operation

flatMap()또한 스트림의 부분 지연 평가를 활용합니다. 주먹 스트림을 읽고 필요할 때만 다음 스트림으로 이동합니다. 동작은 여기에 자세히 설명되어 있습니다. flatMap이 게으른 것으로 보장됩니까?

map()반복 (1 레벨 for루프) 으로 생각 flatmap()하면 중첩 for루프 와 같은 2 레벨 반복 입니다. (각 반복 된 요소를 입력 foo하고, 어떻게 foo.getBarList()그와 반복 처리 barList다시)

map(): 스트림을 가져 와서 모든 요소에 대해 무언가를하고 모든 프로세스의 단일 결과를 수집하고 다른 스트림을 출력합니다. "일부 기능 수행"의 정의는 암시 적입니다. 요소의 처리 결과가 null이면 null최종 스트림을 작성하는 데 사용됩니다. 따라서 결과 스트림의 요소 수는 입력 스트림 수와 같습니다.

flatmap(): 요소 / 스트림의 스트림 과 함수 (명시 적 정의)를 취하여 각 스트림의 각 요소에 함수를 적용하고 모든 중간 결과 스트림을 더 큰 스트림 ( "flattening")으로 수집합니다. 요소의 처리 결과가 null이면 빈 스트림이 "평면화"의 마지막 단계로 제공됩니다. 입력 스트림이 여러 스트림 인 경우 결과 스트림의 요소 수는 모든 입력에 참여하는 모든 요소의 총계입니다.