jdk8 流操作

• stream操作

    /** ============================ reduce函数 ============================== */
 
    /**
     * reduce有三类, 分别是一个参数, 两个参数, 三个参数
     * 1、两个参数较一个参数多了一个初始值
     * 2、三个参数较两个参数多了一个并行操作时用于合并操作的函数时接口对象, 因此当串行操作时与两个参数的效果一致
     */
 
    // 一个参数
    @Test
    public void testReduce1() {
        List<Integer> list = Arrays.asList(3, 2, 4, 1);
        System.out.println(list.stream().reduce((acc, tmp) -> acc + tmp).get());
    }
 
    // 两个参数
    @Test
    public void testReduce2() {
        List<Integer> list = Arrays.asList(3, 2, 4, 1);
        System.out.println(list.stream().reduce(100, (acc, tmp) -> acc + tmp).intValue());
    }
 
    // 三个参数
    @Test
    public void testReduce3() {
        // 串行操作
        List<Integer> list = Arrays.asList(3, 2, 4, 1);
        System.out.println(list.stream().reduce(100
                , (acc, tmp) -> acc + tmp
                , (a, b) -> a + b).intValue());  // out ==> 110
 
        // 并行操作
        System.out.println(list.stream().parallel().reduce(100
                , (acc, tmp) -> acc + tmp
                , (a, b) -> a + b).intValue());  // out ==> 410
        /**
         * 分析：
         * list集合中四个值并行执行, 分别与初始值100相加后, 再进行合并操作, 即：
         * 1）3+100=103, 2+100=102, 4+100=104, 1+100=101
         * 2）103+102+104+101=410
         */
    }

• list排序

List<类> list; 代表某集合
 
//返回 对象集合以类属性一升序排序
list.stream().sorted(Comparator.comparing(类::属性一));
 
//返回 对象集合以类属性一降序排序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed());//先以属性一升序,结果进行属性一降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));//以属性一降序
 
//返回 对象集合以类属性一升序 属性二升序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));
 
//返回 对象集合以类属性一降序 属性二升序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序
 
//返回 对象集合以类属性一降序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一降序,再进行属性二降序
 
//返回 对象集合以类属性一升序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序

//空/Null数据排序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(item -> item.属性二, Comparator.nullsLast(Date::compareTo))).collect(Collectors.toList());

//空/Null数据分组
Map<String, List<类>> map = list.stream().collect(Collectors.groupingBy(item -> {
  if (item.属性一 == null || item.属性一.equals("")) {
  　　return "";
  }
  return DateFormat.getDateInstance().format(item.属性一);
}))

• list 按指定条数分割

        Integer MAX_SEND = 3;
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");
        list.add("7");

        List<List<String>> splitList = Stream.iterate(0, n -> n + 1).limit(list.size() / MAX_SEND + 1).parallel()
                .map(a -> {
                    List<String> sendList = list.stream()
                            .skip(a * MAX_SEND)
                            .limit(MAX_SEND)
                            .parallel()
                            .collect(Collectors.toList());
                    return sendList;
                })
                .collect(Collectors.toList());

        System.out.println(1);