Java8新特性 Stream Api学习

有时候，我们在一个集合中需要筛选出符合条件的元素并且再做出其他处理时，Java8的新特性 Stream函数式编程可以帮我们解决问题。

案例：

1 从员工集合中筛选出salary高于8000的员工，放到新集合中。
2 统计员工最高的薪资，平均薪资，薪资之和。
3 将员工薪资按照从高到低排序，工资相同按照年龄小的在前。
4 按照员工性别分类，按照员工性别和地区分类，将员工按薪资分为是否高于8000的两个部分。

传统的迭代方法处理以上问题也可以，但是代码比较冗余。

1 Stream概述

JDK8是一个非常成功的版本，这个版本新增了Steam，配合出现的lambda，给我们操作集合提供了极大的便利。

stream将要处理的元素看做是一种流，在流中借助Stream API来对元素进行操作：筛选、排序、聚合等。

Stream可以由数组或者集合来创建，对流的操作分为几种

1. 中间操作，每次返回一个新的流，可以有多个。
2. 终端操作：每个流只能进行一次终端操作，终端操作结束后流无法再次使用，终端操作会产生一个新的集合或者值。

另外Stream有几个特性：

1. Stream不会存储数据，二货思按照特性的规则对数据进行计算，一般会输出结果
2. Stream不会改变数据源，通常会产生一个新的集合或者值
3. Stream具有延迟执行特性，只有终端调用时中间操作才会执行。

2 Stream的创建

1. 通过集合Collection来创建

List<String> list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();

2. 通过Arrays.stream(array)来创建

int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

3. 使用Stream的静态方法：of(),iterator(),generator()方法

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println);

Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

输出结果：
0 3 6 9
0.6796156909271994
0.1914314208854283
0.8116932592396652

Stream和parallelStream的简单区分：Stream是顺序流，由主线程按照顺序对流执行操作，而parallelStream是并行流，内部采用多线程并行执行对流进行操作，但前提是流中的数据处理没有顺序要求，例如筛选集合中的奇数，而知处理方式：

可以通过parallel()将顺序流转换为并行流：

Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();

3 Stream的使用

使用Stream之前，要了解一下Optional。

Optional类是一个可以为null的容器对象，如果值存在则isPresent()方法会返回true，调用get方法会获取对象。

接下来就是使用Stream的具体案例。
案例的员工类

List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, "male", "New York"));
personList.add(new Person("Jack", 7000, "male", "Washington"));
personList.add(new Person("Lily", 7800, "female", "Washington"));
personList.add(new Person("Anni", 8200, "female", "New York"));
personList.add(new Person("Owen", 9500, "male", "New York"));
personList.add(new Person("Alisa", 7900, "female", "New York"));

class Person {
	private String name;  // 姓名
	private int salary; // 薪资
	private int age; // 年龄
	private String sex; //性别
	private String area;  // 地区

	// 构造方法
	public Person(String name, int salary, int age,String sex,String area) {
		this.name = name;
		this.salary = salary;
		this.age = age;
		this.sex = sex;
		this.area = area;
	}
	// 省略了get和set，请自行添加

}

包含name、salary、age、sex和area等几个字段。

3.1遍历/匹配（foreach，find，match）

Stream也是支持类似集合的遍历和匹配元素的，只是Stream中元素以Optional类型存在的。
遍历和匹配十分简单：

public class StreamTest {
	public static void main(String[] args) {
        List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
		//遍历符合条件的元素
		list.stream().fileter(x -> x > 6).forEach(System.out::println);
		//匹配第一个
		Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
		//匹配任意 适用于并行流
		Optional<Integer> findAny = list.stream().filter(x -> x > 6).findAny();
		// 是否包含符合特定条件的元素
        boolean anyMatch = list.stream().anyMatch(x -> x > 6);
        System.out.println("匹配第一个值：" + findFirst.get());
        System.out.println("匹配任意一个值：" + findAny.get());
        System.out.println("是否存在大于6的值：" + anyMatch);
    }
}

3.2筛选filter

按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中操作

案例：筛选出集合中大于7的元素，并且打印

list.stream().filter(x -> x > 7).forEach(System.out::println);

案例，筛选员工工资高于8000的员工的姓名，形成新的集合，形成集合依赖collect

List<String> Employee = list.stream().filter(x -> x.getSalary() > 8000).map(Person::getName).collect(Collectors.toList());

3.3 聚合函数 max，min，count

案例1获取String集合中最常的元素

Optional<String> maxString = list.stream().max(Comparator.comparing(String::length));
return max.get();

案例2：获取Integer集合中的最大值

//自然排序
Optional<Integer> max = list.stream().max(Integer::compareTo);
//自定义排序
Optional<Integer> max2 = list.stream().max(new Comparator<Integer>(){
	@Override
			public int compare(Integer o1, Integer o2) {
				return o1.compareTo(o2);
			}
}

案例三：获取工资最高的员工

Optional<Person> max = list.stream().max(Comparator.comparaingInt(Person::getSalary))

案例四：计算Integer集合中大于6的个数

list.stream().filter(x -> x > 6).count();

3.4 映射map flatMap

映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。

map：接收一个函数为参数，该函数应用到每一个元素上，映射成新的元素
flatMap：接收一个函数为参数，将流中每个值换成另一个流，然后将所有的流连成一个流

案例1：英文字符串数组元素全部改为大写，整合素数组每个元素加3

List<String> list = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList())

List<Integer> list2 = intList.stream().map(x -> x + 3).collect(Colletors.toList());

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

List<Person> personList = list.stream().map(
person -> {
	person.setSalary(person.getSalary() + 1000);
	return person;
}).collect(Collerctors.toList());

3.5归约 reduce

缩减就是把一个流缩减成一个值，能够实现对集合求和、求乘积和求最值操作
案例1：对集合元素求和，乘积和最值

求和
Integer result = list.stream().reduce((x,y) -> x + y).get();
Optional<Integer> sum2 = list.stream().reduce(Integer::sum);

求乘积
Integer result = list。stream().reduce((x,y) -> x * y);

求最值
Integer result = list.stream().reduce((x,y) -> x > y ? x : y)
// 求最大值写法2
		Integer max2 = list.stream().reduce(1, Integer::max);

案例二：求所有员工的工资之和和最高工资。

Integer totalSalary = list.stream().map(Person::getSalary).reduce((x,y) -> x + y);

// 求最高工资方式1：
		Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
				Integer::max);

3.6 收集(collect)

因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。toList、toSet和toMap比较常用，另外还有toCollection、toConcurrentMap等复杂一些的用法。

List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
		List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
		Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());

• 未完待续！！！！