Java常用的stream流操作,附源码

Java常用的stream流操作,附源码

  • 问题背景
  • stream操作方法
        • 1 去重
        • 2 对象无序去重, 通过name去重
        • 3 对象无序去重, 通过name且age去重,注意:不是先使用name去重,再使用age去重
        • 3.1 对象有序去重
        • 4 整个对象去重, 使用distinct需要重写User的equals和hashcode
        • 5 流的基本操作
        • 6 取出List中某个属性值
        • 7 转为排序的list
        • 8 转为set集合
        • 9 转为map
        • 10 转换为一个数组
        • 11 取出最大值
        • 12 取出最小值
        • 13 返回总个数
        • 15 求总和
        • 16 anyMatch:只要流中有一个元素满足条件则返 回 true,否则返回 false
        • 17 allMatch: 当流中每个元素都符合条件时才返 回 true,否则返回 false
        • 18 取出第一个元素
        • 19 数组与list的相互转换
        • 20 name为key,age为value,如果key重复,取后一个v2值
        • 21 升序排序
        • 22 降序排序
        • 23 排序并去重
        • 24 根据两个字段排序
        • 25 根据中文字段排序
        • 26 通过对象里面的某个字段进行分组
        • 27 通过对象里面的某个字段映射为Map
        • 28 List转为List
        • 29 List转为List
  • 总结
  • Lyric: 包括像猫的狗

问题背景

java8的新特性非常有亮点,stream用起来爽歪歪
注意事项:

  • 可以自己创建工程,也可以下载源码进行参考

中间操作

  • filter:过滤流中的某些元素,
  • sorted(): 自然排序,流中元素需实现 Comparable 接口 。
  • distinct: 去除重复元素
  • limit(n): 获取 n 个元素
  • skip(n): 跳过 n 元素,配合 limit(n)可实现分页 map(): 将其映射成一个新的元素

终端操作

  • forEach: 遍历流中的元素
  • toArray: 将流中的元素倒入一个数组
  • min: 返回流中元素最小值
  • max: 返回流中元素最大值
  • count: 返回流中元素的总个数
  • reduce: 所有元素求和
  • anyMatch: 接收一个 Predicate 函数,只要流中有一个元素满足条件则返 回 true,否则返回 false
  • allMatch: 接收一个 Predicate 函数,当流中每个元素都符合条件时才返 回 true,否则返回 false
  • findFirst:返回流中第一个元素
  • collect: 将流中的元素倒入一个集合,Collection 或 Map

stream操作方法

导入类

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.lang3.ArrayUtils;

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toCollection;
1 去重
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        List<String> listDistinct = list.stream().distinct().collect(Collectors.toList());
        System.out.println(listDistinct);
2 对象无序去重, 通过name去重
        List<User> userList = new ArrayList();
        userList.add(new User("yuange", 12));
        userList.add(new User("yuange", 12));
        userList.add(new User("yuange1", 14));
        userList.add(new User("yuange1", 15));
        userList.add(new User("pangpang", 12));
        userList.add(new User("pangpang", 12));
        List<User> result = userList.stream()
                .collect(collectingAndThen(toCollection(() ->
                        new TreeSet<>(comparing(User::getName))), ArrayList::new));
        result.forEach(System.out::println);
3 对象无序去重, 通过name且age去重,注意:不是先使用name去重,再使用age去重
        List<User> result1 = userList.stream()
                .collect(collectingAndThen(toCollection(() ->
                        new TreeSet<>(comparing(o -> o.getName() + ";" + o.getAge()))), ArrayList::new));
        result1.forEach(System.out::println);
3.1 对象有序去重
public class StreamUtils{


	//LinkedHashMap有序去重
	private static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
	        LinkedHashMap<Object, Boolean> map = new LinkedHashMap<>();
	        return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
	}
	
	//ConcurrentHashMap无序去重
	private static <T> Predicate<T> distinctByKeyMap(Function<? super T, Object> keyExtractor) {
	        ConcurrentHashMap<Object, Boolean> map = new ConcurrentHashMap<>();
	        return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
	}
}
List<User> list = new ArrayList<User>();
list.add(new User("小南", 23, "18335888888"));
list.add(new User("小南", 22, "18335888888"));
list.add(new User("小南", 21, "18335888888"));
list.add(new User("小南", 20, "18335888888"));

