JDK1.8新特性Stream.API

一、Stream 流创建

1.1 由集合创建

集合对象.stream()
List<Integer> list = new ArrayList<>();
Stream<Integer> stream = list.stream();//串行流
Stream<Integer> integerStream = list.parallelStream();//并行流

1.2 由数组创建

Integer[] integer = {};
Stream<Integer> stream = Arrays.stream(integer);

1.3 由值创建

Stream<String> aaa = Stream.of("aaa", "bbb");

1.4 由函数创建流

Stream.generate(()->Math.random()*10).limit(5).forEach(System.out::println);//生成
Stream.iterate(0,x->x+2).limit(5).forEach(System.out::println);//迭代

二、中间操作

2.1 刷选与切片

2.1.1 filter()–中需要使用断言型接口（Predicate）

List<Integer> list = Arrays.asList(1,2,3,523,21,55);
Stream<Integer> stream3 = list.stream().filter(x -> x > 10);
stream3.forEach(System.out::println);

2.1.2 limit()–截断流，使其元素不超过给定数量

#limit()截断流，使其元素不超过给定数量
List<Integer> list = Arrays.asList(1,2,3,523,21,55);
Stream<Integer> stream3 = list.stream().limit(3);
stream3.forEach(System.out::println);
--------------------输出---------------------
1
2
3

2.1.3 skip()–跳过元素返回一个抛弃了前n个元素的流，若流中元素不满足n个，则返回一个空流，与limit形成互补

List<Integer> list = Arrays.asList(1,2,3,523,21,55);
Stream<Integer> stream3 = list.stream().skip(3);
stream3.forEach(System.out::println);
--------------------输出---------------------
523
21
55

2.1.4 distinct()–筛选，通过流所所生成元素的hashCode()和equals()去除重复元素

  List<Integer> list = Arrays.asList(1,2,3,3,2,4);
  Stream<Integer> stream3 = list.stream().distinct();
  stream3.forEach(System.out::println);
  --------------------输出---------------------
  1
  2
  3
  4

2.2 映射

2.2.1 map()–里面使用函数型接口（Function）

List<String> list = Arrays.asList("aa","bb","cc");
Stream<String> stream3 = list.stream().map(String::toUpperCase);
stream3.forEach(System.out::println);
----------------------输出-----------------------
AA
BB
CC
------------------------------------------------
集合里的每一个元素都会使用到String.toUpperCase（）方法
它是以aa作为一个元素,bb作为一个元素 

2.2.2 flatMap----接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接一个流

List<String> list = Arrays.asList("aa","bb","cc");
Stream<String> stream3 = list.stream().flatMap(l -> {
           String[] strings = l.split("");
           return Arrays.stream(strings);
       });
stream3.forEach(System.out::println);
-------------------输出-----------
a
a
b
b
c
c
-----------------------------------------------
flatMap将原来的流转换为一个新的流并且，是以每一个值为单位的

2.3 排序

2.3.1 sorted() – 自然排序 按照Comparable的方式

List<String> list = Arrays.asList("aa","cc","bb");
Stream<String> stream3 = list.stream().sorted();
stream3.forEach(System.out::println);
---------------输出-----------
aa
bb
cc

2.3.2 sorted( Comparator com)–定制排序

 List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
 Stream<Integer> stream3 = list.stream().sorted(Integer::compare);
 stream3.forEach(System.out::println);
 --------------输出--------------
 1
 2
 3
 3
 6
 8
 9

三、终止操作

3.1 查询与匹配

3.1.1 allMatch()–里面的时断言型接口(Predicate)

 List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
 boolean b = list.stream().allMatch(x -> x > 3);
 System.out.println(b);
 ------------------输出--------------------
 false
 //因为不是所有的数都大于3

3.1.2 anyMatch()–里面的时断言型接口(Predicate)

 List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
 boolean b = list.stream().anyMatch(x -> x > 3);
 System.out.println(b);
  ------------------输出--------------------
 true
 //只要有大于3的数就返回true

3.1.3 noneMatch()–里面的时断言型接口(Predicate)

List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
boolean b = list.stream().noneMatch(x -> x > 3);
System.out.println(b);
 ------------------输出--------------------
 false
 //双重否定，返回false就是有匹配的元素

3.1.3 findFirst----返回第一个元素

List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
Optional<Integer> first = list.stream().findFirst();
System.out.println(first.get());
-----------------输出----------------
1

3.1.4 findAny----返回当前流中的任意一元素

List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
Optional<Integer> first = list.stream().findAny();
System.out.println(first.get());
-----------------输出----------------
1

3.1.5 count-----返回流中元素的总数

List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
long count = list.stream().count();
System.out.println(count);
-----------------输出----------------
7

3.1.5 count-----返回流中元素的总数

 #max----返回流中最大值
 List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
 Optional<Integer> max = list.stream().max(Integer::compareTo);
 System.out.println(max.get());
 -----------------输出----------------
9

3.1.6 min----返回流中的最小值

List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
Optional<Integer> min = list.stream().min(Integer::compareTo);
System.out.println(min.get());
 -----------------输出----------------
1

3.1.7 forEach – 迭代

List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
list.stream().forEach(System.out::println);
 -----------------输出----------------
