2021-09-22

Stream流

flatMapToInt()函数，具有将字符串解析为整数的操作

 // flatMapToInt 将字符串解析为整数的操作
 List<String> list = Arrays.asList("1", "2", "3", "4", "5");
 // 1 2 3 4 5 输出结果
 list.stream().flatMapToInt(num-> IntStream.of(Integer.parseInt(num))).forEach(System.out::println);

// flatMapToInt() 函数，获取长度操作
List<String> asList = Arrays.asList("GeeksforGeeks", "Geeks");
// 输出结果13  5
int[] ints = asList.stream().flatMapToInt(s -> IntStream.of(s.length())).toArray();
for (int anInt : ints) {
    System.out.println("anInt = " + anInt);
}

distinct()函数 去重

List<Integer> integers = Arrays.asList(1, 1, 2, 3, 4, 2);
// 1 2 3 4
List<Integer> collect = integers.stream().distinct().collect(Collectors.toList());

sorted() 排序

// 自然排序
List<Integer> integers = Arrays.asList(4,1, 1, 2, 3, 2);
// 1 2 3 4
integers.stream().distinct().sorted().collect(Collectors.toList()).forEach(System.out::println);

// 自然序逆序 使用Comparator 提供的reverseOrder() 方法
 List<Integer> integers = Arrays.asList(4,1, 1, 2, 3, 2);
 // 4  3  2  1
 integers.stream().distinct().sorted(Comparator.reverseOrder()).collect(Collectors.toList()).forEach(System.out::println);

 // 使用Comparator 来排序一个list
 menuDTOS.stream().sorted(Comparator.comparing(MenuDTO::getId)).collect(Collectors.toList()).forEach(System.out::println);

// 把上面的元素逆序
menuDTOS.stream().sorted(Comparator.comparing(MenuDTO::getId).reversed()).collect(Collectors.toList()).forEach(System.out::println);

// 反序 int 字段进行反序
menuDTOS.stream().sorted(Comparator.comparingInt(MenuDTO::getOrderNum).reversed()).forEach(System.out::println);

limit(long maxSize)截取

// limit  截取流中的元素 
list.stream().sorted().limit(3).collect(Collectors.toList()).forEach(System.out::println);

skip() 跳过元素

// skip 跳过几个元素
list.stream().sorted().skip(3).collect(Collectors.toList()).forEach(System.out::println);

forEachOrdered(Consumer<? super T> action) 顺序循环

List<Integer> list = Arrays.asList(9, 2, 2, 6, 8, 10);
// 保证顺序的执行
list.stream().forEachOrdered(System.out::println);

toArray(IntFunction<A[]> generator)转数组

List<Integer> list = Arrays.asList(9, 2, 2, 6, 8, 10);
// 流转换为数组的形式
Integer[] integers = list.stream().toArray(Integer[]::new);

// IntFunction用法
	IntFunction<Date[]> intFunction = Date[]::new; //指定要创建的数组类型
	Date[] dates = intFunction.apply(10); //创建一个指定长度的数组
//应用的场景：
	Map<Date,String> map = new HashMap();
	Date[] dates = map.keySet().stream().toArray(Date[]::new);
	
// 将map中的所有索引值保存成一个数组
	Date[] dates = map.keySet().stream().toArray(size -> {
		return new Date[size];});

reduce（）计算

// reduce 使用    线程安全使用
List<Integer> list = Arrays.asList(9, 2, 2, 6, 8, 10);
Integer integer = list.stream().reduce(Integer::sum).get();  // 37
Integer integer1 = list.stream().reduce((a, b) -> a + b).get(); // 37
// 1037
Integer reduce = list.stream().reduce(1000, (a, b) -> a += b);
System.out.println("reduce = " + reduce);

// 第三种 
        ArrayList<Integer> newList = new ArrayList<>();
        ArrayList<Integer> reduce1 = list.stream().reduce(newList, (acc, item) -> {
            newList.add(item);
            return acc;
        }, (acc, item) -> null);
        reduce1.forEach(System.out::println);
参考文档：https://blog.csdn.net/icarusliu/article/details/79504602

stream流中collect用法

// 按照xx分组
Collectors.groupingBy(People::getName) 

// collectingAndThen先对stream里的元素进行collecting，之后再对结果进行操作，  下面的结果是一个map,对map计算元素数目   结果为：5
Integer collect1 = menuDTOS.stream().collect(Collectors.collectingAndThen(Collectors.groupingBy(menuDTO -> menuDTO.getParent()), Map::size));
System.out.println("collect1 = " + collect1);

