JDK 8新特性全收录——下

七、方法引用和构造函数引用

格式：容器（对象实例/类）:: 方法名

 List<VideoOrder> list2 = Arrays.asList(new VideoOrder("2019110601",21,"springcloud教程"),
                new VideoOrder("2019110602",23,"netty 教程"),
                new VideoOrder("2019110603",21,"sql教程"));
        list1.stream().map(VideoOrder::getMoney);

八、集合框架

1、stream流

Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。

集合有两种方式生成流：

stream() − 为集合创建串行流。
parallelStream() − 为集合创建并行流。

parallelStream并行流使用以及注意点

1、并非使用并行流处理速度就会快看数据量大小一般数据量小于1万条不建议开启并行流

2、并行流线程并不安全需要使用线程安全的集合进行处理

Strram的方法。

中间操作（intermediate）主要有以下方法（此类型的方法返回的都是Stream对象）：

map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered

终端操作（terminal）主要有以下方法：

forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

集合框架

1、map 函数类型转换

List<VideoOrder> list1 = Arrays.asList(new VideoOrder("2019110601",21,"springboot教程"),
        new VideoOrder("2019110602",23,"redis 教程"),
        new VideoOrder("2019110603",21,"sql教程"));

 List<Integer> list = list1.stream().map(VideoOrder::getMoney).collect(Collectors.toList());

源码：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

作用：不让外部看到实际的实体属性进行实体转换公司常用

2、filter 函数元素过滤

List<String> list = Arrays.asList("aaa","bbb","ccc");
List<String> lists = list.stream()
                     .filter(x ->x.startsWith("a"))
                     .collect(Collectors.toList());

源码：

Stream<T> filter(Predicate<? super T> predicate);

3、limit 函数

List<String> list = Arrays.asList("aaa","bbb","ccc");
list.stream().limit(1).collect(Collectors.toList());

源码：

@Override
public final Stream<P_OUT> limit(long maxSize) {
    if (maxSize < 0)
        throw new IllegalArgumentException(Long.toString(maxSize));
    return SliceOps.makeRef(this, 0, maxSize);
}

4、sorted 函数默认升序排序

List<VideoOrder> list1 = Arrays.asList(new VideoOrder("2019110601",21,"springboot教程"),
        new VideoOrder("2019110602",23,"redis 教程"),
        new VideoOrder("2019110603",21,"sql教程"));

 List<Integer> list = list1.stream().map(VideoOrder::getMoney).collect(Collectors.toList());
 list.stream().sorted(Integer::compareTo);

源码：

@Override
public final Stream<P_OUT> sorted() {
    return SortedOps.makeRef(this);
}

5、max函数

List<String> list = Arrays.asList("x","aaaa","bbb");
 String maxlenth = list.stream().max(Comparator.comparing(String::length)).orElse("");

源码：

@Override
public final Optional<P_OUT> max(Comparator<? super P_OUT> comparator) {
    return reduce(BinaryOperator.maxBy(comparator));
}

6、min函数

List<String> list = Arrays.asList("x","aaaa","bbb");
 String minlenth = list.stream().min(Comparator.comparing(String::length)).orElse("");

源码：

@Override
public final Optional<P_OUT> min(Comparator<? super P_OUT> comparator) {
    return reduce(BinaryOperator.minBy(comparator));

}

7、foreach 函数

List<String> list = Arrays.asList("x","aaaa","bbb");
list.forEach(x->System.out::println(x););

注：遍历无法对外部变量进行修改

收集器和集合统计

1、reduce函数聚合方法

List<VideoOrder> list1 = Arrays.asList(new VideoOrder("2019110601",21,"springboot教程"),
        new VideoOrder("2019110602",23,"redis 教程"),
        new VideoOrder("2019110603",21,"sql教程"));

 final Integer integer = list1.stream().map(VideoOrder::getMoney).collect(Collectors.reducing((x, y) -> x + y)).get();

源码：

