java 8 常用方法总结

这里对java 8常用方法进行总结

1：对List对象的某个属性进行排序

IPage pageList = new Page<>();

1. 降序（不支持属性存在null的属性）

pageList.getRecords().stream().sorted(Comparator.comparing(SysUser::getRoleNames).reversed()).collect(Collectors.toList());

3. 升序（不支持属性存在null的属性）

pageList.getRecords().stream().sorted(Comparator.comparing(SysUser::getRoleNames)).collect(Collectors.toList());

4. 降序（支持字段为null的属性）

pageList.getRecords().stream().sorted(Comparator.comparing(SysUser::getSeatNo,Comparator.nullsLast(String::compareTo)).reversed()).collect(Collectors.toList());

5. 升序（支持字段为null的属性）

pageList.getRecords().stream().sorted(Comparator.comparing(SysUser::getSeatNo,Comparator.nullsLast(String::compareTo))).collect(Collectors.toList());

6. 降序升序工具类

package com.csp.common.util;

import java.math.BigDecimal;
import java.util.Comparator;
import java.util.Date;

/**
 * @Author: LL
 * @Description: 含空值的排序工具 根据对象的某一属性值进行排序
 * @Date: Create in 10:15 2020/12/29
 */
public class ComparatorUtils {
    /**
     * 支持NULL排序 升序
     * 1、null 会排前面
     *
     * @param propertyPredicate 属性
     * @param <T>
     * @return
     */
    public static <T> Comparator<T> sort(ObjectPropertyPredicate<T> propertyPredicate) {
        Comparator<T> comparator = (obj1, obj2) -> {
            Object v1 = propertyPredicate.getProperty(obj1);
            Object v2 = propertyPredicate.getProperty(obj2);
            if (v1 == v2) {
                return 0;
            } else if (v1 == null) {
                return -1;
            } else if (v2 == null) {
                return 1;
            }
            if (v1 instanceof Integer) {
                return (Integer) v1 - (Integer) v2;
            } else if (v1 instanceof Date) {
                return ((Date) v1).compareTo((Date) v2);
            } else if (v1 instanceof BigDecimal) {
                return ((BigDecimal) v1).compareTo((BigDecimal) v2);
            }
            return v1.toString().compareTo(v2.toString());
        };
        return comparator;
    }

    /**
     * 支持NULL排序 降序
     * 1、null 会排后面
     *
     * @param propertyPredicate 属性
     * @param <T>
     * @return
     */
    public static <T> Comparator<T> sortDesc(ObjectPropertyPredicate<T> propertyPredicate) {
        Comparator<T> comparator = (obj1, obj2) -> {
            Object v1 = propertyPredicate.getProperty(obj1);
            Object v2 = propertyPredicate.getProperty(obj2);
            if (v1 == v2) {
                return 0;
            } else if (v1 == null) {
                return 1;
            } else if (v2 == null) {
                return -1;
            }
            if (v1 instanceof Integer) {
                return (Integer) v2 - (Integer) v1;
            } else if (v1 instanceof Date) {
                return ((Date) v2).compareTo((Date) v1);
            } else if (v1 instanceof BigDecimal) {
                return ((BigDecimal) v2).compareTo((BigDecimal) v1);
            }
            return v2.toString().compareTo(v1.toString());
        };
        return comparator;
    }

}

package com.csp.common.util;

@FunctionalInterface
public interface ObjectPropertyPredicate<T> {
    /**
     * 把属性当参数传递到方法中，由方法去处理这个属性的值做什么。
     * 传参使用: o -> o.propertyName
     * 接收参数方法内使用:
     *  参数：ObjectPropertyPredicate<FreeReportDataVO> express
     *  Predicate<Object> press = (obj) -> express.getProperty(obj).toString().startsWith("测试");
     *  express.getProperty(obj)
     * @param o
     * @return
     */
    Object getProperty(T o);
}

7. 工具类使用

//升序
pageList.getRecords().sort(ComparatorUtils.sort(s->s.getSeatNo()));
//降序
pageList.getRecords().sort(ComparatorUtils.sortDesc(s->s.getSeatNo()));

2：提取List< Map< String,Object > >的某个属性数据

提取对象中的id 这里的Object是一个实体（用户）对象
这里有一个转换
List Object 转换成List String
List strs = (List)(List)objList

List<String> userIds =  (List<String>)(List)dataList.stream().map(e -> e.get("id")).collect(Collectors.toList());

3：java8 stream：从集合中获取符合条件的元素

从list部门集合中获取id等于actionId那条对象的部门名称，获取第一个，如果没有赋值空字符串

List<SysDepartUsersOTM> sysDeparts = sysDepartMapper.getSysDepartListByCompany(sysUser.getCompanyId());
sysDeparts.stream().filter(o->o.getId().equals(actionID)).map(SysDepartUsersOTM::getDepartName).findFirst().orElse("")

4：对List< Map< String,Object > >的某个属性进行求和

List

