JDK8新特性笔记（七）：收集器和集合统计

JDK8新特性笔记（七）：收集器和集合统计

1.collector收集器

作用：一个终端操作，用于对流中的数据进行归集操作，collect方法接受的参数是一个Collector

有两个重载方法，在Stream接口中

// 重载方法一
<R> R collect(Supplier<R> supplier,
              BiConsumer<R, ? super T> accumulator,
              BiConsumer<R, R> combiner);
// 重载方法二
<R, A> R collect(Collector<? super T, A, R> collector);

String类型List集合排序例子，之前也有写过

// 创建list
List<String> stringList = Arrays.asList("java", "python", "golang", "C#", "Julia", "shell");
// 排序
List<String> collect = stringList.stream().sorted().collect(Collectors.toList());
// 遍历输出
collect.forEach(System.out::println);

运行结果：
    C#
	Julia
	golang
	java
	python
	shell

以上代码的Collectors.toList()改成toSet()就相当于将List转成set，这种方式可以用于list滤重。

Collectors.toMap()
Collectors.toSet()
Collectors.toCollection() ：用自定义的实现Collection的数据结构收集
Collectors.toCollection(LinkedList::new)
Collectors.toCollection(CopyOnWriteArrayList::new)
Collectors.toCollection(TreeSet::new)

一般默认提供的toList、toMap、toSet就够用了。

2.Joining函数 拼接

一般用作字符串拼接

//3种重载⽅方法
Collectors.joining()
Collectors.joining("param")
Collectors.joining("param1", "param2", "param3")

字符串数组拼接样例

List<String> stringList = Arrays.asList("abc", "spring", "java", "python");
// 单纯拼接
String result = stringList.stream().collect(Collectors.joining(""));
System.out.println(result);
// 拼接间加入分隔符
String result1 = stringList.stream().collect(Collectors.joining("--"));
System.out.println(result1);
// 加大括号
String result2 = stringList.stream().collect(Collectors.joining("--", "{", "}"));
System.out.println(result2);java

stream流可以使用stream.of()直接创建

String result = Stream.of("springboot","mysql","html5","css3").collect(Collectors.joining(",", "[", "]"));

3.partitioningBy 函数 分组

collectors.partitioningBy分组，key是boolean类型

public static <T>
Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? superT> predicate) {
return partitioningBy(predicate, toList());
}

例子：将list中字符串长度大于4的为一组，其他为另一组

List<String> stringList = Arrays.asList("abc", "spring", "java", "python");
Map<Boolean, List<String>> result = stringList.stream().collect(Collectors.partitioningBy(obj -> obj.length() > 4));
System.out.println(result);

4.grouping by 分组

单纯分组

public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier) { 
    return groupingBy(classifier, toList());
}

例子：根据学生所在的省份进行分组

public class GroupingByDemo01 {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(new Student("辽宁", 18), new Student("吉林", 19),
                new Student("辽宁", 23), new Student("吉林", 20),
                new Student("辽宁", 24), new Student("吉林", 23));
        Map<String, List<Student>> result = students.stream().collect(Collectors.groupingBy(obj -> obj.getProvince()));
        
        // 遍历结果
        result.forEach((key,value)->{
            System.out.println("--------------------");
            System.out.println(key);
            value.forEach(obj->{
                System.out.println(obj.getAge());
            });
        });
    }
}
class Student{
    private String province;
    private int age;
    public Student(String province, int age) {
        this.province = province;
        this.age = age;
    }
    public String getProvince() {
        return province;
    }
    public void setProvince(String province) {
        this.province = province;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

运行结果：
--------------------
吉林
19
20
23
--------------------
辽宁
18
23
24

分组统计

public static <T, K, A, D> Collector<T, ?, Map<K, D>>
groupingBy(Function<? super T, ? extends K> classifier,Collector<? super T, A, D> downstream) {
	return groupingBy(classifier, HashMap::new, downstream);
}	

例子：统计各省份人数

public class GroupingByDemo01 {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(new Student("辽宁", 18), new Student("吉林", 19),
                new Student("辽宁", 23), new Student("吉林", 20),
                new Student("黑龙江", 24), new Student("北京", 23));

        Map<String, Long> result = students.stream().collect(Collectors.groupingBy(Student::getProvince,Collectors.counting()));
        // 结果遍历
        result.forEach((key,value)->{
            System.out.println(key+"省 学生人数："+value);
        });
    }
}
class Student{
    private String province;
    private int age;

    public Student(String province, int age) {
        this.province = province;
        this.age = age;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

运行结果：
黑龙江省 学生人数：1
吉林省 学生人数：2
辽宁省 学生人数：2
北京省 学生人数：1

5.summarizing集合统计

summarizing统计

public static <T> Collector<T, ?, IntSummaryStatistics> 
    summarizingInt(ToIntFunction<? super T> mapper) { return new
CollectorImpl<T, IntSummaryStatistics, IntSummaryStatistics>(
	IntSummaryStatistics::new,
	(r, t) -> r.accept(mapper.applyAsInt(t)),
	(l, r) -> { l.combine(r); return l; }, CH_ID );
}

默认有summarizingInt，summarizingLong，summarizingDouble这三种分别统计不同数据类型的数据

例子：统计一些人的年龄信息，如平均年龄，人数，最小，最大

public static void main(String[] args) {
    List<Student> students = Arrays.asList(new Student("辽宁", 18), new Student("吉林", 19),
            new Student("辽宁", 23), new Student("吉林", 20),
            new Student("辽宁", 24), new Student("吉林", 23));
    IntSummaryStatistics result = students.stream().collect(Collectors.summarizingInt(Student::getAge));
    System.out.println("人数："+result.getCount());
    System.out.println("年龄总和："+result.getSum());
    System.out.println("最小年龄："+result.getMin());
    System.out.println("最大年龄："+result.getMax());
    System.out.println("平均年龄："+result.getAverage());
}

运行结果：
人数：6
年龄总和：127
最小年龄：18
最大年龄：24
平均年龄：21.166666666666668