자바 8 에서 Stream API 의 이런 기교가 음탕 하 다!Get 했 어 요?

지난번 에 선생님 께 서 쿠키,session,token 을 공유 하 셨 는데 오늘 은 자바 8 의 Stream API 를 공유 해 드 리 겠 습 니 다.
스 트림 소개
1.자바 8 은 새로운 Stream API 를 도입 했다.이곳 의 Stream 은 I/O 흐름 과 달리 Iterable 을 가 진 집합 류 와 같 지만 행위 와 집합 류 는 다르다.
2.stream 은 집합 대상 의 기능 을 강화 하 는 것 으로 집합 대상 에 대해 각종 편리 하고 효율 적 인 집적 작업 을 하거나 대량의 데이터 조작 에 전념 합 니 다.
3.그 에 포 함 된 요소 에 대해 어떤 작업 을 수행 해 야 하 는 지 알려 주기 만 하면,예 를 들 어'길이 가 10 이상 인 문자열 을 걸 러 내기','모든 문자열 의 이니셜 가 져 오기'등 이 있 으 면 Stream 은 내부 에서 은밀하게 옮 겨 다 니 며 해당 하 는 데이터 변환 을 한다.
스 트림 을 왜 써 요?
1.함수 식 프로 그래 밍 이 가 져 온 장점 이 특히 뚜렷 하 다.이 코드 는 실현 체제 가 아니 라 업무 논리의 의 도 를 더 많이 표현 했다.읽 기 쉬 운 코드 도 유지 하기 쉽 고 믿 을 수 있 으 며 오류 가 발생 하기 쉽 지 않다.
2.고급
인 스 턴 스 데이터 원본

public class Data {
 private static List<PersonModel> list = null;
 
 static {
  PersonModel wu = new PersonModel("wu qi", 18, " ");
  PersonModel zhang = new PersonModel("zhang san", 19, " ");
  PersonModel wang = new PersonModel("wang si", 20, " ");
  PersonModel zhao = new PersonModel("zhao wu", 20, " ");
  PersonModel chen = new PersonModel("chen liu", 21, " ");
  list = Arrays.asList(wu, zhang, wang, zhao, chen);
 }
 
 public static List<PersonModel> getData() {
  return list;
 }
}

Filter
4.567917.데 이 터 를 옮 겨 다 니 며 그 중의 요 소 를 검사 할 때 사용 합 니 다

filter 는 함 수 를 매개 변수 로 받 아들 이 고 이 함 수 는 Lambda 표현 식 으로 표시 합 니 다

 /**
  *        
  */
 public static void fiterSex(){
  List<PersonModel> data = Data.getData();
 
  //old
  List<PersonModel> temp=new ArrayList<>();
  for (PersonModel person:data) {
   if (" ".equals(person.getSex())){
    temp.add(person);
   }
  }
  System.out.println(temp);
  //new
  List<PersonModel> collect = data
    .stream()
    .filter(person -> " ".equals(person.getSex()))
    .collect(toList());
  System.out.println(collect);
 }
 
 /**
  *             20 
  */
 public static void fiterSexAndAge(){
  List<PersonModel> data = Data.getData();
 
  //old
  List<PersonModel> temp=new ArrayList<>();
  for (PersonModel person:data) {
   if (" ".equals(person.getSex())&&person.getAge()<20){
    temp.add(person);
   }
  }
 
  //new 1
  List<PersonModel> collect = data
    .stream()
    .filter(person -> {
     if (" ".equals(person.getSex())&&person.getAge()<20){
      return true;
     }
     return false;
    })
    .collect(toList());
  //new 2
  List<PersonModel> collect1 = data
    .stream()
    .filter(person -> (" ".equals(person.getSex())&&person.getAge()<20))
    .collect(toList());
 
 }

Map
4

map 는 일대일 맵,for 의 역할 을 생 성 합 니 다

비교 상용4.567917.그리고 아주 간단 합 니 다.4.567918.

