Stream流使用

常用遍历方式

  1. //  forEach()方法：void forEach(Consumer< ? super T> action);
  2. //  peek()方法：Stream peek(Consumer< ? super T> action);
  3. List<String> list=...
  4. //  传统for循环
  5. for (String s : list) {
  6.     System.out.println(s);
  7. }
  8. // 使用forEach（结束操作），对集合的修改不会影响原集合
  9. list.stream().forEach(x -> {
  10.     System.out.println(x);
  11. });
  12. //  使用peek（中间操作），对集合的修改也会体现在原集合中
  13. list = list.stream().peek(x -> {System.out.println(x);}).collect(Collectors.toList());

1.filter过滤(惰性求值)

filter 只刻画出了 Stream，但没有产生新的集合。像 filter 这样只描述 Stream，最终不产生新集合的方法叫作惰性求值方法；而像 collect(Collectors.toList())这样 最终会从 Stream 产生值的方法叫作及早求值方法

  1. public class TestFilter {
  2. 　　public static void main(String[] args) {
  3. 　　　　List<Person> persionList = new ArrayList<Person>();
  4. 　　　　persionList.add(new Person(1, "张三", "男", 8));
  5. 　　　　persionList.add(new Person(2, "小小", "女", 2));
  6. 　　　　persionList.add(new Person(3, "李四", "男", 25));
  7. 　　　　persionList.add(new Person(4, "王五", "女", 8));
  8. 　　　　persionList.add(new Person(5, "赵六", "女", 25));
  9. 　　　　persionList.add(new Person(6, "大大", "男", 65));
  11. 　　　　//1、查找年龄大于20岁的人数
  12. 　　　　long  age=persionList.stream().filter(p->p.getAge()>20).count();
  13. 　　　　System.out.println(age);
  15. 　　　　//2、查找年龄大于20岁，性别为男的人数
  16. 　　　　List<Person>  ageList=persionList.stream().filter(p->p.getAge()>20).filter(p->"男".equals(p.getSex())).collect(Collectors.toList());
  17. 　　　　System.out.println(ageList.size());
  19.        //3、查找年龄大于20岁的男性 或 年龄大于18岁的女性人数
  20.        List<Person>  ageList=persionList.stream().filter(p -> (p.getAge()>20 && "男".equals(p.getSex())) || (p.getAge()>18 && "女".equals(p.getSex()))).collect(Collectors.toList());
  21.        System.out.println(ageList.size());
  23. 　　　　//4、过滤掉 姓名、性别、年龄 均相同的重复项
  24. 　　　　List<Person>  ageList=persionList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(p -> p.getName() + ";" + p.getSex() + ";" + p.getAge()))), ArrayList::new));
  25. 　　　　System.out.printIn(ageList.size());
  26. 　　}
  27. }

2.map转换(map, mapToInt、mapToLong、mapToDouble)

转换流，将一种类型的流转换为另外一种流。（mapToInt、mapToLong、mapToDouble 返回int、long、double基本类型对应的Stream）

  1. public class Person {
  2.     private Integer  id;
  3.     private String name;
  4.     private String sex;
  5.     private Integer age;
  6.     //提供get，set，和满参构造函数
  7. }
  9. public class TestMap {
  10. 　　public static void main(String[] args) {
  11. 　　　　List<Person> persionList = new ArrayList<Person>();
  12. 　　　　persionList.add(new Person(1,"张三","男",38));
  13. 　　　　persionList.add(new Person(2,"小小","女",2));
  14. 　　　　persionList.add(new Person(3,"李四","男",65));
  15. 　　　　persionList.add(new Person(4,"王五","女",20));
  16. 　　　　persionList.add(new Person(5,"赵六","男",38));
  17. 　　　　persionList.add(new Person(6,"大大","男",65));
  19. 　　　　//1、只取出该集合中所有姓名组成一个新集合
  20. 　　　　List<String> nameList=persionList.stream().map(Person::getName).collect(Collectors.toList()); //未去重
  21. 　　　　List<String> nameList=persionList.stream().map(Person::getName).distinct().collect(Collectors.toList()); //去重
  22. 　　　　System.out.println(nameList.toString());
  24. 　　　　//2、只取出该集合中所有id组成一个新集合
  25. 　　　　List<Integer> idList=persionList.stream().mapToInt(Person::getId).boxed().collect(Collectors.toList());
  26. 　　　　System.out.println(idList.toString());
  28. 　　　　//3、list转map，key值为id，value为Person对象
  29. 　　　　Map<Integer, Person> personmap = persionList.stream().collect(Collectors.toMap(Person::getId, person -> person));
  30. 　　　　System.out.println(personmap.toString());
  32. 　　　　//4、list转map，key值为id，value为name
  33. 　　　　Map<Integer, String> namemap = persionList.stream().collect(Collectors.toMap(Person::getId, Person::getName));
  34. 　　　　System.out.println(namemap.toString());
  36. 　　　　//5、进行map集合存放，key为age值 value为Person对象 它会把相同age的对象放到一个集合中
  37. 　　　　Map<Integer, List<Person>> ageMap = persionList.stream().collect(Collectors.groupingBy(Person::getAge));
  38. 　　　　System.out.println(ageMap.toString());
  40. 　　　　//6、获取最小年龄
  41. 　　　　Integer ageMin = persionList.stream().mapToInt(Person::getAge).min().getAsInt();
  42. 　　　　System.out.println("最小年龄为: "+ageMin);
  44. 　　　　//7、获取最大年龄
  45. 　　　　Integer ageMax = persionList.stream().mapToInt(Person::getAge).max().getAsInt();
  46. 　　　　System.out.println("最大年龄为: "+ageMax);
  48. 　　　　//8、集合年龄属性求和
  49. 　　　　Integer ageAmount = persionList.stream().mapToInt(Person::getAge).sum();
  50. 　　　　System.out.println("年龄总和为: "+ageAmount);
  52.        //9、不改变原本的集合修改集合
  53.        List<Person> lists = persionList.stream().map(item -> {
  54.             Person person = new Person();
  55.             person.setName("修改集合");
  56.             return person;
  57.        }).collect(Collectors.toList());
  59.         //10  改变原来员工集合的方式
  60.         List<Person> personListNew2 = personList.stream().map(person -> {
  61.             person.setSalary(person.getSalary() + 10000);
  62.             return person;
  63.         }).collect(Collectors.toList());
  64. 　　}
  65. }