list = list.stream().filter(StreamUtils.distinctByKey(User :: getName)).collect(Collectors.toList());
System.out.println(list.toString());
4 整个对象去重, 使用distinct需要重写User的equals和hashcode
        List<User> result2 = userList.stream().distinct().collect(Collectors.toList());
        result2.forEach(System.out::println);
5 流的基本操作
        Integer[] integers = new Integer[]{2, 4, 3, 6, 1, 7, 5, 5, 7};
        List<Integer> list1 = Arrays.asList(integers);
        //list1.stream()等价于Stream.of(2,4,3,6,1,7,5,5,7)
        list1.stream()
                //中间操作
                .filter((e) -> {
                    return e > 3;
                })      //使用Lambda的表达式  表示大于3的留下
                //filter的结果为 4,6,7,5,5,7
                .sorted()                           //自然排序,流中元素需实现
                //sorted的结果为 4,5,5,6,7,7
                .distinct()                         //去除重复元素
                //distinct的结果为 4,5,6,7
                .skip(1)                            //跳过 n 元素   这里意思跳过1个元素,从第二个开始
                //skip的结果为 5,6,7
                .limit(2)                           //获取 n 个元素 这里获取了两个元素
                //limit的结果为 5,6
                //终端操作
                .forEach((a) -> {
                    System.out.println(a);
                });
6 取出List中某个属性值
        ArrayList<User> arrayList = new ArrayList<>();
        arrayList.add(new User("小智", 12));
        arrayList.add(new User("张三", 12));
        arrayList.add(new User("蕾姆", 14));
        arrayList.add(new User("亚当", 11));
        arrayList.add(new User("夏娃", 7));
        arrayList.stream()
                //map(方法)将某一个值映射到Stream
                //Apple::getNumber意思是将Apple对象中的number 转换为Stream中的流
                .map(User::getName)
                //之下的操作就是对Apple中所有的number数据进行操作
                .forEach((e) -> {
                    System.out.println(e);
                });
arrayList.stream().map(User::getName).collect(Collectors.toList());
7 转为排序的list
        List<User> list2 = arrayList.stream()
                //中间操作,进行了一个排序的操作
                .sorted((o1, o2) -> {
                    return o1.getAge() - o2.getAge();
                })
                .collect(Collectors.toList());//将处理完后的流转换为List类型的数据
        System.out.println("转换为一个List的集合:");
        System.out.println(list);
8 转为set集合
        Set<User> set = arrayList.stream()
                //中间操作,进行了一个排序的操作
                .collect(Collectors.toSet());//将处理完后的流转换为List类型的数据
        System.out.println("转换为一个Set的集合:");//set就是不重复
        System.out.println(set);
9 转为map
        Map<String, Integer> map = arrayList.stream()
                //中间操作,进行了一个排序的操作
                .collect(Collectors.toMap(User::getName, User::getAge));//将处理完后的流转换为List类型的数据
        System.out.println("转换为map的结果:");
        System.out.println(map);
10 转换为一个数组
        Object[] array = list1.stream().sorted().toArray();
        System.out.println(Arrays.toString(array));
11 取出最大值
        Integer max = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7
                //终端操作
                .max((o1, o2) -> {
                    return o1 - o2;
                })//max的返回值是一个Optional这样的对象中
                //再调用Optional中的get的这个方法,将值拿到就行了
                .get();
        System.out.println(max);
12 取出最小值
        Integer min = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7
                //终端操作
                .min((o1, o2) -> {
                    return o1 - o2;
                })//min和max一样同理
                .get();
        System.out.println(min);
13 返回总个数
        long count = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7

                //终端操作
                .count();//count返回的总共有多少个数据元素
        System.out.println(count);
15 求总和
        Integer reduce = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7
                //终端操作
                .reduce((o1, o2) -> {
                    return o1 + o2;
                })//count返回的总共有多少个数据元素
                .get();
        System.out.println(reduce);
16 anyMatch:只要流中有一个元素满足条件则返 回 true,否则返回 false
        boolean anyMatch = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7

                //终端操作
                .anyMatch((e) -> {
                    return e > 3;
                });//表示流中的元素只要有一个大于3就返回true
        System.out.println("angMatch:" + anyMatch);
17 allMatch: 当流中每个元素都符合条件时才返 回 true,否则返回 false
        boolean allMatch = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7
                //终端操作
                .allMatch((e) -> {
                    return e > 3;
                });//表示流中的元素全部都大于3才返回true
        System.out.println("allMatch:" + allMatch);
