总结：Java8之Stream

一、介绍

集合讲的是数据，流讲的是计算。

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

元素流在管道中经过中间操作的处理，最后由最终操作得到前面处理的结果。

stream()代码案例如下：

List<TUsersVO> userList = result.getData();
NoticeServiceImpl.userMap = userList.stream().collect(Collectors.toMap(TUsersVO::getUsername, e -> e));

二、基础操作符

• ->

->是Java 8新增的Lambda表达式中，变量和临时代码块的分隔符，即： (变量) -> {代码块}

• Java8 :: 用法 （JDK8 双冒号用法）

JDK8中有双冒号的用法，就是把方法当做参数传到stream内部，使stream的每个元素都传入到该方法里面执行一下。

代码其实很简单：

public class Test1 {

	public static void main(String[] args) {
		List<String> list = Arrays.asList("a","b","c");
		list.forEach(Test1::printStr);
	}
	
	public static void printStr(String a){
		System.out.println(a);
	}
}

三、创建Stream

Stream()：创建窜行处理流

//stream API 源码
default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
}

parallelStream()：创建并行处理流

四、Stream的中间操作：筛选与切片

案例：filter()函数：

List<Map<String, Object>> alertDetailList = (List<Map<String, Object>>) alertInfo.get("detail");
//过滤网络类型不对的
alertDetailList = alertDetailList
			.stream()
			.filter(alertDetail -> 
								      !StringUtil.isEmpty((String)alertDetail.get("endpointcounter")) 
									&&!StringUtil.isEmpty((String)alertDetail.get("endpoint")) 
									&&!((String)alertDetail.get("endpoint")).contains("<-->")//过滤掉专线告警（专线告警消息的idc字段也是节点，这会导致专线告警，但是节点也变色）
									&&!((String)alertDetail.get("endpoint")).contains("<->")//
									&& ((String)alertDetail.get("endpointcounter")).contains("nettype="+netTypePrivate))
            .collect(Collectors.toList());

 joining()函数：字符串拼接

List<String> strings2 = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
//将list按照逗号拼接成字符串
String mergedString = strings2.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);

 distinct()函数：去重

List<String> strings4 = Arrays.asList("abc", "bc", "efg", "abcd", "jkl", "efg", "abcd");
System.out.println("distinctList before is : " + strings4);
List<String> distinctList = strings4.stream()
				.filter(string -> !string.isEmpty())
				.distinct()
				.collect(Collectors.toList());
System.out.println("distinctList after  is : " + distinctList);

limit()函数：截取前maxSize个元素，返回一个新的Stream对象

skip()和limit()：这两个方法是Stream很常用的，不仅各自会被高频使用，还可以组合出现，并能实现一些小功能，如subList和分页等。

//1.准备一个List集合
List<String> list = new ArrayList<>();
list.add("aa");
list.add("bb");
list.add("ddddd");
list.add("eee");
list.add("ffffff");
list.add("bbb");


//2.获取Stream对象
Stream<String> streamList = list.stream();
//3.只取前5个元素
streamList.limit(3).forEach(System.out::println);

skip()函数：

List<Integer> result = Stream.of(1, 2, 3, 4, 5, 6).skip(4).collect(Collectors.toList());
System.out.println("跳过后的list："+result);

打印结果：
跳过后的list：[5, 6]

五、Stream的中间操作：映射

 案例：map()函数：

List<People> peoples = Arrays.asList(
                new People("zs", 25, "cs"),
                new People("ls", 28, "bj"),
                new People("ww", 23, "nj")
        );

// List -> String
List<String> names = peoples.stream().map(p -> p.getName()).collect(Collectors.toList());
// stream流实现英文字母转大写
List<String> upNames = names.stream().map(String::toUpperCase).collect(Collectors.toList());
// stream流实现数字乘倍数
List<Integer> ages = peoples.stream().map(p -> p.getAge() * 2).collect(Collectors.toList());
// list - > new List
List<PeoplePub> peoplePubs = peoples.stream().map(p -> {
            return new PeoplePub(p.getName(), p.getAge());
        }).collect(Collectors.toList());

案例：mapToInt()函数：

