JDK8新特性-Stream流

个人简介

作者是一个来自河源的大三在校生，以下笔记都是作者自学之路的一些浅薄经验，如有错误请指正，将来会不断的完善笔记，帮助更多的Java爱好者入门。

文章目录

个人简介JDK8新特性-Stream流

教程概述Stream流的创建

用集合创建流用数组创建流使用Stream的静态方法创建流顺序流转换成并行流流的遍历和查找元素（forEach、find）

遍历Stream顺序流遍历并行流（多线程，输出顺序会不一样）找出流中第一个元素流的筛选（filter）

案例1：集合中大于5的元素，并打印出来案例2：筛选年龄大于25岁的人，并形成一个只有name的新的集合聚合（max、min、count）

案例3：获取String集合中最长的元素案例4：比较集合中数字最大的并输出案例5：计算Integer集合中大于6的元素的个数映射（map）

案例6：英文字符串数组的元素全部改为大写案例7：整数数组每个元素+3案例8：将员工的薪资全部增加1000 归约（reduce）

案例9：求所有员工的工资之和。案例10：最高工资收集（collect）

Stream流转List（toList）Stream流转Set（toSet）Stream流转Map（toMap）案例11：求流的平均值排序（sorted）

排序注意点案例12：对纯数字进行排序案例13：将对象的薪资属性进行排序去重和限制（distinct、limit）

JDK8新特性-Stream流教程概述

本教程附有非常多的例子，看完肯定能懂Stream流！看完本教程，对于Stream api基本的使用完全没有问题，底层原理则不会深究！本教程借鉴过很多其他大佬的教程，并进行总结创新，难免会有相同之处。 Stream流的创建用集合创建流

	  //创建普通顺序流
      Stream stream = asList.stream();

      //创建并行流
      Stream parallelStream = asList.parallelStream();

用数组创建流

	  int arr[]={1,2,3,4,5};
      IntStream intStream = Arrays.stream(arr);

使用Stream的静态方法创建流

Stream integerStream = Stream.of(1, 2, 3, 4, 5, 6);

顺序流转换成并行流

	  List asList = Arrays.asList(1, 2, 3, 4, 5);
      //创建顺序流
      Stream integerStream = asList.stream();
      //把顺序流转换成并行流
      Stream parallel = integerStream.parallel();

实体类Person：

class Person {
    private String name;  // 姓名
    private double salary; // 薪资
    private int age; // 年龄

    public Person(String name, double salary, int age) {
        this.name = name;
        this.salary = salary;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", salary=" + salary +
                ", age=" + age +
                '}';
    }
}

流的遍历和查找元素（forEach、find）遍历Stream顺序流

	  List list=new ArrayList<>();

      list.add(new Person("z1",2000.0,18));
      list.add(new Person("z2",3200.0,15));
      list.add(new Person("z3",1500.0,27));
      list.add(new Person("z4",7000.0,36));
      list.add(new Person("z5",5000.0,22));
      list.add(new Person("z6",4200.0,42));	  
	  //创建Stream顺序流
      Stream stream = list.stream();
      //遍历Stream顺序流
      stream.forEach(System.out::println);

遍历并行流（多线程，输出顺序会不一样）

	  //创建并行流（多线程）
      Stream parallelStream = list.parallelStream();
	  //遍历并行流（多线程，输出顺序会不一样）
	  parallelStream.forEach(System.out::println);

找出流中第一个元素

	  Optional first = stream.findFirst();
      System.out.println(first.get());

流的筛选（filter）案例1：集合中大于5的元素，并打印出来

	  List list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

      Stream stream = list.stream();

      //1：集合中大于5的元素，并打印出来
      stream.filter(el->el>5).forEach(System.out::println);

案例2：筛选年龄大于25岁的人，并形成一个只有name的新的集合

	  List personList = new ArrayList();
      personList.add(new Person("z1",2000.0,18));
      personList.add(new Person("z2",3200.0,15));
      personList.add(new Person("z3",1500.0,27));
      personList.add(new Person("z4",7000.0,36));
      personList.add(new Person("z5",5000.0,22));
      personList.add(new Person("z6",4200.0,42));

      Stream personStream = personList.stream();

      List collect = personStream
              .filter(person -> person.getAge() > 25)
          	  //只筛选出name，如果直接collect则返回的是person对象
              .map(Person::getName) 
              .collect(Collectors.toList());
      collect.forEach(System.out::println);

聚合（max、min、count）案例3：获取String集合中最长的元素

	 List list1 = Arrays.asList("qdiq", "sdji", "aaa", "ihduxdswaa", "qwer");

      Stream stream1 = list1.stream();

      Optional maxString = stream1.max(Comparator.comparing(String::length));
      System.out.println("maxString="+maxString.get());

案例4：比较集合中数字最大的并输出

	  List integerList = Arrays.asList(20, 10, 30, 52, 42, 15, 11, 13, 19, 30);

      Stream integerStream = integerList.stream();

      Optional optionalInteger = integerStream.max(Comparator.comparing(Integer::intValue));
      System.out.println(optionalInteger.get());

案例5：计算Integer集合中大于6的元素的个数

	  List list2 = Arrays.asList(7, 6, 4, 8, 2, 11, 9);
      long count = list2.stream().filter(integer -> integer > 6).count();
      System.out.println("集合中大于6的个数="+count);

映射（map）

可以直接操作每一个流的元素凡是需要操作流中元素的都用map，filter只是起到筛选的作用案例6：英文字符串数组的元素全部改为大写

	  Stream stream = Arrays.stream(strArr);

      //s就是每一个元素
      List collect = stream.map(s -> s.toUpperCase()).collect(Collectors.toList());

      collect.forEach(System.out::println);