//假如Map集合有一个属性为readyCoun
//那么对这个kay值的value数据进行求和的方式为以下语句
exportList.stream().map(s -> new BigDecimal(s.get("readyCount").toString())).reduce(BigDecimal.ZERO, BigDecimal::add)

5：对List< Map< String,Object > >的某个属性进行求和，平均值，最大值，最小值，总数

通过statistics.get"对应的方法"（）；获取对应的数据；

IntSummaryStatistics  statistics =(IntSummaryStatistics)  exportList.stream().collect(Collectors.summarizingInt(e -> Integer.valueOf(((Map) e).get("inCalls").toString())));
System.out.println(statistics);
Double avg = statistics.getAverage();
System.out.println("平均值："+avg);
//outInput
//IntSummaryStatistics{count=10, sum=14, min=0, average=1.400000, max=7}
//平均值：1.4

6：stream的map和filter怎么混用

 List<String> collect2 = collect.stream().filter(x -> x.getType() == 1).map(x -> x.getPicUrl()).collect(Collectors.toList());

7：对list先分组再排序

1. 分组

 list.stream().collect(Collectors.groupingBy(MeetingAgent::getCompletionStatus))

2. 排序（升序）

List<MeetingAgent> studentsSortName = studentList.stream().sorted(Comparator.comparing(StudentInfo::getAge)).collect(Collectors.toList());

3. 排序（倒序）

List<MeetingAgent> studentsSortName = studentList.stream().sorted(Comparator.comparing(StudentInfo::getAge).reversed()).collect(Collectors.toList());

4. 分组后排序(先按照类型分组，再按时间倒叙排序)

 List<MeetingAgent> list = new ArrayList<>();
 List<MeetingAgent> result = new ArrayList<>();
        list.stream().collect(Collectors.groupingBy(MeetingAgent::getCompletionStatus)).forEach((k, v) -> {
            result.addAll(v.stream().sorted(Comparator.comparing(MeetingAgent::getCreateTime).reversed()).collect(Collectors.toList()));
        });

8：对list集合的去重，按照某个属性

使用说明：假如你有一个list用户集合，你想每个年龄只要一条，那么就可以用年龄作为条件，o1,o2，是返回数据在集合中靠前的还是靠后的。

 List<User> collectCost = listCost.stream().collect(Collectors.toMap(User::getAge, a -> a, (o1, o2) -> {
                    return o1;
                })).values().stream().collect(Collectors.toList());

9：Java lambda 单/多列分组后多列求和

@Data
    public class Student{
        public Student() {
        }

        public Student(String code, String name, Long chengJi, Integer age, BigDecimal value) {
            this.code = code;
            this.name = name;
            this.chengJi = chengJi;
            this.age = age;
            this.value = value;
        }

        private String code;
        private String name;
        private Long chengJi;
        private Integer age;
        private BigDecimal value;

    }
    @Test
    public void lambda() {
    	//单列分组请求
        List<Student> studentList = new ArrayList();
        studentList.add(new Student("a","am",1L,2,new BigDecimal(3)));
        studentList.add(new Student("a","am1",1L,2,new BigDecimal(3)));
        studentList.add(new Student("b","bm1",1L,2,new BigDecimal(3)));
        List<Student> collect = studentList.stream().collect(Collectors.groupingBy(Student::getCode,
                Collectors.reducing((sum, s) ->
                        new Student(s.code, s.name, sum.chengJi + sum.chengJi,
                                sum.age + s.age, sum.value.add(s.value)))
        )).entrySet().stream().map(c -> c.getValue().get()).collect(Collectors.toList());
        System.out.println(collect);
    }
      @Test
    public void lambda() {
    	//多列分组请求
              List<Student> studentList = new ArrayList();
        studentList.add(new Student("a","am",1L,2,new BigDecimal(3)));
        studentList.add(new Student("a","am1",1L,2,new BigDecimal(3)));
        studentList.add(new Student("a","am1",1L,2,new BigDecimal(3)));
        studentList.add(new Student("b","bm1",1L,2,new BigDecimal(3)));
        List<Student> collect1 = studentList.stream().collect(Collectors.groupingBy(wr ->
                        Arrays.asList(wr.getCode(), wr.getName()),
                Collectors.reducing((sum, s) ->
                        new Student(s.code, s.name, sum.chengJi + sum.chengJi,
                                sum.age + s.age, sum.value.add(s.value)))
        )).entrySet().stream().map(c -> c.getValue().get()).collect(Collectors.toList());
        System.out.println(collect1);
    }

     return this.icProjectCapitalInvestmentDetailsMapper.projectFundPlanLineChart(request).stream().collect(Collectors.groupingBy(IcProjectCapitalInvestmentDetails::getRemark,
                Collectors.reducing((sum, s) ->
                        IcProjectCapitalInvestmentDetails.builder()
                                .plannedInvestment(DoubleUtils.add(s.getPlannedInvestment(),sum.getPlannedInvestment()))
                                .financialSection(DoubleUtils.add(s.getFinancialSection(),sum.getFinancialSection()))
                                .remark(s.getRemark())
                                .planOrder(s.getPlanOrder())
                                .build())))
                .entrySet().stream().map(c -> c.getValue().get()).sorted(Comparator.comparing(IcProjectCapitalInvestmentDetails::getPlanOrder)).collect(Collectors.toList());

