Lambda操作记录二

package com.segi.uhomecp.meter.test;

import com.alibaba.fastjson.JSON;
import com.segi.uhomecp.meter.test.vo.People;
import com.segi.uhomecp.meter.test.vo.Student;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test4 {

        public static void main(String[] args) {
            //Collectors toMap
            List<Student> list=new ArrayList<>();
            Map<Integer, Student> collect1 = list.stream().collect(Collectors.toMap(Student::getId, student -> student));
            List<Student> list2 = new ArrayList<Student>();
            list2.add(new Student(1, "Mahesh", 12));
            list2.add(new Student(2, "Suresh", 15));
            list2.add(new Student(3, "Nilesh", 10));
            list2.add(new Student(4, "Ailesh", 17));
            list2.add(new Student(5, "Dilesh", 13));
            list2.add(new Student(6, "Dilesh", 18));
            list2.add(new Student(6, "Dilesh", 18));
            //List集合转 Map
            List<People> peopleList=new ArrayList<People>();
            peopleList.add(new People("test6", "666"));
            peopleList.add(new People("test7", "777"));
            peopleList.add(new People("test1", "222"));
            peopleList.add(new People("test1", "111"));
            peopleList.add(new People("test2", "222"));
            peopleList.add(new People("test3", "333"));
            peopleList.add(new People("test4", "444"));
            peopleList.add(new People("test5", "555"));
            Map<String, List<People>> collect5 = peopleList.stream().collect(Collectors.groupingBy(People::getName));
            System.out.println(collect5);
            Map<String, String> collect = peopleList.stream().collect(Collectors.toMap(People::getName, People::getAge,(key1,key2)->key2));
            System.out.println(collect);
            //Collectors toList
            List<Integer> collect2 = Stream.of(1, 2, 3, 4, 5, 6, 6).map(a->a+a).collect(Collectors.toList());
            System.out.println(collect2);
            //map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数：
            List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
            // 获取对应的平方数
            List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
            System.out.println(squaresList);
            //Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：
            List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
            List<String> collect3 = strings.stream().filter(s -> !s.isEmpty()).collect(Collectors.toList());
            String collect4 = strings.stream().filter(s -> !s.isEmpty()).map(s -> s+"1").collect(Collectors.joining(","));
            System.out.println(collect3);System.out.println(collect4);
            //一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上，它们可以用来产生类似如下的统计结果。
            IntSummaryStatistics intSummaryStatistics = numbers.stream().mapToInt(x -> x).summaryStatistics();
            System.out.println(intSummaryStatistics);
            List<Student> collect7 = list2.stream().sorted(Comparator.comparing(Student::getAge).reversed()).collect(Collectors.toList());
            System.out.println(JSON.toJSON(collect7));
            final String collect6 = list2.stream().collect(Collectors.mapping(Student::getName, Collectors.joining(",", "[", "]")));
            System.out.println(collect6);
            Map<Integer, String> collect8 = list2.stream().collect(Collectors.groupingBy(Student::getId, Collectors.mapping(Student::getName, Collectors.joining(",", "[", "]"))));
            System.out.println(collect8);
            // //1.1根据某个属性分组计数
            Map<String, Long> collect9 = list2.stream().collect(Collectors.groupingBy(Student::getName, Collectors.counting()));
            System.out.println(collect9);
            //1.2根据整个实体对象分组计数,当其为String时常使用
            Map<Student, Long> collect10 = list2.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
            System.out.println(JSON.toJSON(collect10));
            //1.3根据分组的key值对结果进行排序、放进另一个map中并输出
            Map<String,Long> xMap=new HashMap<>();
            collect9.entrySet().stream().sorted(Map.Entry.<String, Long>comparingByKey().reversed()).forEachOrdered(x->xMap.put(x.getKey(),x.getValue()));
            System.out.println(xMap);
            //2.分组，并统计其中一个属性值得sum或者avg:id总和
            Map<Integer, Integer> collect11 = list2.stream().collect(Collectors.groupingBy(Student::getId, Collectors.summingInt(Student::getAge)));
            System.out.println(collect11);


            //Collectors 的方法操作集合
            List<String> list3 = Arrays.asList("11","3","134","1544","16444","73","318","3320");
            //生成一个用于获取最小/最大值的Optional结果的Collector。
            Optional<String> collect12 = list3.stream().max((a, b) -> a.length() - b.length());
            System.out.println(collect12);
            //生成一个用于求元素和的Collector，首先通过给定的mapper将元素转换类型，然后再求和。参数的作用就是将元素转换为指定的类型，最后结果与转换后类型一致。
            int i = list3.stream().limit(2).collect(Collectors.summingInt(Integer::valueOf));
            long l = list3.stream().limit(5).collect(Collectors.summingLong(Long::valueOf));
            double d = list3.stream().limit(6).collect(Collectors.summingDouble(Double::valueOf));
            System.out.println(i +"\n" +l + "\n" + d);
             无初始值的情况，返回一个可以生成Optional结果的Collector
            System.out.println(list3.stream().limit(2).map(String::length).collect(Collectors.reducing(Integer::sum)));
             有初始值的情况，返回一个可以直接产生结果的Collector
            System.out.println(list3.stream().limit(3).map(String::length).collect(Collectors.reducing(0, Integer::sum)));
             有初始值，还有针对元素的处理方案mapper，生成一个可以直接产生结果的Collector，元素在执行结果操作op之前需要先执行mapper进行元素转换操作
            System.out.println(list3.stream().limit(4).collect(Collectors.reducing(0,String::length,Integer::sum)));
            //groupingBy
            // 只需一个分组参数classifier，内部自动将结果保存到一个map中，每个map的键为?类型（即classifier的结果类型），值为一个list，这个list中保存在属于这个组的元素。
            Map<Integer,List<String>> s = list3.stream().collect(Collectors.groupingBy(String::length));
            // 在上面方法的基础上增加了对流中元素的处理方式的Collector，比如上面的默认的处理方法就是Collectors.toList()
            Map<Integer,List<String>> ss = list3.stream().collect(Collectors.groupingBy(String::length, Collectors.toList()));
            // 在第二个方法的基础上再添加了结果Map的生成方法。
            Map<Integer,Set<String>> sss = list3.stream().collect(Collectors.groupingBy(String::length,HashMap::new,Collectors.toSet()));
            System.out.println(s.toString() + "\n" + ss.toString() + "\n" + sss.toString());
            //只需一个校验参数predicate
            Map<Boolean,List<String>> map = list3.stream().collect(Collectors.partitioningBy(e -> e.length()>2));
            //在上面方法的基础上增加了对流中元素的处理方式的Collector，比如上面的默认的处理方法就是Collectors.toList()
            Map<Boolean,Set<String>> map2 = list3.stream().collect(Collectors.partitioningBy(e -> e.length()>3,Collectors.toSet()));
            System.out.println(map.toString() + "\n" + map2.toString());
            //toMap
            Map<String,String> map11 = list3.stream().limit(2).collect(Collectors.toMap(e -> e.substring(0,1),e -> e));
            Map<String,String> map22 = list3.stream().collect(Collectors.toMap(e -> e.substring(0,1),e->e,(a,b)-> b));
            Map<String,String> map33 = list3.stream().collect(Collectors.toMap(e -> e.substring(0,1),e->e,(a,b)-> b,HashMap::new));
            System.out.println(map11.toString() + "\n" + map22.toString() + "\n" + map33.toString());

        }
}