// 按照名字分组(分组的结果是一个map)，并统计每一个分组(map中的每一个value)中的元素数目  结果：stringLongEntry = 0::::4   stringLongEntry = 100::::1 stringLongEntry = 200::::3
// stringLongEntry = 300::::3   stringLongEntry = 400::::4
Map<String, Long> collect = menuDTOS.stream().collect(Collectors.groupingBy(MenuDTO::getParent, Collectors.counting()));
for (Map.Entry<String, Long> stringLongEntry : collect.entrySet()) {
    System.out.println("stringLongEntry = " + stringLongEntry.getKey() +"::::"+stringLongEntry.getValue());}

 // 集合中的数据根据某个字段进行分组
 Map<String, List<MenuDTO>> collect2 = menuDTOS.stream().collect(Collectors.groupingBy(MenuDTO::getParent));
 for (Map.Entry<String, List<MenuDTO>> stringListEntry : collect2.entrySet()) {
     System.out.println(stringListEntry.getKey()+"=" + stringListEntry.getValue());
 }

// 按某个字段分组后再按另一个字段取最大的类
/*0=Optional[MenuDTO{id='400', menuName='培训管理', parent='0', orderNum='4'}]
100=Optional[MenuDTO{id='101', menuName='公告栏', parent='100', orderNum='5'}]
200=Optional[MenuDTO{id='203', menuName='删除用户', parent='200',orderNum='0'}]
300=Optional[MenuDTO{id='303', menuName='删除角色', parent='300',orderNum='0'}]
400=Optional[MenuDTO{id='404', menuName='查询培训班', parent='400', orderNum='0'}]
*/
 Map<String, Optional<MenuDTO>> collect3 = menuDTOS.stream().collect(Collectors.groupingBy(MenuDTO::getParent,                                                                                          Collectors.maxBy(Comparator.comparing(MenuDTO::getId))));
 for (Map.Entry<String, Optional<MenuDTO>> stringOptionalEntry : collect3.entrySet()) {
     System.out.printf(stringOptionalEntry.getKey() +"=" + stringOptionalEntry.getValue());
 }

 // 集合转换为map  key为指定的字段
 Map<String, MenuDTO> collect2 = menuDTOS.stream().collect(Collectors.toMap(MenuDTO::getId, Function.identity()));
 for (Map.Entry<String, MenuDTO> entry : collect2.entrySet()) {
     System.out.println(entry.getKey() + ":::" + entry.getValue());
 }

参考文档：
https://blog.csdn.net/qq_43212582/article/details/109312598

max(Comparator<? super T> comparator); 取最大值

 // 取出集合中最大的一个字段
    List<Integer> integers = Arrays.asList(4,1, 1, 2, 3, 2);
    Integer integer = integers.stream().max((a, b) -> {
        if (a > b) {
            return 1;
        } else {
            return -1;
        }
    }).get();
    System.out.println("integer = " + integer);
}

min(Comparator<? super T> comparator) 取最小的值

 // 求集合中最小的值
 List<Integer> integers = Arrays.asList(4,1, 1, 2, 3, 2);
 Integer integer1 = integers.stream().distinct().min((a, b) -> {
     if (a > b) {
         return 1;
     } else {
         return 0;
     }
 }).get();
 System.out.println("integer1 = " + integer1);

findFirst() 获取流中的第一个元素

// findFist 获取流中的第一个元素  方式一：  OptionalInt是一个容器对象，可能包含也可能不包含int值
Optional<Integer> first = integers.stream().findFirst();
if (first.isPresent()){
    System.out.println("integer2 = " + first.get());
}
// 找到直接返回数据  找不到直接给到默认值
Integer integer3 = integers.stream().findFirst().orElse(null);

// findFist 获取流中的第一个元素  方式二：
Optional<Integer> any = integers.stream().findFirst();
any.ifPresent(value -> System.out.println("present = " + value));

findAny()寻找List中符合要求的数据

 // 获取流中符合条件的数据 如何不符合就直接返回null  不会出现异常  结果：null
 Integer integer2 = integers.stream().filter(s -> s == 5).findAny().orElse(null);
 System.out.println("integer2 = " + integer2);
 // 直接使用findAny()获取到元素的第一元素  不过建议使用findFirst来进行获取   结果： 4
 Integer integer3 = integers.stream().findAny().orElse(null);
 System.out.println("integer3 = " + integer3);

builder()构建流

 // 用于构建流,向里面调价元素，它返回构建的流。
 Stream<Object> build = Stream.builder().add(1).add(2).build();
 build.forEach(System.out::println);

anyMatch(Predicate<? super T> predicate) 匹配

// anyMatch 判断的条件里，任意一个元素成功，返回true
boolean anyMatch = integers.stream().anyMatch(s -> s == 4);
System.out.println("anyMatch = " + anyMatch);
// allMatch表示，判断条件里的元素，所有的都是，返回true
boolean allMatch = integers.stream().allMatch(s -> s == 4);
System.out.println("allMatch = " + allMatch);
//noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true
boolean noneMatch = integers.stream().noneMatch(s -> s == 6);
System.out.println("noneMatch = " + noneMatch);

