百日筑基第二十七天-Java8 stream流常用操作
创建stream流的方式
1、通过Collection系列提供的stream()（串行） 或parallelStream()（并行）获取
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();//串行流
Stream<String> stream2 = list.parallelStream();//并行流
2、通过Arrays中的静态方法stream() 获取数据流，接收参数为数组类型，将数组转成流
User[] u = new User[2];
Stream<User> stream3 = Arrays.stream(u);
3、通过Stream类中的静态方法of()
Stream<String> stream4 = Stream.of("11","2");
4、使用 Pattern.splitAsStream() 方法，将字符串分隔成流
Pattern pattern = Pattern.compile(",");
Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");
stringStream.forEach(System.out::println);
测试数据
定义一个User 类，用于测试：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private Integer id;
private String type;
private String name;
}
添加一些测试数据：
List<User> list = new ArrayList<>();
User user=new User(1,"a","小明");
User user1=new User(2,"a","小红");
User user2=new User(3,"b","小李");
list.add(user);
list.add(user1);
list.add(user2);
分组
将List里面的元素，以某个属性来分组，例如，以type分组，将type相同的放在一起
例：
//List 以type分组 Map<String,List<User>>
Map<String, List<User>> groupBy = list.stream().collect(Collectors.groupingBy(User::getType));
System.out.println(groupBy);
输出：
{a=[User(id=1, type=a, name=小明), User(id=2, type=a, name=小红)], b=[User(id=3, type=b, name=小李)]}
分组个数
我们还可以求出分组个数
求分组个数很简单，我们只需要在groupingBy方法里加多一个Collectors.counting()即可
Map<String, Long> groupBy = list.stream().collect(Collectors.groupingBy(User::getType,Collectors.counting()));
输出：
{a=2, b=1}
多级分组
多级分组是先将stream流分组，然后再对分组后的数据再进行分组
例：
Map<String, Map<String, List<User>>> groupBy = list.stream().collect(Collectors.groupingBy(User::getType,Collectors.groupingBy(User::getName)));
输出：
{a={小明=[User(id=1, type=a, name=小明)], 小红=[User(id=2, type=a, name=小红)]}, b={小李=[User(id=3, type=b, name=小李)]}}
Stream转换List
很多时候，我们对Stream操作之后，返回的还是Stream流，很多时候，我们想返回的List或者其他类型的对象，我们就需要对Stream流进行终止操作
方法：.collect(Collectors.toList())
说明：由Stream中的值生成一个List列表，也可用collect(toSet())生成一个Set集合。
例：
String[] testStrings = { "a", "b", "c", "d" };
List<String> list = Stream.of(testStrings).collect(Collectors.toList());
Stream转换Set
Stream 转换为 Set，Set不允许重复值，没有顺序，使用collect(Collectors.toSet())即可
例：
Set<User> collect = list.stream().collect(toSet());
Stream转换Map
Stream 转换为 Map，使用.collect(Collectors.toMap())即可。
Collectors.toMap 有三个重载方法：
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper);
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
BinaryOperator<U> mergeFunction);
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier);
参数含义分别是：
keyMapper：Key 的映射函数
valueMapper：Value 的映射函数
mergeFunction：当 Key 冲突时，调用的合并方法
mapSupplier：Map 构造器，在需要返回特定的 Map 时使用
三种重载方法，所以就有三种不同的用法
1、只指定key和value的映射
例：
//以ID为key，User对象为value组成一个map
Map<Integer, User> collect1 = list.stream().collect(toMap(User::getId, userObject -> userObject));
collect1.entrySet().stream().forEach(System.out::println);
输出：
1=User(id=1, type=a, name=小明)
2=User(id=2, type=a, name=小红)
3=User(id=3, type=b, name=小李)
当然，你也可以指定某个属性为value值
例：
//以ID为key，Name为value
Map<Integer, String> collect1 = list.stream().collect(toMap(User::getId, User::getName));
2、使用第二个重载方法，需要传多一个参数，即需要传入合并函数（用于当发生key冲突时，如何处理，即插入一个key已经存在的数据时的处理）
例：传入(o,n)->o合并函数
Map<String, String> collect1 = list.stream().collect(toMap(User::getType, User::getName,(o,n)->o));
//遍历map
collect1.entrySet().stream().forEach(System.out::println);
o,n)->o：其中o和n表示旧的value和新的value，只是一个名称，可以随意换成其他的名称，->o表示保留旧的value值，不插入新的value值
如我们运行上面的例子，输出如下
a=小明
b=小李
我们的数据中type值相同的有两个，因为小明是先插入的，所以合并函数(o,n)->o保留的是先插入的数据
如果我们想用后插入的数据来替换旧的数据，那么只需要把返回变量变一下即可，如下
(o,n)->n
当然，我们还可以返回其他形式的value，比如拼接两个value等等操作
例：
(o,n)->o+n
3、调用第三个重载方法，需要传4个参数，即在合并函数之后，再传入一个函数，用于自定义返回 Map的 类型
我们看一下三个参数的tomap源码
public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction) {
return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
}
可以看到，其实就是使用四个参数的重载方法，只不过替我们默认定义了返回的map类型为HashMap
有时候，我们不想返回HashMap，我们想返回ConcurrentHashMap，很简单，如下
list.stream().collect(toMap(User::getType, User::getName,(o,n)->o,ConcurrentHashMap::new));
如果想返回TreeMap，那么将ConcurrentHashMap::new替换成TreeMap::new即可
自定义实现Collection的数据结构收集
除了使用Collectors提供了toMap，toList等方法之外，我们还可以自定义Collection的数据结构收集
例：
//用LinkedList收集
list.stream().collect(Collectors.toCollection(LinkedList::new));
//用TreeSet收集
list.stream().collect(Collectors.toCollection(TreeSet::new));
stream字符串拼接
stream字符串拼接使用Collectors.joining()方法就可将字符串拼接在一起，而且joining方法可以传入一个字符参数，这样就可以在拼接的每个元素中间都拼接上该字符
注：joining方法只对String类型的流有效
joining还有一个三个传参的重载方法，
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
参数说明：
delimiter：元素间隔字符
prefix：前缀，即拼接字符开头加上的字符
suffix：后缀，即拼接字符结尾加上的字符
例：
List<String> stringList = Arrays.asList("a", "b", "c");
System.out.println(stringList.stream().collect(joining()));
System.out.println(stringList.stream().collect(joining("xxx")));
例：
List<String> stringList = Arrays.asList("a", "b", "c");
System.out.println(stringList.stream().collect(joining()));
System.out.println(stringList.stream().collect(joining("xxx")));
输出：
abc
axxxbxxxc
排序
stream流中的排序方法为sorted()
sorted()，产生一个新流，其中按自然顺序排序。
sorted(Comparator)，产生一个新流，其中按Comparator比较器顺序排序。
注：如果是自定义的对象使用sorted()方法，需要实现Comparable 接口，基本类型可以直接使用。
Comparable接口只有一个compareTo方法
public interface Comparable<T>{
int compareTo(T t);
}
int compareTo(T t)方法说明
定义:比较此对象与指定对象的顺序。
返回:负整数、零或正整数。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
例：
//按ID降序
@Override
public int compareTo(User user) {
return user.id-this.id;
}
升序
this.id-user.id
如果我们不想在对象里实现Comparable 接口，那么可以使用sorted(Comparator)方法，传入参数为Comparator比较器
例：根据type进行排序，reversed()为倒序
list.stream().sorted(Comparator.comparing(User::getType).reversed()).collect(toList());
注：comparing方法是Comparator内部实现的一个方法，我们可以传入某个属性，然后会替我们生成一个该属性的升序Comparator比较器
总数
求一个stream的长度，使用.collect(Collectors.counting()即可
list.stream().collect(Collectors.counting())
循环遍历
循环遍历使用forEach方法即可
//循环遍历输出每个元素
collect.stream().forEach(System.out::println);
取最大值
stream流有一个max方法可以取出stream流中符合要求的最大值
max方法源码如下：
Optional<T> max(Comparator<? super T> var1);
传入的参数为Comparator比较器，返回的是一个Optional对象，使用Optional的get方法，即可取出封装的对象
如果是基本类，则可以使用基本类型的compare方法
例：
//使用Comparator的comparing方法做参数
User user3 = list.stream().max(Comparator.comparing(User::getId)).get();
//取出User集合中最大的ID
Integer max = list.stream().map(x -> x.getId()).max(Integer::compare).get();
取最小值
stream流有一个min方法可以取出stream流中符合要求的最小值
用法和max方法一样
例：
//取出id最小的user
User min = list.stream().min((u1,u2)->u1.getId().compareTo(u2.getId())).get();
注：上面使用的是lambda表达式的Comparator比较器
取平均值
取平均值有averagingInt，averagingLong，averagingDouble三种方法，只是类型不一样，返回的都是Double
averagingInt源码如下
public static <T> Collector<T, ?, Double> averagingInt(ToIntFunction<? super T> mapper)
例：
//取出id的平均值
list.stream().collect(Collectors.averagingInt(User::getId));
筛选
stream流的筛选方法为filter(predicate)
filter(predicate)-接收lambda，从流中排除某些元素，保留符合条件的元素
该方法接受一个谓词predicate方法(返回Boolean的函数)作为参数
例：
//筛选出id大于1的user
List<User> collect2 = list.stream().filter(x -> x.getId() > 1).collect(toList());
输出
User(id=2, type=a, name=小红)
User(id=3, type=b, name=小李)
注意：stream流的filter方法是保留符合条件的元素
去重
stream流的筛选方法为distinct()，它会根据元素的hashcode()和equals()去除重复的元素
例：
List<String> stringList = Arrays.asList("a", "b", "c","a");
stringList.stream().distinct().forEach(System.out::println);
输出：
a
b
c
可以看到重复的元素a只剩下了一个
截断流limit
limit(n)-截断流，使其元素不超过给定数量
源码如下
Stream<T> limit(long var1);
传入的是一个Long类型的整数
例：
stringList.stream().limit(2L);
使用了这个limit方法后，stream流就会只剩下2个元素
映射
Stream中包含5个映射方法：map、mapToDouble、mapToInt、mapToLong和flatMap。
map，接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每一个元素上，并将其映射成一个新的元素。
map最常用的操作就是取出元素中的某个属性，形成一个新的流
例：
//将Uer集合中的Name属性全部取出来形成一个新的流，再转换成集合
List<String> nameList = list.stream().map(User::getName).collect(toList());
mapToDouble/mapToInt/mapToLong，接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新DoubleStream/IntStream/LongStream。
匹配
anyMatch是否有一个元素匹配条件，返回的是一个boolean类型元素
源码如下：
boolean anyMatch(Predicate<? super T> var1);
例：
//判断是否有元素的type等于b
boolean anyMatch = list.stream().anyMatch(x -> x.getType().equals("b"));
allMatch,检查是否匹配所有元素，需要stream流的所有元素都匹配条件才返回true
noneMatch,检查是否没有匹配所有元素。