JAVA8 常用的stream方法

lambda将list中某一属性相同的数据分组

//（第一个*表示实体类，第二个*表示实体类中属性，如果不是实体类，可直接写）
Map< x,x > Map = list.stream().collect(Collectors.groupingBy(*::get*)); 
// 以videos为key，记录该key相同的对应id集合   key : videos  ====== value : List<id>
Map<String, List<Long>> idCollect = gacCourses.stream().collect(Collectors.groupingBy(GacCourse::getVideos, Collectors.mapping(GacCourse::getId, Collectors.toList())));

//使用lambda表达式
Map<String,List<Person >> personMap =
list.stream().collect(Collectors.groupingBy(Person::getName));
//遍历
for (Map.Entry<String, List<Person >> entry : personMap.entrySet()) { //key是分组条件name
 //通过key取value，value是Person对象，可能有多个，用list取
    List<Object> list11 = (List<Object>) personMap.get(entry.getKey());
    }
}

2.List forEach 遍历对象 List 对某一字段重新赋值
一、Java8 stream 操作

objectList = objectList .stream().map(object -> {
             Object objectNew = new Object();
             BeanUtils.copyProperties(object, objectNew);
             objectNew.setVar("Value");
             return objectNew;
             }).collect(Collectors.toList())

二、List forEach 操作

objectList.forEach(object -> object.setVar("Value"));

3.对数据进行模糊查询操作

/**
         *  传入模糊查询的参数
         */
        Pattern pattern = Pattern.compile("小辉");
        Pattern pattern1 = Pattern.compile("2");

        List list = new ArrayList();
        for(int i=0;i<users.size();i++){
            Matcher matcher = pattern.matcher(users.get(i).getName());
            Matcher matcher1 = pattern1.matcher(users.get(i).getPassword());
            //调用模糊查询方法
            if(matcher.find() || matcher1.find()){
                list.add(users.get(i));
            }
        }

原文链接：https://blog.csdn.net/ligh_sqh/article/details/100010466
https://www.cnblogs.com/luxj/p/8279254.html

4.取成员属性list

List<String> configList = codeEntityList.stream().map(t -> t.getName()).distinct().collect(Collectors.toList());

5.对象的过滤

list.stream().filter(body-> body.getId().equals(entity1.getId())).findAny().get();

6.根据某个属性分组，汇总某个属性

 Map<String, Integer> collect2 = list.stream().collect(Collectors.groupingBy(PersonData::getType,Collectors.summingInt(PersonData::getAge)));

7.根据某个属性添加条件过滤数据，

 list = list.stream().filter(u -> !u.getType().equals("访。客")).collect(Collectors.toList());

8.判断一组对象里面有没有属性值是某个值

boolean add = list.stream().anyMatch(m -> "王五".equals(m.getName()));

9.取出一组对象的某个属性组成一个新集合

List<String> names=list.stream().map(PersonData::getName).collect(Collectors.toList());

List<类> list; 代表某集合

10.返回 对象集合以类属性一升序排序

list.stream().sorted(Comparator.comparing(类::属性一));

11返回 对象集合以类属性一降序排序 注意两种写法

list.stream().sorted(Comparator.comparing(类::属性一).reversed());//先以属性一升序,结果进行属性一降序
 
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));//以属性一降序

12.返回 对象集合以类属性一升序 属性二升序

list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));

13.返回 对象集合以类属性一降序 属性二升序 注意两种写法

list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
 
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序

14.返回 对象集合以类属性一降序 属性二降序 注意两种写法

list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
 
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一降序,再进行属性二降序
 

15.返回 对象集合以类属性一升序 属性二降序 注意两种写法

list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
 
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序<br><br><br>

16.A List B List 根据两对象实体的id，对A进行去重

List<String> bIDs = studentListB.stream().map(o->o.getName()).collect(Collectors.toList());
List<Student> collect = studentListA.stream().filter(o -> !bIDs.contains(o.getName())).collect(Collectors.toList());

17.返回List中匹配属性值的下标

int index = IntStream.range(0, flowElementList.size())
        .filter(i -> flowElementList.get(i).getId().equals(taskDefinitionKey))
        .findFirst().orElse(-1);

18.sorted排序 考虑null值(若不排除null，会报错)

minPriceList.stream().sorted(Comparator.comparing(l -> l.getCreateDate(), Comparator.nullsLast(Date::compareTo))).findFirst().get();

int rejectTime = (int) collect2.stream().map(FlowTaskDTO::getComment).filter(comment -> comment != null && comment.getType().equals("3")).count();

19.求元素的（交集、差集、去重并集）

system.out.println("====求交集===");
list list=list1.stream().filter(t->list2.contains(t)).collect(collectors.tolist());
system.out.println("====求差集===");
list=list1.stream().filter(t-> !list2.contains(t)).collect(collectors.tolist());
system.out.println("====求并集===");
list.addall(list1);
list.addall(list2);
list=list.stream().distinct().collect(collectors.tolist());
相关链接：https://www.xttblog.com/?p=5240

20.利用Collectors.toCollection和TreeSet去重

//  根据videos字段去重
TreeSet<GacCourse> distinctGacCourses = gacCourses.stream().collect(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(GacCourse::getVideos))));