// 对象中的操作
boolean b = menuDTOS.stream().anyMatch(menuDTO -> menuDTO.getId().equals("100"));
System.out.println("b = " + b);

concat(Stream a, Stream b) 两个流放在一起

// 两个流拼接到一个流中
Stream<Integer> integerStream = Stream.of(1, 2, 3);
Stream<Integer> integerStream1 = Stream.of(2, 2, 2);
List<Integer> collect = Stream.concat(integerStream, integerStream1).collect(Collectors.toList());
System.out.println("collect = " + collect);

// flatMap 也可以合并两个流  操作如下：
List<Integer> collect = Stream.of(1, 2, 3, 4, 5, 6).collect(Collectors.toList());
List<Integer> collect1 = Stream.of(8, 9, 10, 11, 12).collect(Collectors.toList());
List<Integer> collect2 = Stream.of(collect, collect1).flatMap(test -> test.stream()).collect(Collectors.toList());
System.out.println("collect2 = " + collect2);

iterate(final int seed, final IntUnaryOperator f)迭代生成无限整数流

// 迭代 2 6 18
IntStream limit = IntStream.iterate(2, n -> n * 3).limit(3);
limit.forEach(System.out::println);

Collectors类的使用

joining对Stream的结果字符串拼接

// joining  结果拼接到一起   javapythonC++phpjava
String collect2 = list.stream().collect(Collectors.joining());
System.out.println("collect2 = " + collect2);
// 结果以"!拼接到一起    java!python!C++!php!java
String collect3 = list.stream().collect(Collectors.joining("!"));
System.out.println("collect3 = " + collect3);
// 结果以start--开头，end--结束  中间以@连接  start--java@python@C++@php@javaend--
String collect4 = list.stream().collect(Collectors.joining("@", "start--", "end--"));
System.out.println("collect4 = " + collect4);

toCollection(Supplier collectionFactory) 收集为指定的集合

 List<String> list = Arrays.asList("java", "python", "C++","php","java");
 List<String> collect = list.stream().collect(Collectors.toCollection(LinkedList::new));
 System.out.println("collect = " + collect);

 TreeSet<String> collect1 = list.stream().collect(Collectors.toCollection(TreeSet::new));
 System.out.println("collect1 = " + collect1);

 HashSet<String> collect5 = list.stream().collect(Collectors.toCollection(HashSet::new));
 System.out.println("collect5 = " + collect5);

Collectors.groupingBy用法

// 指定字段进行分组  100===[MenuDTO{id='100', menuName='首页', parent='0', orderNum='1'}]
Map<String, List<MenuDTO>> collect = menuDTOS.stream().collect(Collectors.groupingBy(MenuDTO::getId));
Set<Map.Entry<String, List<MenuDTO>>> entries = collect.entrySet();
for (Map.Entry<String, List<MenuDTO>> entry : entries) {
    System.out.println(entry.getKey()+"===" + entry.getValue());
}

// 字段拼接分组   202-修改用户===[MenuDTO{id='202', menuName='修改用户', parent='200', orderNum='0'}]
Map<String, List<MenuDTO>> collect1 = menuDTOS.stream().collect(Collectors.groupingBy(item -> item.getId() + "-" + item.getMenuName()));
for (Map.Entry<String, List<MenuDTO>> stringListEntry : collect1.entrySet()) {
    System.out.println(stringListEntry.getKey() + "===" + stringListEntry.getValue());
}

// 根据不同条件分组 
//  2==[MenuDTO{id='300', menuName='角色管理', parent='0', orderNum='3'}, MenuDTO{id='400', menuName='培训管理', parent='0', orderNum='4'}, MenuDTO{id='101', menuName='公告栏', parent='100', orderNum='5'}]
 Map<? extends Serializable, List<MenuDTO>> collect2 = menuDTOS.stream().collect(Collectors.groupingBy(item -> {
     if (item.getOrderNum() > 2) {
         return 2;
     } else {
         return "other";
     }
 }));
 for (Map.Entry<? extends Serializable, List<MenuDTO>> listEntry : collect2.entrySet()) {
     System.out.println(listEntry.getKey() + "==" + listEntry.getValue());
 }

 // 分组  求总数  0===4 100===1  200===3  300===3  400===4
 Map<String, Long> collect = menuDTOS.stream().collect(Collectors.groupingBy(MenuDTO::getParent, Collectors.counting()));
 for (Map.Entry<String, Long> stringLongEntry : collect.entrySet()) {
     System.out.println(stringLongEntry.getKey() + "===" + stringLongEntry.getValue());
 }

Collectors类的研究使用
https://zhuanlan.zhihu.com/p/82508008  递归使用

集合：
LinkedList
CopyOnWriteArrayList
TreeSet