打印结果

[OtherTest.Student(code=a, name=am1, chengJi=2, age=4, value=6), OtherTest.Student(code=b, name=bm1, chengJi=1, age=2, value=3)]
[OtherTest.Student(code=b, name=bm1, chengJi=1, age=2, value=3), OtherTest.Student(code=a, name=am1, chengJi=2, age=4, value=6), OtherTest.Student(code=a, name=am, chengJi=1, age=2, value=3)]

10：Java lambda 多列求和

          metaList.stream().collect(Collectors.reducing((sum, s) ->
                    IcInvestmentDynamicsEngineeringConstructionService.IcInvestmentDynamicsEngineeringConstruction
                            .builder()
                            .aH(DoubleUtils.add(sum.getAH(), s.getAH()))
                            .aB(DoubleUtils.add(sum.getAB(), s.getAB()))
                            .build()
            )).stream().collect(Collectors.toList());

11：Java8两个集合(List)取交集、并集、差集、去重并集

import java.util.ArrayList;
import java.util.List;

import static java.util.stream.Collectors.toList;

/**
 * @author ming
 * @version 1.0.0
 * @date 2020/6/17 14:44
 **/
public class CollectionsTest {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        list1.add("1");
        list1.add("2");
        list1.add("3");
        list1.add("4");
        list1.add("5");

        List<String> list2 = new ArrayList<>();
        list2.add("2");
        list2.add("3");
        list2.add("6");
        list2.add("7");

        // 交集
        List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
        System.out.println("---交集 intersection---");
        intersection.parallelStream().forEach(System.out::println);

        // 差集 (list1 - list2)
        List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
        System.out.println("---差集 reduce1 (list1 - list2)---");
        reduce1.parallelStream().forEach(System.out::println);

        // 差集 (list2 - list1)
        List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
        System.out.println("---差集 reduce2 (list2 - list1)---");
        reduce2.parallelStream().forEach(System.out::println);

        // 并集
        List<String> listAll = list1.parallelStream().collect(toList());
        List<String> listAll2 = list2.parallelStream().collect(toList());
        listAll.addAll(listAll2);
        System.out.println("---并集 listAll---");
        listAll.parallelStream().forEachOrdered(System.out::println);

        // 去重并集
        List<String> listAllDistinct = listAll.stream().distinct().collect(toList());
        System.out.println("---得到去重并集 listAllDistinct---");
        listAllDistinct.parallelStream().forEachOrdered(System.out::println);
      ---交集 intersection---
		3
		2
		---差集 reduce1 (list1 - list2)---
		4
		5
		1
		---差集 reduce2 (list2 - list1)---
		7
		6
		---并集 listAll---
		1
		2
		3
		4
		5
		2
		3
		6
		7
		---得到去重并集 listAllDistinct---
		1
		2
		3
		4
		5
		6
		7
        //---原来的List1---
        //1
        //2
        //3
        //5
        //6
        //---原来的List2---
        //2
        //3
        //7
        //8
    }

}

12: Java lambda 分组后多列求和转map

            Map<String, IctVisaClaimsService.IctVisaClaims> ictVisaClaims = ChainWrappers.lambdaQueryChain(ictVisaClaimsMapper)
                    .eq(IctVisaClaimsService.IctVisaClaims::getDelFlag, Constant.DEL_FLAG_0)
                    .eq(IctVisaClaimsService.IctVisaClaims::getProjectId, item.getId())
                    .list().stream().collect(Collectors.groupingBy(IctVisaClaimsService.IctVisaClaims::getContractName, Collectors.reducing((sum, s) ->
                            IctVisaClaimsService.IctVisaClaims
                                    .builder()
                                    .contractName(sum.getContractName())
                                    .applyAmount(DoubleUtils.add(sum.getApplyAmount(), s.getApplyAmount()))
                                    .fullCapitalAuditAmount(DoubleUtils.add(sum.getFullCapitalAuditAmount(), s.getFullCapitalAuditAmount()))
                                    .ownersApprovalAmount(DoubleUtils.add(sum.getOwnersApprovalAmount(), s.getOwnersApprovalAmount()))
                                    .build())))
                    .entrySet().stream().
                            map(c -> c.getValue().get()).sorted(Comparator.comparing(IctVisaClaimsService.IctVisaClaims::getCreateTime)).collect(Collectors.toList())
                    .stream().collect(Collectors.toMap(IctVisaClaimsService.IctVisaClaims::getContractName, Function.identity(), (key1, key2) -> key2));

30：参考地址

1. 地址一
2. 地址二
3. 地址三
4. 地址四
5. 地址五