4.排序

sorted() 排序方法

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Person> persionList = new ArrayList<Person>();
  4.         persionList.add(new Person(1, "张三", "男", 8));
  5.         persionList.add(new Person(2, "小小", "女", 2));
  6.         persionList.add(new Person(3, "李四", "男", 25));
  7.         persionList.add(new Person(4, "王五", "女", 8));
  8.         persionList.add(new Person(5, "赵六", "女", 25));
  9.         persionList.add(new Person(6, "大大", "男", 65));
  11.         //根据年龄升序
  12.         persionList = persionList.stream().sorted(Comparator.comparing(Person::getAge)).collect(Collectors.toList());
  13.         persionList = persionList.stream().sorted(Comparator.comparingInt(x -> x.getAge())).collect(Collectors.toList());
  14.         persionList = persionList.stream().sorted((a, b) -> a.getAge().compareTo(b.getAge())).collect(Collectors.toList());
  15.         //根据年龄降序
  16.         persionList = persionList.stream().sorted(Comparator.comparing(Person::getAge).reversed()).collect(Collectors.toList());
  17.         persionList = persionList.stream().sorted((a, b) -> b.getAge().compareTo(a.getAge())).collect(Collectors.toList());
  18.         //根据年龄降序，年龄相同的再根据id升序
  19.         persionList = persionList.stream().sorted(Comparator.comparing(Person::getAge).reversed().thenComparing(Person::getId)).collect(Collectors.toList());
  20.     }
  21. }

Stream 按组分别统计

  1. Map<Long, List<ActivityGift>> groupGifts = gifts.stream().collect(Collectors.groupingBy(ActivityGift::getActivityId, Collectors.toList()));

Stream 按某个值相等统计

  1.  List<Activity> activities = activityMapper.selectBatchIds(groupGifts.keySet());
  2. activities = activities.stream().filter(activity -> activity.getStatus() == status).collect(Collectors.toList());

求list集合中所有value的值

  1. list.stream().mapToDouble(Px::getValue).sum()

求某一属性集合

  1.   Set<String> name= syDailyStatements.stream().map(YcDailyStatement::getSiteName).collect(Collectors.toSet());

利用siteName 把list分成集合组

  1.   Map<String, List<RankVo2>> collect = rankVo2pm25List.stream().collect(Collectors.groupingBy(RankVo2::getSiteName));

求平均值

  1.  List<DayData> pm25List = dayData.stream().filter(s -> s.getPm25() != null).collect(Collectors.toList());
  2.                 if (pm25List != null && pm25List.size() > 0) {
  3.                     double pm25 = pm25List.stream().mapToDouble(DayData::getPm25).average().getAsDouble() * 1000;
  4.                     double getint = getint(pm25, 0);
  5.                     rateData1.setPm25Rate(getint);
  6.                 }

