JDK8的stream的使用

lambda表达式：
• 特点：延迟加载，提高了性能
• 使用前提：必须存在函数式接口(有且只有一个抽象方法的接口)
• 类似匿名内部类的语法糖(更加方便使用，但原理不变的代码语法)
格式： （参数）-> {方法体}

• 只有一行代码时可以省略{}和方法的分号；
• 可以省略参数的类型

stream流：
• 优化集合的操作，使代码更优雅
• 关注做什么，而不是怎么做

1. stream流是一个集合元素的函数模型，它并不是集合，也不是数据结构，本身并不存储任何元素。只是数据源的元素队列。
2. 特征：
   • pipeling：中间操作都会返回流对象本身，多个操作可以串联成一个管道。
   • 内部迭代：流可以直接调用遍历的方法。
3. 使用流的基本步骤：获取数据源->数据转换->操作或获取结果。
   • 每次转换原有的stream不变，返回一个新的stream
4. 获取流的方式
   • 所有的collection可以通过stream方法获取流。
   list集合：list.stream()
   set集合：set.stream()
   map集合：不能直接转，但可以间接转换
   获取键：map.keySet().stream()
   获取值：map.values().stream()
   获取键值对：map.entrySet().stream()

• 数组获取流
  数组：int[] arr ={1,2,3}
  数组转流：Stream.of(arr)

5. stream流常用方法
   a. forEach():遍历。终结方法，调用后就不能继续调用stream的其他方法了
   list.stream().forEach(s ->sout(s));
   b. filter():过滤
   list.stream().filter( s-> return s.startWith(“张”));
   c. map:映射，将当前流中的类型数据转换为另一种类型
   stream().map(s -> {})
   d. count():统计个数。终结方法
   list.stream().count()
   e. limit():取用前几个
   list.stream().limit(3)
   f. skip():跳过前几个
   list.stream().skip(3)
   g. concat():把2个流合并
   list.stream().concat(stream1,stream2)

• stream其他用法

Student  {
Long studentId;
String name;
String class;
}

6. 将原来的Stream映射为一个单元素流，然后收集为List。
   • 把学生集合的id映射出来变成一个id的集合

List<String> StudnetIds = studentList.stream()
.map(Student::getStudentId)
.collect(Collectors.toList());

7. 把数组转map
   • 把学生集合的id作为key,class作为value的map

Map<Long,String> studentMap = studentList.stream()
.collect(Collectors.toMap(Student::getStudentId,
Student::getClass)); 

8. 拼接字符串

list.stream().map(Student::getName()).collect(Collectors.joining());
list.stream().map(Student::getName()).collect(Collectors.joining("-中间的分隔符-"));
list.stream().map(Student::getName()).collect(Collectors.joining("-中间的分隔符-", "前缀*", "&后缀"));

下面是copy的一个示例；

package com.badger;
 
import java.util.ArrayList;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
 
import org.junit.Test;
 
public class TestJava8 {
	public static List<Emp> list = new ArrayList<>();
	static {
		list.add(new Emp("上海", "小名", 17));
		list.add(new Emp("北京", "小红", 18));
		list.add(new Emp("深圳", "小蓝", 19));
		list.add(new Emp("广州", "小灰", 20));
		list.add(new Emp("杭州", "小黄", 21));
		list.add(new Emp("贵阳", "小白", 22));
	}
 
	@Test
	public void test1() {
		// 转list
		List<String> names = list.stream().map(emp -> emp.getName()).collect(Collectors.toList());
		// 转set
		Set<String> address = list.stream().map(emp -> emp.getName()).collect(Collectors.toSet());
		// 转map，需要指定key和value，Function.identity()表示当前的Emp对象本身
		Map<String, Emp> map = list.stream().collect(Collectors.toMap(Emp::getName, Function.identity()));
		// 计算元素中的个数
		Long count = list.stream().collect(Collectors.counting());
		// 数据求和 summingInt summingLong，summingDouble
		Integer sumAges = list.stream().collect(Collectors.summingInt(Emp::getAge));
		// 平均值 averagingInt,averagingDouble,averagingLong
		Double aveAges = list.stream().collect(Collectors.averagingInt(Emp::getAge));
 
		// 综合处理的，求最大值，最小值，平均值，求和操作
		// summarizingInt，summarizingLong,summarizingDouble
		IntSummaryStatistics intSummary = list.stream().collect(Collectors.summarizingInt(Emp::getAge));
		System.out.println(intSummary.getAverage());// 19.5
		System.out.println(intSummary.getMax());// 22
		System.out.println(intSummary.getMin());// 17
		System.out.println(intSummary.getSum());// 117
 
		// 连接字符串,当然也可以使用重载的方法，加上一些前缀，后缀和中间分隔符
		String strEmp = list.stream().map(emp -> emp.getName()).collect(Collectors.joining());
		String strEmp1 = list.stream().map(emp -> emp.getName()).collect(Collectors.joining("-中间的分隔符-"));
		String strEmp2 = list.stream().map(emp -> emp.getName()).collect(Collectors.joining("-中间的分隔符-", "前缀*", "&后缀"));
		System.out.println(strEmp);// 小名小红小蓝小灰小黄小白
		// 小名-中间的分隔符-小红-中间的分隔符-小蓝-中间的分隔符-小灰-中间的分隔符-小黄-中间的分隔符-小白
		System.out.println(strEmp1);
		// 前缀*小名-中间的分隔符-小红-中间的分隔符-小蓝-中间的分隔符-小灰-中间的分隔符-小黄-中间的分隔符-小白&后缀
		System.out.println(strEmp2);
		// maxBy 按照比较器中的比较结果刷选 最大值
		Optional<Integer> maxAge = list.stream().map(emp -> emp.getAge()).collect(Collectors.maxBy(Integer::max));
		// 最小值
		Optional<Integer> minAge = list.stream().map(emp -> emp.getAge()).collect(Collectors.minBy(Integer::min));
		// 归约操作
		list.stream().map(emp -> emp.getAge()).collect(Collectors.reducing((x, y) -> x + y));
		list.stream().map(emp -> emp.getAge()).collect(Collectors.reducing(0, (x, y) -> x + y));
		// 分操作 groupingBy 根据地址，把原list进行分组
		Map<String, List<Emp>> mapGroup = list.stream().collect(Collectors.groupingBy(Emp::getAddress));
		// partitioningBy 分区操作 需要根据类型指定判断分区
		Map<Boolean, List<Integer>> partitioningMap = list.stream().map(emp -> emp.getAge())
				.collect(Collectors.partitioningBy(emp -> emp > 20));
		
	}
 
	static class Emp {
		private String address;
 
		private String name;
 
		private Integer age;
 
		public Emp() {
 
		}
 
		public Emp(String address) {
			this.address = address;
		}
 
		public Emp(String name, Integer age) {
			this.name = name;
			this.age = age;
		}
 
		public Emp(String address, String name, Integer age) {
			super();
			this.address = address;
			this.name = name;
			this.age = age;
		}
 
		public String getAddress() {
			return address;
		}
 
		public void setAddress(String address) {
			this.address = address;
		}
 
		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;
		}
 
		@Override
		public String toString() {
			return "Emp [address=" + address + ", name=" + name + ", age=" + age + "]";
		}
 
	}
}