java8 对集合的操作，stream()流操作

去重 distinct() 去重；collect(Collectors.toList())。封装成集合

List<Person> distinctList = list.stream().distinct().collect(Collectors.toList());

collectingAndThen去重（根据对象里面的某个字段进行去重）

List<ProductReq> paperRecordList = productList.stream().collect(
        Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(ProductReq::getProductFullName))), ArrayList::new));

collectingAndThen去重（根据对象里面的多个字段进行去重）

ArrayList<ProductReq> paperRecordList = list.stream().collect(
        Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(item->item.getUserId()+"_"+item.getPassStatus()))), ArrayList::new));

Collectors.toMap去重

去重取旧对象：

List<ProductReq> paperRecordList = new ArrayList<>(productList.stream().collect(Collectors.toMap(ProductReq :: getProductFullName, Function.identity(), (oldValue, newValue) -> oldValue)).values());

排序 ?sorted((第一个对象，第二个对象)->返回值) ?（升降序看是第几个对象与第几个对象比较）

List<Person> sortedList = list.stream().sorted((o1,o2)->o1.getAge()-o2.getAge()).collect(Collectors.toList());

//按照年龄升序

list.stream().sorted(Comparator.comparing(Student::getAge)) 

//按照年龄降序

list.stream().sorted(Comparator.comparing(Student::getAge).reversed()) 

排序空字段排在前面

list.stream().sorted(Comparator.comparing(l -> l.getCreateTime(), Comparator.nullsFirst(Date::compareTo))).collect(toList());

排序空字段排在后面
toOrderList.stream().sorted(Comparator.comparing(l -> l.getContractCode(), Comparator.nullsFirst(String::compareTo))).collect(toList());

按年龄排序(Integer类型)

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

排序，按日期倒叙，null日期排在最后
investmentManagers.sort(Comparator.comparing(ProductDetailReq.productFormerInvestmentManagersReq::getTermOfOfficeStartDate, Comparator.nullsLast(Comparator.reverseOrder())));

过滤 ， filter(item->{}) ? item为每一项。 按照自己的需求来筛选list中的数据

List<Person> filterList = list.stream().filter(item->item.getAge()>3).collect(Collectors.toList());

map(), 提取对象中的某一元素. ?用每一项来获得属性（也可以直接用 ?对象::get属性()）

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

List<String> mapList2 = list.stream().map(item->item.getName()).collect(Collectors.toList());

统计 sum() 。mapToDouble() 转换成double。还有其他类型转换。可以自己研究。

double sum = list.stream().mapToDouble(Person::getAge).sum();

list.stream().mapToDouble(User::getHeight).sum()//和
list.stream().mapToDouble(User::getHeight).max()//最大
list.stream().mapToDouble(User::getHeight).min()//最小
list.stream().mapToDouble(User::getHeight).average()//平均值
BigDecimal quitMoney = quitList.stream().filter(item -> item.getTradeType() == 1).map(SelectListByCustomerIdRsp::getTradeMoney).reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, RoundingMode.HALF_UP);

分组 ? Collectors.groupingBy(属性名)

Map<Integer, List<Person>> map = list.stream().collect(Collectors.groupingBy(Person::getAge));

多重分组 Collectors.groupingBy(属性，Collectors.groupingBy(属性))

Map<String, Map<Integer, List<Person>>> map2 = list.stream().collect(Collectors.groupingBy(t->t.getName(),Collectors.groupingBy(t->t.getAge())));

分组并计算综合 ? Collectors.summarizingLong()

Map<String, Map<Integer, LongSummaryStatistics>> map3 = list.stream().collect(Collectors.groupingBy(t->t.getName(),Collectors.groupingBy(t->t.getAge(),Collectors.summarizingLong(Person::getSize))));

将list转你为map

Map<String, Person> collect = carModels.stream().collect(Collectors.toMap(Person::getName, (p) -> p));

集合比较的简写方式

list.sort((o1,o2)->{return o1.getAge()-o2.getAge();});

根据筛选条件对list进行过滤

List<ContractVO> filterList = result.stream().filter(item->
        {
            boolean flag =true;
            if(StringUtils.isNotBlank(dto.getCustomer())){
                flag = item.getCustomer().equals(dto.getCustomer());
            }
            String dept = null == dto.getDept() ? "" : dto.getDept();
            if (StringUtils.isNotBlank(dto.getDept())){
                flag = dept.equals(dto.getDept())&&flag;
            }
            String manager = null == dto.getManager() ? "" : dto.getManager();
            if (StringUtils.isNotBlank(dto.getManager())){
                flag = manager.equals(dto.getManager())&&flag;
            }
            BigDecimal balance = null == item.getBalance() ? BigDecimal.ZERO:item.getBalance();
            if (null != dto.getBalanceMin()){
                flag = balance.compareTo(dto.getBalanceMin())>=0&&flag;
            }
            if (null != dto.getBalanceMax()){
                flag = balance.compareTo(dto.getBalanceMin())<=0&&flag;
            }
            int invalidDays = null == item.getInvalidDays() ? 0 : item.getInvalidDays();
            if (null != dto.getInvalidDaysMin()){
                flag = invalidDays>=dto.getInvalidDaysMin()&&flag;
            }
            if (null != dto.getInvalidDaysMax()){
                flag = invalidDays<=dto.getInvalidDaysMax()&&flag;
            }
            return flag;
        }
).collect(Collectors.toList());
}

计算求和

resultList.stream().map(vo -> ObjectUtils.isEmpty(vo.getFeeNetValue()) ? new BigDecimal(0) : vo.getFeeNetValue()).reduce(BigDecimal.ZERO, BigDecimal::add);

String转List＜Long＞

  Arrays.stream(strArr.split(",")).map(s -> Long.parseLong(s.trim())).collect(Collectors.toList());

字符转转集合同时进行数据类型转换

List<Long> strings = Stream.of(param.split(",")).map(Long::parseLong).collect(Collectors.toList());