자바 8 stream flatMap 흐름 의 평면 화 작업 에 대하 여 말씀 드 리 겠 습 니 다.

6628 단어 java8streamflatMap 흐름
개념:
Steam 은 자바 8 이 제기 한 새로운 개념 으로 입 출력 의 Stream 흐름 이 아니 라 함수 식 프로 그래 밍 방식 으로 집합 류 에서 복잡 한 조작 을 하 는 도구 입 니 다.한 마디 로 하면 내부 교체 방식 으로 집합 데 이 터 를 처리 하 는 작업 이 고 내부 교 체 는 더 많은 통제 권 을 집합 류 에 맡 길 수 있다.Stream 은 Iterator 와 기능 이 유사 하지만 Iterator 는 외부 교체 형식 으로 집합 데 이 터 를 처리 하 는 작업 입 니 다.
자바 8 이전에 집합 작업 에 대해 처리 과정 을 써 야 합 니 다.예 를 들 어 집합 에서 조건 을 만족 시 키 는 데 이 터 를 선별 하려 면 집합 중의 모든 요 소 를 일일이 옮 겨 다 니 고 모든 요 소 를 조건 에 만족 하 는 지 판단 한 다음 에 조건 을 만족 시 키 는 요 소 를 저장 해 야 합 니 다.한편,Stream 은 집합 선별 작업 에 대해 더욱 편리 한 조작 을 제공 합 니 다.함수 인 터 페 이 스 를 실현 하 는 선별 조건 을 매개 변수 로 전달 하면 Stream 은 스스로 조작 하고 적당 한 요 소 를 stream 방식 으로 되 돌려 주 며 마지막 으로 받 으 면 됩 니 다.
2 가지 조작:
1.intermediate operation 중간 작업:중간 작업 의 결 과 는 하나의 Stream 을 묘사 하고 묘 사 했 으 며 새로운 집합 이 생기 지 않 았 습 니 다.이런 조작 을 타성 구 치 방법 이 라 고도 합 니 다.
2.terminal operation 종료 작업:최종 적 으로 Stream 에서 값 을 얻 을 수 있 습 니 다.
어떻게 이 두 가지 조작 을 구분 합 니까?작업 의 반환 값 유형 에 따라 판단 할 수 있 습 니 다.반환 값 이 Stream 이면 이 작업 은 중간 작업 입 니 다.반환 값 이 다른 값 이거 나 비어 있 으 면 이 작업 은 종료 작업 입 니 다.
flatMap 중간 조작:
Stream 으로 값 을 바 꾸 고 여러 Stream 흐름 을 하나의 Stream 흐름 으로 합 칠 수 있 습 니 다.

한 줄 의 숫자 를 포함 하 는 두 개의 흐름 을 하나의 흐름 으로 합 쳐

 @Test
 public void flapMapTest() {
 List<Integer> list = (List<Integer>) Stream.of(Arrays.asList(1, 2, 3, 4, 5, 6), Arrays.asList(8, 9, 10, 11, 12))
  .flatMap(test -> test.stream()).collect(Collectors.toList());
 
 for (int i = 0, length = list.size(); i < length; i++) {
  System.out.println(list.get(i));
 }
 
 }
flatpap 의 용법 과 의 미 는 하나의 사례 를 통 해 설명 해 야 한다.
사례:주어진 단어 목록["Hello","World"]에 대해 목록["H","e","l","o","W","r","d"]을 되 돌려 주 고 싶 습 니 다.
첫 번 째 방식

String[] words = new String[]{"Hello","World"}; 
List<String[]> a = Arrays.stream(words)
 