public static <T> Collector<T, ?, Optional<T>>
reducing(BinaryOperator<T> op) {
    class OptionalBox implements Consumer<T> {
        T value = null;
        boolean present = false;

        @Override
        public void accept(T t) {
            if (present) {
                value = op.apply(value, t);
            }
            else {
                value = t;
                present = true;
            }
        }
    }

2、collection 收集方法

List<VideoOrder> list1 = Arrays.asList(new VideoOrder("2019110601",21,"springboot教程"),
        new VideoOrder("2019110602",23,"redis 教程"),
        new VideoOrder("2019110603",21,"sql教程"));

 list1.stream().collect(Collectors.toSet()); //转set
 list1.stream().collect(Collectors.toCollection(TreeSet::new));

//转自定义集合

3、joining 函数拼接方法

List<VideoOrder> list1 = Arrays.asList(new VideoOrder("2019110601",21,"springboot教程"),
        new VideoOrder("2019110602",23,"redis 教程"),
        new VideoOrder("2019110603",21,"sql教程"));

 list1.stream().map(VideoOrder::getTitle).collect(Collectors.joining()); //字符串拼接
 list1.stream().map(VideoOrder::getTitle).collect(Collectors.joining("-")); //使用"-"拼接
 list1.stream().map(VideoOrder::getTitle).collect(Collectors.joining("-","[","]")); //加上"[]"在用"-拼接"

源码：


无参：
 public static Collector<CharSequence, ?, String> joining() {
    return new CollectorImpl<CharSequence, StringBuilder, String>(
            StringBuilder::new, StringBuilder::append,
            (r1, r2) -> { r1.append(r2); return r1; },
            StringBuilder::toString, CH_NOID);
}

 带一个：
   public static Collector<CharSequence, ?, String> joining(CharSequence delimiter) {
    return joining(delimiter, "", "");
}

带三个：
   public static Collector<CharSequence, ?, String> joining(CharSequence delimiter,
                                                         CharSequence prefix,
                                                         CharSequence suffix) {
    return new CollectorImpl<>(
            () -> new StringJoiner(delimiter, prefix, suffix),
            StringJoiner::add, StringJoiner::merge,
            StringJoiner::toString, CH_NOID);
}

4、partitioningBy 函数

Map<Boolean,List<Integer>> result   =  Stream.of(1,2,3)
                         .collect(Collectors.partitioningBy(obj ->obj.intValue()>2));
        结果：{false=[1, 2], true=[3]}

源码：

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

5、groupingBy 分组函数

List<Student> list = Arrays.asList(new Student("北京","22"),
             new Student("南京","23"),new Student("上海","20"),new Student("北京","21"));
 根据省份分组 ：    Map<String,List<Student> students> map  =   list.stream().collect(Collectors.groupingBy(x ->x.getProvince()));

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

6、counting 分组进阶统计

List<Student> list = Arrays.asList(new Student("北京","22"),
                new Student("南京","23"),new Student("上海","20"),new Student("北京","21"));
Map<String,Long> map = list.stream()
            .collect(Collectors.groupingBy(obj->obj.getProvince(),Collectors.counting()));
结果： {上海=1, 南京=1, 北京=2}

源码：

public static <T> Collector<T, ?, Long>
counting() {
    return reducing(0L, e -> 1L, Long::sum);
}

7、summarizing 统计函数

7.1summarizingInt

List<Student> list = Arrays.asList(new Student("北京",22),
                new Student("南京",23),new Student("上海",21),new Student("北京",24));
        IntSummaryStatistics statistics = list.stream()
                                                 .collect(Collectors.summarizingInt(Student::getAge));
        System.out.println("最大值"+statistics.getMax());
        System.out.println("最小值"+statistics.getMin());
        System.out.println("平均值"+statistics.getAverage());
        System.out.println("总和"+statistics.getSum());
        System.out.println("总数"+statistics.getCount());


    7.2、summarizingDouble
    7.3、summarizingLong

summingInt int类型数据求和

List<VideoOrder> list1 = Arrays.asList(new VideoOrder("2019110601",21,"springboot教程"),
        new VideoOrder("2019110602",23,"redis 教程"),
        new VideoOrder("2019110603",21,"sql教程"));
final Integer collect2 = list1.stream().collect(Collectors.summingInt(VideoOrder::getMoney));

8、averagingInt函数求平均

final Double collect2 = list1.stream().collect(Collectors.averagingInt(VideoOrder::getMoney));

思维练习：

pojo:

@Data
public class VideoOrder {

 private String tradeNo;
 private Integer money;
 private String title;
}

1、交集注：需要重写下equals、hash方法

数据：
总金额 65
List<VideoOrder> list1 = Arrays.asList(new VideoOrder("2019110601",21,"springboot教程"),
        new VideoOrder("2019110602",23,"redis 教程"),
        new VideoOrder("2019110603",21,"sql教程"));
总金额 64
 List<VideoOrder> list2 = Arrays.asList(new VideoOrder("2019110601",21,"springcloud教程"),
         new VideoOrder("2019110602",22,"netty 教程"),
         new VideoOrder("2019110603",21,"sql教程"));

实现：


 Stream<VideoOrder> orderStream = list1.stream().filter(list2::contains);
 
 @Override
public int hashCode() {
    return title.hashCode();
}

@Override
public boolean equals(Object obj) {
    if(obj instanceof VideoOrder){
       return ((VideoOrder) obj).title.equals(this.title);
    }
    return super.equals(obj);
}

2、差集

List<VideoOrder> orders = list1.stream()
      .filter(obj -> !list2.contains(obj)).collect(Collectors.toList());

3、去重并集

List<VideoOrder> collect = list1.parallelStream().collect(Collectors.toList());
collect.addAll(list2);
List<VideoOrder> distinct = collect.parallelStream().distinct().collect(Collectors.toList());

3.1 并集

//并集
List<VideoOrder> collect = list1.parallelStream().collect(Collectors.toList());
collect.addAll(list2);

4、求平均

1、Double aDouble = list1.stream().collect(Collectors.averagingInt(VideoOrder::getMoney));
2、final IntSummaryStatistics collect1 = list1.stream().collect(Collectors.summarizingInt(VideoOrder::getMoney));
     final double average = collect1.getAverage();

5、求和

1、 final IntSummaryStatistics collect1 = list1.stream().collect(Collectors.summarizingInt(VideoOrder::getMoney));
    collect1.getSum();
2、final Integer collect2 = list1.stream().collect(Collectors.summingInt(VideoOrder::getMoney));

jdk 8新特性全收录 ——上链接地址：https://blog.csdn.net/weixin_42083036/article/details/102951697

王博渊

发布了47 篇原创文章 · 获赞 30 · 访问量 1万+

私信关注