求最大值

  1. double max = hourData1.stream().filter(s -> s.getName() != null && s.getName().equals("PM10")).mapToDouble(HourData::getVal).summaryStatistics().getMax()*1000;
  3. List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
  4. // 自然排序
  5. Optional<Integer> max = list.stream().max(Integer::compareTo);
  6. // 自定义排序
  7. Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
  8.         @Override
  9.         public int compare(Integer o1, Integer o2) {
  10.             return o1.compareTo(o2);
  11.         }
  12. });
  13. System.out.println("自然排序的最大值：" + max.get());
  14. System.out.println("自定义排序的最大值：" + max2.get());
  16. // 求工资最高的
  17. Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));
  19. //获取String集合中最长的元素
  20. List list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
  21. Optional<String> max = list.stream().max(Comparator.comparing(String::length));
  22. System.out.println("最长的字符串：" + max.get());
  24. // 计算Integer集合中大于6的元素的个数。
  25. list.stream().filter(x -> x > 6).count();

选出不同的

  1.  List<String> prices = new LinkedList<>();
  2. prices.stream().distinct().collect(Collectors.toList());

求某一个属性去掉相同的元素

  1. // id是判断是否重复的条件
  2. List<Goods> goodsList = allocationGoodsList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(()->new TreeSet<>(Comparator.comparing(Goods::getRbtPreparation))), ArrayList::new));

求多个属性去掉相同的元素

  1. // 可以多条件去重
  2. ArrayList<PatentDto> collect1 = patentDtoList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(p->p.getPatentName() + ";" + p.getLevel()))), ArrayList::new)

比较过滤

  1. Goods goods = searchResult.getGoodsList().stream().filter(e -> e.getPrices().get(priceId).compareTo(supplyMoney) == 0).findAny().orElse(null);

集合是否包含字符串

  1. KeywordConst.KW_NO.stream().anyMatch(message::contains)

求两个集合对象的交集、并集、差集、去重

  1. package com.ymdd.galaxy.appmanage.core.appauth.service;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import static java.util.stream.Collectors.toList;
  8. public class Test {
  10.     public static void main(String[] args) {
  11.         List<String> list1 = new ArrayList<String>();
  12.         list1.add("1");
  13.         list1.add("2");
  14.         list1.add("3");
  15.         list1.add("5");
  16.         list1.add("6");
  18.         List<String> list2 = new ArrayList<String>();
  19.         list2.add("2");
  20.         list2.add("3");
  21.         list2.add("7");
  22.         list2.add("8");
  24.         // 交集
  25.         List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
  26.         System.out.println("---交集 intersection---");
  27.         intersection.parallelStream().forEach(System.out :: println);
  29.         // 差集 (list1 - list2)
  30.         List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
  31.         System.out.println("---差集 reduce1 (list1 - list2)---");
  32.         reduce1.parallelStream().forEach(System.out :: println);
  34.         // 差集 (list2 - list1)
  35.         List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
  36.         System.out.println("---差集 reduce2 (list2 - list1)---");
  37.         reduce2.parallelStream().forEach(System.out :: println);
  39.         // 并集
  40.         List<String> listAll = list1.parallelStream().collect(toList());
  41.         List<String> listAll2 = list2.parallelStream().collect(toList());
  42.         listAll.addAll(listAll2);
  43.         System.out.println("---并集 listAll---");
  44.         listAll.parallelStream().forEachOrdered(System.out :: println);
  46.         // 去重并集
  47.         List<String> listAllDistinct = listAll.stream().distinct().collect(toList());
  48.         System.out.println("---得到去重并集 listAllDistinct---");
  49.         listAllDistinct.parallelStream().forEachOrdered(System.out :: println);
  51.         System.out.println("---原来的List1---");
  52.         list1.parallelStream().forEachOrdered(System.out :: println);
  53.         System.out.println("---原来的List2---");
  54.         list2.parallelStream().forEachOrdered(System.out :: println);
  56.     }
  57. }

字符串排序

  1.    return registerList.stream().map(item -> {
  2.             item.setCheckoutProductDetails(detailGroup.get(item.getId()));
  3.             final String checkoutReportAttachIds = item.getCheckoutReportAttachIds();
  4.             if (StringUtils.isNotEmpty(checkoutReportAttachIds)) {
  5.                 final String attachesStr = Arrays.stream(checkoutReportAttachIds.split(",")).filter(str -> StringUtils.isNotEmpty(str) && !"undefined".equals(str.toLowerCase())).collect(Collectors.joining(","));
  6.                 item.setSysAttaches(sysAttachMapper.getList(attachesStr));
  7.             }
  8.             return QsCheckoutRegisterService.translationCheckoutRegisterDict(item);
  9.         }).sorted(Comparator.comparing(QsCheckoutRegister::getReCheckCnt, Comparator.comparingInt(p -> Integer.parseInt(String.valueOf(p))))).collect(Collectors.toList());

Collectors.summingDouble() 方法将流中的所有元素视为 Double类型，并计算所有元素的总和 ( sum )

  1.     List<Double> list = Arrays.asList(1.1, 2.2, 3.3, 4.4);
  2.     Double sum = list.stream().collect(Collectors.summingDouble(i -> {
  3.         System.out.println("i -> " + i);
  4.         return i;
  5.     }));
  6.     System.out.println(sum);