.map(word -> word.split("")) 
.distinct() 
.collect(toList()); 
a.forEach(System.out::print);
코드 출력:
[Ljava.lang.String;@12edcd21[Ljava.lang.String;@34c45dca
(String[]두 개 를 포함 하 는 list 를 되 돌려 줍 니 다)
이 구현 방식 은 문제 가 있 습 니 다.map 방법 에 전 달 된 lambda 는 단어 마다 String[](String 목록)을 만 들 었 습 니 다.따라서 맵 이 되 돌아 오 는 흐름 은 사실상 Stream형식 입 니 다.당신 이 진정 으로 원 하 는 것 은 Stream으로 문자열 을 표시 하 는 것 입 니 다.
아래 그림 은 위 코드 stream 의 운행 절차 입 니 다.

두 번 째 방식:flatMap(대류 편평 화 처리)

String[] words = new String[]{"Hello","World"}; 
List<String> a = Arrays.stream(words)
 
.map(word -> word.split("")) 
.flatMap(Arrays::stream) 
.distinct() 
.collect(toList()); 
a.forEach(System.out::print);
결과 출력:HeloWrd
flatMap 방법 을 사용 하 는 효 과 는 각 배열 이 하나의 흐름 을 매 핑 하 는 것 이 아니 라 흐 르 는 내용 을 매 핑 하 는 것 입 니 다.모든 맵(Array:stream)을 사용 할 때 생 성 된 하나의 흐름 이 합 쳐 지 는 것 입 니 다.즉,평면 화 된 것 입 니 다.
아래 그림 은 flatMap 의 stream 운행 절 차 를 활용 하여

예시:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class FlatMap {
  public static void main(String[] args) {
    //    
    //          
    String[] strArray = {"hello", "world"};
 
    //    
    List<String> res = Arrays.stream(strArray)
        .map(w -> w.split(""))
        .flatMap(Arrays::stream)
        .distinct()
        .collect(Collectors.toList());
    System.out.println(res);
 
    //TODO   
    System.out.println("--------------------------------");
    //Demo1:    ，       (      )
    //[1,2,3,4]=>[1,4,9,16]
    Integer[] nums1 = {1, 2, 3, 4};
    List<Integer> nums1List = Arrays.asList(nums1);
    List<Integer> res1 = nums1List.stream().map(i -> i * i).collect(Collectors.toList());
    System.out.println(res1);
 
    System.out.println("--------------------------------");
    //Demo2:     ，     
    //[1,2,3],[3,4]=>[1,3],[1,4],[2,3],[2,4],[3,3],[3,4]
    Integer[] nums2 = {1, 2, 3};
    Integer[] nums3 = {3, 4};
    List<Integer> nums2List = Arrays.asList(nums2);
    List<Integer> nums3List = Arrays.asList(nums3);
 
    //  2 map    
    List<int[]> res2 = nums2List.stream().flatMap(i -> nums3List.stream().map(j -> new int[]{i, j})).collect(Collectors.toList());
    System.out.println(res2.size());
 
    System.out.println("--------------------------------");
    //Demo3:  Demo2 Demo1        3     
    //(2,4) (3,3)      
    List<int[]> res3 = nums2List.stream().flatMap(i -> nums3List.stream().filter(j -> (i + j) % 3 == 0).map(j -> new int[]{i, j})).collect(Collectors.toList());
    System.out.println(res3.size()); 
  }
}
콘 솔 출력 결과:

자바 의 스 트림 흐름 중 맵 과 flatMap 의 차이 점
맵 부터 볼 게 요.scala 와 같은 함수 식 언어 를 잘 알 고 있다 면 이 방법 에 대해 잘 알 고 있 을 것 입 니 다.그 역할 은 input Stream 의 모든 요 소 를 output Stream 의 다른 요소 로 비 추 는 것 입 니 다.
대문자 변환

List<String> output = wordList.stream().
map(String::toUpperCase).
collect(Collectors.toList());
이 코드 는 모든 단 어 를 대문자 로 변환 한다.
제곱 수

List<Integer> nums = Arrays.asList(1, 2, 3, 4);
List<Integer> squareNums = nums.stream().
map(n -> n * n).
collect(Collectors.toList());
이 코드 는 정수 list 의 제곱 수{1,4,9,16}를 생 성 합 니 다.
위의 예 를 통 해 알 수 있 듯 이 맵 은 1:1 맵 을 생 성하 고 모든 입력 요 소 는 규칙 에 따라 다른 요소 로 전환 합 니 다.한 쌍 의 다 중 맵 관 계 를 가 진 장면 도 있 는데 이 때 는 flatMap 이 필요 하 다.
한 쌍 이 많다

Stream<List<Integer>> inputStream = Stream.of(
 Arrays.asList(1),
 Arrays.asList(2, 3),
 Arrays.asList(4, 5, 6)
 );
Stream<Integer> outputStream = inputStream.
flatMap((childList) -> childList.stream());
flatMap 은 inpuStream 의 등급 구 조 를 평면 화 하 는 것 은 바로 최 하층 요 소 를 추출 하여 함께 놓 는 것 이다.최종 output 의 새로운 Stream 에는 List 가 없고 모두 직접적인 숫자 이다.
이상 의 자바 8 stream flatMap 흐름 의 평면 화 작업 은 바로 편집장 이 여러분 에 게 공유 한 모든 내용 입 니 다.참고 하 실 수 있 고 많은 응원 부 탁 드 리 겠 습 니 다.
ASP.NET+easyUI 프레임 워 크 를 기반 으로 이미지 업로드 기능 구현(판단 형식+실시 간 탐색)
ASP.NET+easyUI 프레임 워 크 를 기반 으로 이미지 업로드 기능 구현(폼)

좋은 웹페이지 즐겨찾기

개발자 우수 사이트 수집

개발자가 알아야 할 필수 사이트 100선 추천 우리는 당신을 위해 100개의 자주 사용하는 개발자 학습 사이트를 정리했습니다
best100-homepage