1
3
2
6
8
3
9
//注意：forEach的迭代操作是由Stream API完成的称为内部迭代
//借助于iterator的方式为外部迭代

3.2 规约

3.2.1 reduce(T identity,BinaryOperator)—可以将流中元素反复结合起来得到一个值，返回T

 List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
 Integer reduce = list.stream().reduce(0, (x, y) -> x + y);
 System.out.println(reduce);
 -----------------输出----------------
 32
 //根据2元运算将所有的数加起来
 //首先以0为x，1为y，结果为1，然后1为x，取3为y，结果为4，以4为x...以此类推

3.2.2 reduce(BinaryOpreator)----可以将流中元素反复结合起来，返回Optional< T >

 List<Integer> list = Arrays.asList(1,3,2,6,8,3,9);
 Optional<Integer> reduce = list.stream().reduce((x, y) -> x + y);
 System.out.println(reduce.get());
  -----------------输出----------------
 32
 //原理同上，只是这里没有初始值，直接取1为x
 //所以ist就有可能为空，当返回的值可能为空时，结果存储在Optional容器中,避免空指针异常

3.3 收集

3.3.1 创建实体类

//创建实体类
public class User {
    private String name;
    private Integer age;
    private double salary;

    public User(String name, Integer age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public double getSalary() {
        return salary;
    }

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Double.compare(user.salary, salary) == 0 &&
                Objects.equals(name, user.name) &&
                Objects.equals(age, user.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, salary);
    }
}

3.3.2 导入测试数据

public class StreamTest {
	 List<User> user = Arrays.asList(new User("张三",12,1000.00),
                                    new User ("李四",32,4000),
                                    new User ("王五",40,4000),
                                    new User ("王五",40,4000));
}

3.3.3 根据名称生成一个新的List

 List<String> list = user.stream().map(User::getName).collect(Collectors.toList());
 list.forEach(System.out::println);
 -----------------输出--------------
 张三
 李四
 王五
 王五

3.3.4 根据名称生成一个新的Set

 
 Set<String> set = user.stream().map(User::getName).collect(Collectors.toSet());
 set.forEach(System.out::println);
 -----------------输出--------------
 张三
 李四
 王五

3.3.5 获取流的个数

Long count = user.stream().collect(Collectors.counting());
System.out.println(count);
-----------------输出--------------
4

3.3.6 根据工资获取平均值

Double avg = user.stream().collect(Collectors.averagingDouble(User::getSalary));
System.out.println(avg);
-----------------输出--------------
3250.0

3.3.7 根据工资获取总和

Double sum = user.stream().collect(Collectors.summingDouble(User::getSalary));
System.out.println(sum);
-----------------输出--------------
13000.0

3.3.8 根据工资获取组函数

 DoubleSummaryStatistics sum = user.stream().collect(Collectors.summarizingDouble(User::getSalary));
 System.out.println(sum);
 -----------------输出--------------
 DoubleSummaryStatistics{count=4, sum=13000.000000, min=1000.000000, average=3250.000000, max=4000.000000}

3.3.9 根据工资获取最大值

Optional<User> max = user.stream().collect(Collectors.maxBy(Comparator.comparingDouble(User::getSalary)));
 System.out.println(max.get());
 -----------------输出--------------
 User{name='李四', age=32, salary=4000.0}

3.3.10 根据工资获取最小值

Optional<User> min = user.stream().collect(Collectors.minBy(Comparator.comparingDouble(User::getSalary)));
 System.out.println(min.get());
 -----------------输出--------------
 User{name='张三', age=12, salary=1000.0}

3.3.11 分组

Map<Double, List<User>> map = user.stream().collect(Collectors.groupingBy(User::getSalary));
System.out.println(map);
-----------------输出--------------
{4000.0=[User{name='李四', age=32, salary=4000.0}, User{name='王五', age=40, salary=4000.0}, User{name='王五', age=40, salary=4000.0}], 1000.0=[User{name='张三', age=12, salary=1000.0}]}

3.3.12 多级分组

Map<Double, Map<String, List<User>>> collect = user.stream().collect(Collectors.groupingBy(User::getSalary, Collectors.groupingBy(
                u -> {
                    if ( u.getAge() <= 12) {
                        return "青年";
                    } else if ( u.getAge() <= 32) {
                        return "中年";
                    } else {
                        return "老年";
                    }
                }
        )));
System.out.println(collect);    
-----------------输出--------------    
{4000.0={老年=[User{name='王五', age=40, salary=4000.0}, User{name='王五', age=40, salary=4000.0}], 中年=[User{name='李四', age=32, salary=4000.0}]}, 1000.0={青年=[User{name='张三', age=12, salary=1000.0}]}}

3.3.13 分区

Map<Boolean, List<User>> collect1 = user.stream().collect(Collectors.partitioningBy(e -> e.getSalary() > 3000));
System.out.println(collect1);
-----------------输出--------------   
{false=[User{name='张三', age=12, salary=1000.0}], true=[User{name='李四', age=32, salary=4000.0}, User{name='王五', age=40, salary=4000.0}, User{name='王五', age=40, salary=4000.0}]}

3.3.14 连接

String s = user.stream().map(User::getName).collect(Collectors.joining("--"));
System.out.println(s);
-----------------输出--------------
张三--李四--王五--王五