java 8小技巧使用（未完待续）

1 按照对象属性分组，每个值多少个。

  Map<String, List<PersonPosition>> collect = list.stream()
                    .collect(Collectors.groupingBy(PersonPosition::getTypeOfWork));

结果

2 两个List「String」进行匹配。取交集，并集，等。

链接：

https://blog.csdn.net/qq_32230309/article/details/107321802

3 遍历map

 TreeMap<String, Object> queryTimeMap = new TreeMap<>();
queryTimeMap.entrySet().iterator().forEachRemaining(item -> System.out.println("key:value=" + item.getKey() + ":" + item.getValue()));

4 根据对象属性去重

 //进行人员卡去重。
        List<PostingDownholeCheck> resultStaticScNew = resultStatic.stream().collect(
                Collectors.collectingAndThen(
                        Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(PostingDownholeCheck::getCardCode))), ArrayList::new)
        );

5 根据对象属性排序

//先根据年龄然后按照性别
listDevs.sort(Comparator.comparing(User::getAge).thenComparing(User::getSex));

6 根据属性对比进行数据筛选

其中paperMoney（返回来的值是100.00这样的所以用Double去接） 和buildName是resourceBuildAndBuildRelationDataByUnitName返回来的值的别名，getValueCost和getName是相对应的比对值。

 // 比对出相同的数据
        List<Map<String,Object>> list ;
        List<JiuQiImportModelDto>  resourceBuildDtos;
        List list1;
        //遍历文件
            jiuQiImportModelDtos = ExcelUtil.readExcel(file, JiuQiImportModelDto.class, 0);
            list =  resourceBuildRepository.resourceBuildAndBuildRelationDataByUnitName(resourceStr);
            resourceBuildDtos = jiuQiImportModelDtos.stream()
                    .filter(item -> list.stream()
                            .map(e -> Double.valueOf(e.get("paperMoney").toString()))
                            .collect(toList())
                         .contains(Double.valueOf(item.getValueCost())))
                    .filter(item -> list.stream()
                            .map(e -> e.get("buildName").toString())
                            .collect(toList())
                            .contains(item.getName()))
                    .collect(toList());

7 将获取的json串中的某个Key中的value值进行类型转换

//转换成Long
List<Long> unitIds = jsonObject.getJSONArray("unitIds").stream().map(Convert::toLong).collect(Collectors.toList());
//转成Int类型
List<Integer> typeList = jsonObject.getJSONArray("type").stream().map(Convert::toInt).collect(Collectors.toList());

8 根据一个实体中的一个属性遍历将一个新的Lits 添加值

List<EquipmentAsset> assetList = equipmentAssetRepository.findAllByDelFlgAndNumber(numberList);
 List<Long> listIds = new ArrayList<>();
 assetList.forEach(asset -> listIds.add(asset.getId()));

此时listIds是assetList 实体中id的遍历。

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

package cn.cmsblogs.util.stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class SummingIntExample {
    public static void main(String[] args) {
       List<Integer> list = Arrays.asList(30,10,20,35);
       int result = list.stream().collect(Collectors.summingInt(i->i));
       System.out.println(result);
    }
}

输出结果为 95

Collectors.summingLong()，Collectors.summingDouble()一样。

10 Collectors.toList()

package cn.cmsblogs.util.stream;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class ToListExample {
    public static void main(String[] args) {
       List<String> list = Stream.of("AA","BB","CC").collect(Collectors.toList());
       list.forEach(s->System.out.println(s));
    }
}

Collectors.toSet()，Collectors.toMap()一样。

11 Collectors.mapping()

Collectors.mapping() 一般用于多重 map and reduce 中。 Java 文档中描述的原型如下

mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)

第一个参数用于 map ，第二个参数用于 reduce

package cn.cmsblogs.util.stream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class MappingDemo {
    public static void main(String[] args) {
        List<Person> list = Person.getList();
        Map<Integer, String> nameByAge
           = list.stream().collect(Collectors.groupingBy(Person::getAge, 
                   Collectors.mapping(Person::getName, Collectors.joining(","))));
        nameByAge.forEach((k,v)->System.out.println("Age:"+k +"  Persons: "+v));
    }   
}
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public static List<Person> getList() {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Ram", 30));
        list.add(new Person("Shyam", 20));
        list.add(new Person("Shiv", 20));
        list.add(new Person("Mahesh", 30));
        return list;
    }
}

输出结果如下

Age:20  Persons: Shyam,Shiv
Age:30  Persons: Ram,Mahesh

12 求平均值

Collectors.averagingDouble()
Collectors.averagingDouble() 方法将流中的所有元素视为 double 类型并计算他们的平均值。该方法返回的是同一个 Collectors 实例，因此可以进行链式操作。