/**
  *          
  */
 public static void getUserNameList(){
  List<PersonModel> data = Data.getData();
 
  //old
  List<String> list=new ArrayList<>();
  for (PersonModel persion:data) {
   list.add(persion.getName());
  }
  System.out.println(list);
 
  //new 1
  List<String> collect = data.stream().map(person -> person.getName()).collect(toList());
  System.out.println(collect);
 
  //new 2
  List<String> collect1 = data.stream().map(PersonModel::getName).collect(toList());
  System.out.println(collect1);
 
  //new 3
  List<String> collect2 = data.stream().map(person -> {
   System.out.println(person.getName());
   return person.getName();
  }).collect(toList());
 }

FlatMap
4.567917.말 그대로 map 와 차이 가 많 지 않 고 더욱 깊 은 단계 의 조작4.567917.그러나 차이 가 있다.
맵 과 flat 반환 값 이 다 릅 니 다4.567917.맵 의 모든 입력 요 소 는 규칙 에 따라 다른 요소 로 전환 합 니 다4.567917.그리고 일부 장면 은 한 쌍 의 다 중 맵 관계 이 므 로 이때 flatMap 이 필요 합 니 다지도 1 대 1Flatmap 한 쌍 이 많 습 니 다맵 과 flatMap 의 방법 성명 은 다르다

Stream map(Function mapper);

Stream flatMap(Function> mapper);

4.567917.map 와 flatpap 의 차이 점:저 는 개인 적 으로 flatpap 의 경우 더욱 깊 은 차원 의 데 이 터 를 처리 할 수 있 고 여러 개의 list 에 들 어가 면 결 과 는 하나의 list 로 돌아 갈 수 있 으 며 map 는 1 대 1 이 고 입 참 은 여러 개의 list 이 며 결 과 는 여러 개의 list 로 돌아 가 야 한다 고 생각 합 니 다.쉽게 말 하면 입 참 이 모두 대상 이 라면 flatMap 은 대상 안의 대상 을 조작 할 수 있 고 map 는 1 층 만 조작 할 수 있다 

public static void flatMapString() {
  List<PersonModel> data = Data.getData();
  //       
  List<String> collect = data.stream()
    .flatMap(person -> Arrays.stream(person.getName().split(" "))).collect(toList());
 
  List<Stream<String>> collect1 = data.stream()
    .map(person -> Arrays.stream(person.getName().split(" "))).collect(toList());
 
  // map  
  List<String> collect2 = data.stream()
    .map(person -> person.getName().split(" "))
    .flatMap(Arrays::stream).collect(toList());
  //     
  List<String> collect3 = data.stream()
    .map(person -> person.getName().split(" "))
    .flatMap(str -> Arrays.asList(str).stream()).collect(toList());
 }

Reduce
느낌 이 비슷 하 다
숫자(문자열)누적개인 별로 안 써 봤 어 요.

 public static void reduceTest(){
  //  ，      10
  Integer reduce = Stream.of(1, 2, 3, 4)
    .reduce(10, (count, item) ->{
   System.out.println("count:"+count);
   System.out.println("item:"+item);
   return count + item;
  } );
  System.out.println(reduce);
 
  Integer reduce1 = Stream.of(1, 2, 3, 4)
    .reduce(0, (x, y) -> x + y);
  System.out.println(reduce1);
 
  String reduce2 = Stream.of("1", "2", "3")
    .reduce("0", (x, y) -> (x + "," + y));
  System.out.println(reduce2);
 }

Collect

collect 는 흐름 에서 목록,map 등 자주 사용 하 는 데이터 구 조 를 생 성 합 니 다

toList()

toSet()

toMap()

