list.stream() 创建顺序流
list.parallelStream() 创建并行流
Arrays.stream(数组)
Stream.of(数组)
通过parallel()把顺序流转换成并行流
Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();
Stream的使用
Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
package com.stream;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class test {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 15,"male", "New York"));
personList.add(new Person("Jack", 7000, 16,"male", "Washington"));
personList.add(new Person("Lily", 7800, 17,"female", "Washington"));
personList.add(new Person("Anni", 8200, 18,"female", "New York"));
personList.add(new Person("Owen", 9500, 19,"male", "New York"));
personList.add(new Person("Alisa", 7900, 20,"female", "New York"));
/*=============================遍历/匹配（foreach/find/match）================== */
List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
// 遍历输出符合条件的元素
list.stream().filter(x -> x > 6).forEach(System.out::println);
// 匹配第一个
Optional<Integer> first = list.stream().filter(x -> x > 6).findFirst();
System.out.println("配第一个" + first.get());
// 匹配任意（适用于并行流）
Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
System.out.println("匹配任意一个值：" + findAny.get());
// 是否包含符合特定条件的元素
boolean anyMatch = list.stream().anyMatch(s -> s < 6);
System.out.println("anyMatch : " + anyMatch);
//============== 筛选（filter）================================================
//筛选出Integer集合中大于7的元素
list.stream().filter(s -> s > 7).forEach(System.out::println);
//筛选员工中工资高于8000的人，并形成新的集合。 形成新集合依赖collect（收集）
personList.stream().filter(s -> s.getSalary() > 8000).map(Person::getName).collect(Collectors.toList()).forEach(System.out::println);
//============================== 聚合（max/min/count)====================================
//获取String集合中最长的元素。
List<String> listStr = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
Optional<String> strMax = listStr.stream().max(Comparator.comparing(String::length));
System.out.println("最长" + strMax.get());
//获取Integer集合中的最大值
// 自然排序
Optional<Integer> intMax = list.stream().max(Integer::compareTo);
//自定义
Optional<Integer> intMax02 = list.stream().max(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
});
System.out.println(intMax.get());
System.out.println(intMax02.get());
//获取员工工资最高的人
Optional<Person> salMax = personList.stream().max(Comparator.comparing(Person::getSalary));
System.out.println("工资最高的人"+salMax.get().getSalary());
//计算Integer集合中大于6的元素的个数
long count = list.stream().filter(s -> s > 6).count();
System.out.println("个数"+count);
//=====================映射(map/flatMap)======================================
//映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap
//map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
//flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
//英文字符串数组的元素全部改为大写。整数数组每个元素+3
String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
Arrays.stream(strArr).map(s -> s.toUpperCase()).collect(Collectors.toList()).forEach(System.out::println);
list.stream().map(s -> s+3).collect(Collectors.toList());
//将员工的薪资全部增加1000。
// 不改变原来员工集合的方式
List<Person> personListNew = personList.stream().map(person -> {
Person personNew = new Person(person.getName(), 0, 0, null, null);
personNew.setSalary(person.getSalary() + 1000);
return personNew;
}).collect(Collectors.toList());
System.out.println("一次改动前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());
System.out.println("一次改动后：" + personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());
// 改变原来员工集合的方式
List<Person> personListNew2 = personList.stream().map(person -> {
person.setSalary(person.getSalary() + 1000);
return person;
}).collect(Collectors.toList());
System.out.println("二次改动前：" + personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());
System.out.println("二次改动后：" + personListNew2.get(0).getName() + "-->" + personListNew2.get(0).getSalary());
//将两个字符数组合并成一个新的字符数组
List<String> listArr = Arrays.asList("m-k-l-a", "1-3-5-7");
List<String> listArrNew = listArr.stream().flatMap(s -> {
// 将每个元素转换成一个stream
String[] split = s.split("-");
Stream<String> stream = Arrays.stream(split);
return stream;
}).collect(Collectors.toList());
System.out.println("处理前的集合：" + listArr);
System.out.println("处理后的集合：" + listArrNew);
//=================================归约(reduce)=================================
//归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
//求Integer集合的元素之和、乘积和最大值
// 求和方式1
Optional<Integer> sum01 = list.stream().reduce((x, y) -> x + y);
//求和方式2
Optional<Integer> sum02 = list.stream().reduce(Integer::sum);
//求和方式3
Integer sum03 = list.stream().reduce(0, Integer::sum);
// 求乘积
Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
// 求最大值方式1
Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
//求最大值写法2
Integer max02 = list.stream().reduce(1, Integer::max);
System.out.println("总和" + sum01.get() + "," + sum02.get() + "," + sum03);
System.out.println("乘积" + product.get());
System.out.println("最大值" + max.get() + ", 最大值" + max02);
//求所有员工的工资之和和最高工资
//所有员工的工资之和
Optional<Integer> s1 = personList.stream().map(Person::getSalary).reduce(Integer::sum);
Integer s2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);
// 求最高工资方式
Integer high = personList.stream().map(Person::getSalary).reduce(1, Integer::max);
System.out.println("和："+s1.get() + "=======" + s2 );
System.out.println("高："+ high);
//===========================收集(collect)==================================
//把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合
//归集(toList/toSet/toMap)
//toList、toSet和toMap比较常用，另外还有toCollection、toConcurrentMap等复杂一些的用法。
list.stream().filter(s -> s>6).collect(Collectors.toList()).forEach(System.out::println);
list.stream().filter(s -> s % 3 == 0).collect(Collectors.toSet()).forEach(System.out::println);
Map<String, Person> collect = personList.stream().filter(p -> p.getSalary() > 8000).collect(Collectors.toMap(Person::getName, p -> p));
for (String s : collect.keySet()) {
System.out.println(s);
}
System.out.println(collect);
//==============================统计(count/averaging)==========================
/*
Collectors提供了一系列用于数据统计的静态方法：
计数：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
统计以上所有：summarizingInt、summarizingLong、summarizingDouble
*/
//统计员工人数、平均工资、工资总额、最高工资。
// 求总数
Long count01 = personList.stream().collect(Collectors.counting());
// 求平均工资
Double aveSal = personList.stream().collect(Collectors.averagingInt(Person::getSalary));
// 求最高工资
Optional<Integer> salMax02 = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
//求工资之和
Optional<Integer> he = personList.stream().map(Person::getSalary).collect(Collectors.reducing((x, y) -> x + y));
// 一次性统计所有信息
DoubleSummaryStatistics countCollect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
System.out.println(count01);
System.out.println(aveSal);
System.out.println(salMax02.get());
System.out.println(he.get());
System.out.println(countCollect);
//==============================================分组(partitioningBy/groupingBy)========================
//分区：将stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分。
//分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。
//将员工按薪资是否高于8000分为两部分；将员工按性别和地区分组
Map<Boolean, List<Person>> fenZuBySal = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
Map<String, List<Person>> fenZuBySex = personList.stream().collect(Collectors.groupingBy(Person::getSex));
// 将员工先按性别分组，再按地区分组
Map<String, Map<String, List<Person>>> fenZu = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
System.out.println(fenZuBySex);
System.out.println(fenZu);
//=====================================接合(joining)=======================
//joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串
String joinTest = personList.stream().map(p -> p.getName()).collect(Collectors.joining("--"));
System.out.println(joinTest);
//=========================归约(reducing)==================================
//Collectors类提供的reducing方法，相比于stream本身的reduce方法，增加了对自定义归约的支持。
// 每个员工减去起征点后的薪资之和
Integer sum = personList.stream().collect(Collectors.reducing(1, Person::getSalary, (i, j) -> (i + j - 5000)));
System.out.println("员工扣税薪资总和：" + sum);
//stream的reduce
Optional<Integer> reduceSum =personList.stream().map(Person::getSalary).reduce(Integer::sum);
System.out.println("员工薪资总和：" + reduceSum.get());
//================================================3.7 排序(sorted)===============================
//sorted，中间操作。有两种排序：
//sorted()：自然排序，流中元素需实现Comparable接口
//sorted(Comparator com)：Comparator排序器自定义排序
//将员工按工资由高到低（工资一样则按年龄由大到小）排序
// 按工资增序排序
List<String> sortBySalIncr = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName).collect(Collectors.toList());
// 按工资倒序排序
List<String> sortBySalDecr = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());
// 先按工资再按年龄自然排序（升序）
// 先按工资再按年龄自然排序（降序）
List<String> salAndAgeDesc = personList.stream().sorted((p1, p2) -> {
if (p1.getSalary() == p2.getSalary()) {
return p2.getSalary() - p1.getSalary();
}
return p2.getSalary() - p1.getSalary();
}).map(Person::getName).collect(Collectors.toList());
System.out.println("先按工资再按年龄自定义降序排序：" + salAndAgeDesc);
//===============================提取/组合==============================================
String[] arr1 = { "a", "b", "c", "d" };
String[] arr2 = { "d", "e", "f", "g" };
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
// concat:合并两个流 distinct：去重
List<String> concatAndDistinct = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
//limit：限制从流中获得前n个数据
List<Integer> limitStream = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
//skip：跳过前n个数据
List<Integer> skipStream = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
System.out.println("流合并：" + concatAndDistinct);
System.out.println("limit：" + limitStream);
System.out.println("skip：" + skipStream);
}
}