Collectors.averagingDouble() 接受一个参数，这个参数是一个 lambda 表达式，用于对所有的元素执行一个 map 操作。

Java 所有集合的 stream().collect() 可以接受一个收集器实例作为其参数并返回该收集器的计算结果

例如下面的代码，collect() 方法会把所有的元素收集起来然后传递给 Collectors.averagingDouble(d->d*2) 收集器，对每个元素执行 *2 操作后计算平均值

package cn.cmsblogs.util.stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class AveragingDoubleExample {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4);
        Double result = list.stream().collect(Collectors.averagingDouble(d->d*2));
        System.out.println(result);
    }
}

输出结果为 5.0
Collectors.averagingInt()，Collectors.averagingLong()一样。

13 统计个数

Collectors.counting()

package cn.cmsblogs.util.stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class CountingExample {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4);
       long result=  list.stream().collect(Collectors.counting());
       System.out.println(result);
    }
}

结果为：4

14 所有元素拼接成一个字符串

Collectors.joining()

package cn.cmsblogs.util.stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class JoiningExample {
    public static void main(String[] args) {
       List<String> list = Arrays.asList("A","B","C","D");
       String result=  list.stream().collect(Collectors.joining(",","(",")"));
       System.out.println(result);
    }
}

输出结果为 (A,B,C,D)

15 求最大最小值

Collectors.maxBy() 和 Collectors.minBy()

package cn.cmsblogs.util.stream;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
public class MaxByMinByExample {
    public static void main(String[] args) {
       List<Integer> list = Arrays.asList(30,10,20,35);
       //Get Max       
       list.stream().collect(Collectors.maxBy(new MaxByMinByExample().new IntegerComp()))
               .ifPresent(i->System.out.println(i));
       //Get Min
       list.stream().collect(Collectors.minBy(new MaxByMinByExample().new IntegerComp()))
               .ifPresent(i->System.out.println(i));
    }
    class IntegerComp implements Comparator<Integer> {
        @Override
        public int compare(Integer i1, Integer i2) {
          if(i1 >=i2 ){
              return 1;
          }else{
              return -1;
          }
        }
    }
}

输出结果如下

35
10

16 List对象分组根据日期分组，最大值减去最小值求区间的值是多少

   private static String totalUse(List<WaterUseIndexNew> devicelist) {
        Map<String, List<WaterUseIndexNew>> deviceDataMap = devicelist.stream().collect(Collectors.groupingBy(WaterUseIndexNew::getDeviceName));
        AtomicReference<String> totalUse = new AtomicReference<>("0");
        deviceDataMap.forEach((k, deviceLogList) -> {
            deviceLogList.sort(Comparator.comparing(u -> new Double(u.getWaterDeviceLastData())));
            OptionalDouble currentMonthMax = deviceLogList.stream().mapToDouble(map -> Double.parseDouble(map.getWaterDeviceLastData())).max();
            OptionalDouble currentMonthMin = deviceLogList.stream().mapToDouble(map -> Double.parseDouble(map.getWaterDeviceLastData())).min();
            BigDecimal sub = ArithmeticUtil.sub(currentMonthMax.getAsDouble()+"", currentMonthMin.getAsDouble()+"");
            String use = ArithmeticUtil.add(totalUse.get(), sub.toString()).toString();
            totalUse.set(use);
        });
        return totalUse.get();
    }

这是一个企业中的一个日期的区间数，如果想取这个日期区间的好几个企业的累计区间值也可以使用该方法

按照日期分组的sql如下：

SELECT
        id.device_name deviceName,
        DATE( idln.create_time ) AS days,
        REPLACE (( FORMAT( log_value, 2 )), ',', '' ) AS waterDeviceLastData
        FROM
        iot_device_log_new idln
        LEFT JOIN iot_device id ON idln.device_id = id.device_id
        WHERE 1=1
        <if test='status != null and status != ""'>
            AND id.`status` = #{status}
        </if>
        AND id.del_flag = 0
        <if test='waterType != null and waterType != ""'>
            AND id.water_type = #{waterType}
        </if>
        AND idln.create_time BETWEEN #{startTime}
        AND #{endTime}
        <if test='deviceApplyType != null and deviceApplyType != "" '>
            AND id.device_apply_type in ${deviceApplyType}
        </if>
        <if test='deptIdList != null and deptIdList != ""'>
            AND dept_id in ${deptIdList}
        </if>
        <if test='deviceId != null and deviceId != ""'>
            AND idln.device_id = #{deviceId}
        </if>
        GROUP BY deviceName, days