사용자 정의

 /**
  * toList
  */
 public static void toListTest(){
  List<PersonModel> data = Data.getData();
  List<String> collect = data.stream()
    .map(PersonModel::getName)
    .collect(Collectors.toList());
 }
 
 /**
  * toSet
  */
 public static void toSetTest(){
  List<PersonModel> data = Data.getData();
  Set<String> collect = data.stream()
    .map(PersonModel::getName)
    .collect(Collectors.toSet());
 }
 
 /**
  * toMap
  */
 public static void toMapTest(){
  List<PersonModel> data = Data.getData();
  Map<String, Integer> collect = data.stream()
    .collect(
      Collectors.toMap(PersonModel::getName, PersonModel::getAge)
    );
 
  data.stream()
    .collect(Collectors.toMap(per->per.getName(), value->{
   return value+"1";
  }));
 }
 
 /**
  *     
  */
 public static void toTreeSetTest(){
  List<PersonModel> data = Data.getData();
  TreeSet<PersonModel> collect = data.stream()
    .collect(Collectors.toCollection(TreeSet::new));
  System.out.println(collect);
 }
 
 /**
  *   
  */
 public static void toGroupTest(){
  List<PersonModel> data = Data.getData();
  Map<Boolean, List<PersonModel>> collect = data.stream()
    .collect(Collectors.groupingBy(per -> " ".equals(per.getSex())));
  System.out.println(collect);
 }
 
 /**
  *   
  */
 public static void toJoiningTest(){
  List<PersonModel> data = Data.getData();
  String collect = data.stream()
    .map(personModel -> personModel.getName())
    .collect(Collectors.joining(",", "{", "}"));
  System.out.println(collect);
 }
 
 /**
  *    
  */
 public static void reduce(){
  List<String> collect = Stream.of("1", "2", "3").collect(
    Collectors.reducing(new ArrayList<String>(), x -> Arrays.asList(x), (y, z) -> {
     y.addAll(z);
     return y;
    }));
  System.out.println(collect);
 }

Optional
4.567917.optional 은 핵심 라 이브 러 리 를 위 한 새로운 데이터 형식 으로 null 값 을 교체 합 니 다

사람들 은 기 존의 null 값 에 대해 불평 을 많이 한다.심지어 이 개념 을 발명 한 Tony Hoare 도 마찬가지 이다.그 는 이것 이 자신의'가치 가 매우 높 은 잘못'이 라 고 말 했다

lambda 뿐만 아니 라 어디 든 사용 할 수 있 습 니 다.

Optional.of(T),T 는 비어 있 지 않 습 니 다.그렇지 않 으 면 오 류 를 초기 화 합 니 다

Optional.ofNullable(T),T 는 임 의,비어 있 을 수 있 습 니 다

isPresent(),해당!=null ifPresent(T),T 는 lambda 표현 식 또는 다른 코드 일 수 있 으 며,비어 있 지 않 으 면 실 행 됩 니 다

public static void main(String[] args) {
 
 
  PersonModel personModel=new PersonModel();
 
  //        -
  Optional<Object> o = Optional.of(personModel);
  System.out.println(o.isPresent()?o.get():"-");
 
  //        -
  Optional<String> name = Optional.ofNullable(personModel.getName());
  System.out.println(name.isPresent()?name.get():"-");
 
  //     ，   xxx
  Optional.ofNullable("test").ifPresent(na->{
   System.out.println(na+"ifPresent");
  });
 
  //   ，        
  System.out.println(Optional.ofNullable(null).orElse("-"));
  System.out.println(Optional.ofNullable("1").orElse("-"));
 
  //   ，        ，    
  System.out.println(Optional.ofNullable(null).orElseGet(()->{
   return "hahah";
  }));
  System.out.println(Optional.ofNullable("1").orElseGet(()->{
   return "hahah";
  }));
 
  //   ，       
  System.out.println(Optional.ofNullable("1").orElseThrow(()->{
   throw new RuntimeException("ss");
  }));
 
 
//  Objects.requireNonNull(null,"is null");
 
 
  //   Optional       
  EarthModel earthModel1 = new EarthModel();
  //old
  if (earthModel1!=null){
   if (earthModel1.getTea()!=null){
    //...
   }
  }
  //new
  Optional.ofNullable(earthModel1)
    .map(EarthModel::getTea)
    .map(TeaModel::getType)
    .isPresent();
 
 
//  Optional<EarthModel> earthModel = Optional.ofNullable(new EarthModel());
//  Optional<List<PersonModel>> personModels = earthModel.map(EarthModel::getPersonModels);
//  Optional<Stream<String>> stringStream = personModels.map(per -> per.stream().map(PersonModel::getName));
 
 
  //      list
  Optional.ofNullable(new EarthModel())
    .map(EarthModel::getPersonModels)
    .map(pers->pers
      .stream()
      .map(PersonModel::getName)
      .collect(toList()))
    .ifPresent(per-> System.out.println(per));
 
 
  List<PersonModel> models=Data.getData();
  Optional.ofNullable(models)
    .map(per -> per
      .stream()
      .map(PersonModel::getName)
      .collect(toList()))
    .ifPresent(per-> System.out.println(per));
 
 }