案例7：整数数组每个元素+3

	  List intList = Arrays.asList(1, 3, 5, 7, 9, 11);

      Stream stream1 = intList.stream();
      stream1.map(integer -> integer+=3).collect(Collectors.toList()).forEach(System.out::println);

案例8：将员工的薪资全部增加1000

	  List personList = new ArrayList();
      personList.add(new Person("z1",2000.0,18));
      personList.add(new Person("z2",3200.0,15));
      personList.add(new Person("z3",1500.0,27));
      personList.add(new Person("z4",7000.0,36));
      personList.add(new Person("z5",5000.0,22));
      personList.add(new Person("z6",4200.0,42));

      Stream personStream = personList.stream();

      personStream.map(person -> {
          double old = person.getSalary();
          person.setSalary(old+1000); //增加1000
          return person; //返回原对象
      }).collect(Collectors.toList()).forEach(System.out::println);

归约（reduce）

把一个流缩减成一个值作用：实现一个流的加法、乘法、求最值等计算

整个流的加法、乘法、最大值

	  List list = Arrays.asList(1, 3, 2, 8, 11, 4);

      Stream stream = list.stream();

      //整个流的加法
      Optional add = stream.reduce((x, y) -> x + y);
      System.out.println(add.get());

      //整个流的乘法
      Optional num = stream.reduce((x, y) -> x * y);
      System.out.println(num.get());

      //最大值
      Optional maxNumber = stream.reduce((x, y) -> x > y ? x : y);
      System.out.println(maxNumber.get());

案例9：求所有员工的工资之和。

	  List personList = new ArrayList();
      personList.add(new Person("z1",2000.0,18));
      personList.add(new Person("z2",3200.0,15));
      personList.add(new Person("z3",1500.0,27));
      personList.add(new Person("z4",7000.0,36));
      personList.add(new Person("z5",5000.0,22));
      personList.add(new Person("z6",4200.0,42));
	  Stream personStream1 = personList.parallelStream();
      Optional sum = personStream1
              //指定选择操作薪资
              .map(person -> person.getSalary())
              .reduce((x, y) -> x + y);
      System.out.println(sum.get());

案例10：最高工资

	  List personList = new ArrayList();
      personList.add(new Person("z1",2000.0,18));
      personList.add(new Person("z2",3200.0,15));
      personList.add(new Person("z3",1500.0,27));
      personList.add(new Person("z4",7000.0,36));
      personList.add(new Person("z5",5000.0,22));
      personList.add(new Person("z6",4200.0,42));
	  Stream personStream2 = personList.parallelStream();
      Optional max = personStream2
              //指定操作salary
              .map(person -> person.getSalary())
              .reduce((x, y) -> x > y ? x : y);
      System.out.println(max.get());

收集（collect） Stream流转List（toList）

	List list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
    Stream parallel1 = list.stream().parallel();
	List list1 = parallel1.collect(Collectors.toList());
    list1.forEach(System.out::println);

Stream流转Set（toSet）

	List list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
    Stream parallel1 = list.stream().parallel();
	Set set = parallel2.collect(Collectors.toSet());
    set.forEach(System.out::println);

Stream流转Map（toMap）

	List personList = new ArrayList();
    personList.add(new Person("z1", 2000.0, 18));
    personList.add(new Person("z2", 3200.0, 15));
    personList.add(new Person("z3", 1500.0, 27));
    personList.add(new Person("z4", 7000.0, 36));
    personList.add(new Person("z5", 5000.0, 22));
    personList.add(new Person("z6", 4200.0, 42));
    Stream personStream = personList.stream().parallel();
    Map map =
        personStream
            // toMap(k, v)
            .collect(Collectors.toMap(x -> x.getName(), y -> y));

	// lambda遍历map
    map.forEach(
        (k, v) -> {
          System.out.println("key=" + k + ",v=" + v);
        });

案例11：求流的平均值

	List list2 = Arrays.asList(1, 2, 3, 4, 10);

    Stream integerStream = list2.stream();

    Double averag = integerStream.collect(Collectors.averagingInt(x -> x));
    System.out.println(averag);

排序（sorted）排序注意点

排序不能用并行流，否则将失效案例12：对纯数字进行排序

	  List list = Arrays.asList(12, 5, 6, 3, 2, 9, 22, 17, 15, 13, 6, 5, 1);
      Stream integerStream1 = list.stream();
      //1:对纯数字进行排序
      integerStream1.sorted(Comparator.comparingInt(x->x)).forEach(System.out::println);

案例13：将对象的薪资属性进行排序

	  List personList = new ArrayList();
      personList.add(new Person("z1",2000.0,18));
      personList.add(new Person("z2",3200.0,15));
      personList.add(new Person("z3",1500.0,27));
      personList.add(new Person("z4",7000.0,36));
      personList.add(new Person("z5",5000.0,22));
      personList.add(new Person("z6",4200.0,42));

      Stream stream = personList.stream();

      stream.sorted(Comparator.comparing(el->el.getSalary())).forEach(System.out::println);

去重和限制（distinct、limit）

	  List list = Arrays.asList(3, 6, 6, 2, 3, 1, 2, 9, 12, 15);
      Stream stream = list.stream();
      stream
              //去重
              .distinct()
              //分页,限制最多输出前几个
              .limit(3)
              .forEach(System.out::println);

JDK8新特性-Stream流

Java相关栏目本月热门文章