IntStream intStream = Arrays.asList(1, 2, 3, 4, 5, 6).stream().mapToInt(i -> i);

List<User> list = new ArrayList<>();

for (int i = 0; i < 5; i++) {
       User a = new User();
       a.setAge(5);
       if (i == 4) {
            a.setAge(null);
       }
       list.add(a);
}
// 存在空指针风险
// int sum = list.stream().mapToInt(User::getAge).sum();

// 正确写法
int sum = list.stream().mapToInt(o -> Objects.isNull(o.getAge()) ? 0 : o.getAge()).sum();
System.out.println(sum);

和mapToInt，还有mapToDouble，mapToLong，用法一致

list.stream().mapToDouble(User::getAge).sum()//和
list.stream().mapToDouble(User::getAge).max()//最大
list.stream().mapToDouble(User::getAge).min()//最小
list.stream().mapToDouble(User::getAge).average()//平均值

 flatMap()函数：简单来说就是将多个stream流合并成一个stream：

List<List<Integer>> lists = new ArrayList<>();
List<Integer> arrayList = new ArrayList<>();
arrayList.add(1);
arrayList.add(3);
arrayList.add(22);
arrayList.add(11);
arrayList.add(44);
arrayList.add(null);
arrayList.add(4);
lists.add(arrayList);
        
List<Integer> arrayList2 = JSON.parseArray(JSON.toJSONString(arrayList), Integer.class);
arrayList2.add(55);
lists.add(arrayList2);
        
List<Integer> arrayList3 = JSON.parseArray(JSON.toJSONString(arrayList), Integer.class);
arrayList3.add(99);
arrayList3.add(-2);
lists.add(arrayList3);

//将子集合抽上来形成一个大集合
List<Integer> collect = lists.stream()
            .flatMap(item -> item.stream().filter(Objects::nonNull))
            .collect(Collectors.toList());
System.out.println(collect);


输出：[1, 3, 22, 11, 44, 4, 1, 3, 22, 11, 44, 4, 55, 1, 3, 22, 11, 44, 4, 99, -2]

六、Stream的中间操作：排序

sorted()函数：

List<Employee> list = Arrays.asList(
            new Employee(1, "Alex", 1000),
            new Employee(2, "Michael", 2000),
            new Employee(3, "Jack", 1500),
            new Employee(4, "Owen", 1500),
            new Employee(5, "Denny", 2000));

list.stream().forEach(System.out::println);

//根据用户名排序
list.stream().sorted(Comparator.comparing(Employee::getName)).collect(Collectors.toList()).forEach(System.out::println);

//根据Id反向排序
list.stream()
.sorted(Comparator.comparingLong(Employee::getId).reversed())
.collect(Collectors.toList())
.forEach(System.out::println);

七、Stream的终止操作：查找与匹配

终止操作会从流的流水线生成结果。

其结果可以是任何不是流的值，例如List、Integer 甚至是void。

findFirst()函数：

Stream的findFirst方法在此流中查找第一个元素作为Optional。

如果流中没有元素，findFirst返回空的Optional。

如果流没有顺序，那么findFirst可以选择任何元素。

如果findFirst选择的元素为null，它将抛出NullPointerException。

List<String> list = Arrays.asList("Vijay", "Suresh", "Vinod");
String output = list.stream()
	  .filter(e -> e.startsWith("V")) // Vijay, Vinod
	  .findFirst() //Vijay
	  .orElse("NA");
System.out.println(output);

List<Integer> numList = Arrays.asList(31, 32, 33, 34);
numList.stream()
	  .filter(n -> n % 2 == 0) // 32, 34
	  .findFirst() //32
	  .ifPresent(e -> System.out.println(e));

1 .findFirst() 方法：根据命名可以大致知道是获取Optional流中的第一个元素。
2 .findAny() 方法：是获取Optional 流中任意一个，存在随机性，其实里面也是获取元素中的第一个。

count()函数：

List<String> list2 = new ArrayList<>();
list2.add("aa");
list2.add("ffffff");
list2.add("ddddd");
list2.add("ccc");
list2.add("ee");
list2.add("bbb");
long count = list2.stream().count();
System.out.println("count："+count);


输出：count：6

 