병발 하 다

stream 을 parallelStream 또는 parallel 로 교체 합 니 다

입력 흐름 의 크기 는 병행 화가 속도 향상 을 가 져 올 지 여 부 를 결정 하 는 유일한 요소 가 아니 라 성능 은 코드 를 작성 하 는 방식 과 핵 수량의 영향 을 받 을 수 있 습 니 다

4.567917.성능 에 영향 을 주 는 다섯 가지 요 소 는 데이터 크기,소스 데이터 구조,값 포장 여부,사용 가능 한 CPU 핵 수량,그리고 모든 요 소 를 처리 하 는 데 걸 리 는 시간 이다

 //       ，      
 private static int size=10000000;
 public static void main(String[] args) {
  System.out.println("-----------List-----------");
  testList();
  System.out.println("-----------Set-----------");
  testSet();
 }
 
 /**
  *   list
  */
 public static void testList(){
  List<Integer> list = new ArrayList<>(size);
  for (Integer i = 0; i < size; i++) {
   list.add(new Integer(i));
  }
 
  List<Integer> temp1 = new ArrayList<>(size);
  //  
  long start=System.currentTimeMillis();
  for (Integer i: list) {
   temp1.add(i);
  }
  System.out.println(+System.currentTimeMillis()-start);
 
  //  
  long start1=System.currentTimeMillis();
  list.stream().collect(Collectors.toList());
  System.out.println(System.currentTimeMillis()-start1);
 
  //  
  long start2=System.currentTimeMillis();
  list.parallelStream().collect(Collectors.toList());
  System.out.println(System.currentTimeMillis()-start2);
 }
 
 /**
  *   set
  */
 public static void testSet(){
  List<Integer> list = new ArrayList<>(size);
  for (Integer i = 0; i < size; i++) {
   list.add(new Integer(i));
  }
 
  Set<Integer> temp1 = new HashSet<>(size);
  //  
  long start=System.currentTimeMillis();
  for (Integer i: list) {
   temp1.add(i);
  }
  System.out.println(+System.currentTimeMillis()-start);
 
  //  
  long start1=System.currentTimeMillis();
  list.stream().collect(Collectors.toSet());
  System.out.println(System.currentTimeMillis()-start1);
 
  //  
  long start2=System.currentTimeMillis();
  list.parallelStream().collect(Collectors.toSet());
  System.out.println(System.currentTimeMillis()-start2);
 }

디 버 깅

list.map.fiter.map.xx 는 체인 호출 이 고 최종 호출 collect(xx)는 결 과 를 되 돌려 줍 니 다

4.567917.타성 구 치 와 조기 구 치 를 나눈다4.567917.한 조작 이 타성 구 치 인지 일찍 구 하 는 지 판단 하 는 것 은 매우 간단 하 다.그것 의 반환 값 만 보면 된다.반환 값 이 Stream 이 라면 타성 값 입 니 다.반환 값 이 다른 값 이거 나 비어 있 으 면 미리 값 을 구 하 는 것 입 니 다.이런 조작 을 사용 하 는 이상 적 인 방식 은 타성 구 치 의 체인 을 형성 하고 마지막 으로 미리 구 하 는 조작 으로 원 하 는 결 과 를 되 돌려 주 는 것 이다

peek 를 통 해 모든 값 을 볼 수 있 고 흐름 을 계속 조작 할 수 있 습 니 다

private static void peekTest() {
  List<PersonModel> data = Data.getData();
 
  //peek        per
  data.stream().map(per->per.getName()).peek(p->{
   System.out.println(p);
  }).collect(toList());
 }

이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.