18 取出第一个元素
         Integer findFirst = Stream.of(2, 4, 3, 6, 1, 7, 5)
                //中间操作
                .sorted()   //自然排序
                //sorted的结果为 1,2,3,4,5,6,7
                //终端操作
                .findFirst()    //findFirst的终端操作也用的是Optional的对象
                .get();         //要对数据进行输出,所以也要用的get的方法
        System.out.println("findFirst:" + findFirst);
19 数组与list的相互转换
        int[] array1 = {1, 2, 5, 5, 5, 5, 6, 6, 7, 2, 9, 2};
        /* int[] 转 list */
        //方法一:需要导入commons-lang3依赖  ArrayUtils.toObject把int转为Integer
        List<Integer> list3 = Arrays.asList(ArrayUtils.toObject(array1));
        //方法二:java8及以上版本 boxed()转为Integer
        List<Integer> list4 = Arrays.stream(array1).boxed().collect(Collectors.toList());
        System.out.println(list3);
        System.out.println(list4);
        System.out.println();

        /* list 转 int[]*/
        //方法一:
        Integer[] intArr = list3.toArray(new Integer[list3.size()]);
        //方法二:java8及以上版本
        int[] intArr1 = list3.stream().mapToInt(Integer::valueOf).toArray();
        System.out.println(Arrays.toString(intArr));
        System.out.println(Arrays.toString(intArr1));

        //数组为Integer类型
        Integer[] array2 = {1, 2, 5, 5, 5, 5, 6, 6, 7, 2, 9, 2};
        List<Integer> list5 = Arrays.asList(array2);
        System.out.println(list5);
20 name为key,age为value,如果key重复,取后一个v2值
userMap = userList.stream().collect(Collectors.toMap(User::name, User-> User, (v1, v2) -> v2));
21 升序排序
// 根据age排序 (正序)
list = list.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
//输出
//[User(name=小南, age=20, phone=18335888888), User(name=小南, age=21, phone=18335888888), User(name=小南, age=22, phone=18335888888), User(name=小南, age=23, phone=18335888888)]
// (倒序)
list = list.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());
//输出
//[User(name=小南, age=23, phone=18335888888), User(name=小南, age=22, phone=18335888888), User(name=小南, age=21, phone=18335888888), User(name=小南, age=20, phone=18335888888)]
//如果排序字段为空将空的某一条默认排到开头还是结尾
//放到结尾
list = list.stream().sorted(Comparator.comparing(User::getAge,Comparator.nullsLast(Integer::compare).reversed())).collect(Collectors.toList());
//放到开头
list = list.stream().sorted(Comparator.comparing(User::getAge,Comparator.nullsFirst(Integer::compare).reversed())).collect(Collectors.toList());
22 降序排序
stream流降序
list.stream().sorted(Comparator.reverseOrder())
stream流根据某一字段降序
list.stream().sorted(Comparator.comparing(User::getAge).reversed())
23 排序并去重
//需要使用文章上面的工具类StreamUtils
list = list.stream().sorted(Comparator.comparing(User::getAge,Comparator.nullsLast(Integer::compare).reversed())).filter(StreamUtils.distinctByKey(User :: getName)).collect(Collectors.toList());
24 根据两个字段排序
list.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getName)).collect(Collectors.toList());
25 根据中文字段排序
list.stream().sorted(Comparator.comparing(User::getChName,Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());
26 通过对象里面的某个字段进行分组
Map<Long, List<Keyword>> keywords = keywordService.getKeywordsByPaperId(paperIds).stream().collect(Collectors.groupingBy(Keyword::getPaperId));
27 通过对象里面的某个字段映射为Map
Map<String, Item> itemMap = itemList.stream().filter(t -> StringUtils.isNotEmpty(t.getCode())).collect(Collectors.toMap(Item::getCode, Function.identity()));
28 List转为List
list.stream().map(s -> Long.parseLong(s.trim())).collect(Collectors.toList());

处理返回LongStream;LongStream.boxed 将 LongStream 转换为 Stream ,然后收集到列表中

list.stream().mapToLong(t -> Long.parseLong(t.trim())).boxed().collect(Collectors.toList());
29 List转为List
list.stream().map(String::valueOf).collect(Collectors.toList());

总结

  • 有用到新的就来更新




作为程序员第 163 篇文章,每次写一句歌词记录一下,看看人生有几首歌的时间,wahahaha …

Lyric: 包括像猫的狗

你可能感兴趣的:(java开发常遇问题,java,开发语言)