reduce()函数：reduce的意思的减少，缩小；但是这个方法的使用更像是流元素的累积操作，因为这个方法会将流中所有的元素经过累积操作之后返回。

//stream流重载了reduce方法，含三个
// 1.T reduce(T identity,BinaryOperator<T> accumulator)
//参数一为累加器的函数的标识，参数二为函数（+，-，*，/）
//2.Optional<T> reduce(BinaryOperator<T> accumulator)
//3.<U> U reduce(U identity,BiFunction<U,? super T,U> accumulator,BinaryOperator<U> combiner)

List<BigDecimal> list = new ArrayList<>();
BigDecimal a = new BigDecimal("10");
list.add(a);
BigDecimal b = new BigDecimal("20");
list.add(b);
BigDecimal c = new BigDecimal("30");
list.add(c);
BigDecimal d = new BigDecimal("-10");
list.add(d);

//BigDecimal.ZERO为0，以0为底数和流里的每一个元素相加
//求和
BigDecimal result = list.stream().reduce(BigDecimal.ZERO, BigDecimal::add);//结果为50
System.out.println(result);

//亦可写作
BigDecimal result1 = list.stream().reduce(BigDecimal.ZERO, (x,y) -> x.add(y));//结果为50
System.out.println(result1);

//求最大值
Optional<BigDecimal> max = list.stream().reduce(BigDecimal::max);//结果为30
System.out.println(max.get());

//求最小值
Optional<BigDecimal> min = list.stream().reduce(BigDecimal::min);//结果为-10
System.out.println(min.get());

//各项相乘
Optional<BigDecimal> mu = list.stream().reduce(BigDecimal::multiply);//结果为-60000
System.out.println(mu.get());

Collector接口中方法的实现决定了如何对流执行收集操作（如收集到List、Set、Map）。但是Collector实用类提供了很多静态方法可以方便的收集常见实例

 案例：

List<Student> studentList = Arrays.asList(
    new Student("刘一", 721, true, Student.GradeType.THREE),
    new Student("陈二", 637, true, Student.GradeType.THREE),
    new Student("张三", 666, true, Student.GradeType.THREE),
    new Student("李四", 531, true, Student.GradeType.TWO),
    new Student("王五", 483, false, Student.GradeType.THREE),
    new Student("赵六", 367, true, Student.GradeType.THREE),
    new Student("孙七", 499, false, Student.GradeType.ONE));

示例：统计所有学生的平均总成绩

Double averagingDouble = studentList.stream().collect(Collectors.averagingDouble(Student::getTotalScore));

六 、collect 方法

可以把Java8的流看做花哨又懒惰的数据集迭代器。他们支持两种类型的操作：中间操作(e.g. filter, map)和终端操作(如count, findFirst, forEach, reduce). 中间操作可以连接起来，将一个流转换为另一个流。这些操作不会消耗流，其目的是建立一个流水线。与此相反，终端操作会消耗类，产生一个最终结果。collect()方法就是一个 归约操作，就像reduce一样可以接受各种做法作为参数，将流中的元素累积成一个汇总结果 。具体的做法是通过定义新的Collector接口来定义的。

七、Optional用法

简单来说，Optional的主要业务场景就是在对象可能为null，最适合的场景是在A,B值其中一个值为null时选择另外一个值。

比如现在有个Student对象，需要使用Student的name字段构造user对象，那么一般的写法就是：

public User xxxFunction(Student student){
	User user = new User();
	if(student!=null){
		user.setUsername(student.getName());
	}
	return user;
}

使用Optional的写法：

public User xxxFunction(Student student){
	User user = new User();
	Optional.ofNullable(student).ifPresent(a->user.setUsername(a.getName()));
	return user;
}

ofNullable（T value）：会构造返回一个Optional<T>的对象，该方法允许value为null时，Optional类封装的value值为null。
ifPresent(Consumer<? super T> consumer) ：ifPresent是如果存在的意思，下面value其实就是指student对象，即student不为空时，才执行ifPresent里面的函数，即只有student不为空，才将student的name赋给user的name

public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
}

参考：

Java 8 Stream 

Java8新特性：Stream介绍和总结 

详解Java8 Collect收集Stream的方法