你真的开始用JDK8了吗？（下）

最新推荐文章于 2024-07-09 15:49:00 发布

wangyan9110

最新推荐文章于 2024-07-09 15:49:00 发布

阅读量1.4k

点赞数 2

分类专栏： Java 文章标签： java lambda

本文链接：https://blog.csdn.net/WANGYAN9110/article/details/69671764

版权

Java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

上篇文章中，看到了JDK8中的Optional和Lambda Expressions带来编程上的改变，甚至编程思维的改变。接下来我们继续看JDK8的Stream和Interface default method给我们带来的改变

Stream

Stream也是JAVA8的一大特点，这里的Stream和IO的那个Stream不同，它提供了对集合操作的增强，极大的提高了操作集合对象的便利性。下面我们就通过一个示例来看，使用Stream给我们带来哪些改变。

有一批学生考试数据，包括学生ID,班级ID,学科,分数。来计算如下指标

找出所有语文科目，分数大于60分的学生
找出语文科目，排名第一的学生
计算学生ID为10的学生的总分
所有学生按照总分从大到小

在JDK8之前，实现以上功能也非常简单的，相信对于一个刚刚学习Java的工程师来说，也很容易实现。不妨大家给自己设定一个限制，如何使用最少的代码实现以上功能。这里留作一个问题思考，下面我们使用Stream API来实现这些需求.

筛选：filter用法

找出所有语文科目，分数大于60分的学生

studentScores.stream()
        .filter(s -> "语文".equals(s.getSubject()) && s.getScore() >= 60f)
        .collect(Collectors.toList())
        .forEach(System.out::println);

排序：sorted用法

找出语文科目，排名第一的学生

Optional<StudentScore> studentScore = studentScores.stream()
        .filter(s -> "语文".equals(s.getSubject()))
        .sorted((s1, s2) -> s1.getScore() > s2.getScore() ? -1 : 1)
        .findFirst();
if (studentScore.isPresent()) {
    System.out.println(studentScore.get());
}

统计计算：reduce

计算学生ID为10的学生的总分

Double total = studentScores.stream()
        .filter(s -> s.getStudentId() == 10)
        .mapToDouble(StudentScore::getScore)
        .reduce(0, Double::sum);
System.out.println(total);

分组统计：Collectors

所有学生按照总分从大到小

studentScores.stream()
        .collect(Collectors.groupingBy(StudentScore::getStudentId
                , Collectors.summingDouble(StudentScore::getScore)))
        .entrySet()
        .stream()
        .sorted((o1, o2) -> o1.getValue() < o2.getValue() ? 1 : -1)
        .forEach(System.out::println);

以上的示例已经包括了Stream API的大部分的功能。从以上可以看到，在进行计算时，总是需要使用在集合对象中使用stream()方法，先转成Stream然后在进行后面的操作，为什么不直接在集合类下直接实现如下操作呢？Stream和集合类有哪些区别？Oracle给出了如下说明

Stream没有存储，它不是数据结构，并不保存数据。它可以像数组、生成器等数据源获取数据，通过一个计算流进行操作
在功能性质上，通过流的操作，不会修改数据源，比如，filter操作，是从集合的流上获取一个新的流，而不是将过滤掉的元素从集合上删除
延迟计算，许多流式的计算像filter、map等，是通过懒式的实现。一个数据流操作包括三个基本步骤，数据源->数据转换->执行获取结果。每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象。数据转换的操作都是lazy的
可以支持无限的大小。虽然集合是有限的，但是流是可以支持无限大小的，像limit(n)或者findFirst可以让无限的流操作在有限的时间内完成
流的元素只能在一次创建中被访问到一次，像Iterator一样，必须生成一个新的流来访问新的元素

Interface default method

在JDK8中，使用forEach方法可以直接遍历数组，当然们进入查看forEach查看源代码时，我们在Iterable接口可以看到如下代码：

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

这不是方法的实现么？是的，在接口里可以写实现了。在JDK8中为了支持新特性，必须对原有接口进行改造。需要在不破坏现有的架构情况下在接口里增加新方法。这也是JAVA8引入Default method的原因。但是引入Default method之后，需要思考两个问题：

和抽象类区别

当接口有了default method 之后，接口看起来和抽象性是一样的，但是他们两个在Java8中还是有区别的。

抽象类，有自己的构造方法，并且可以定义自己的数据结构，但是默认方法只能调用接口时使用，并不会涉及到特定接口实现类的状态。具体使用接口还是抽象类还需要根据具体业务场景来界定

接口的多继承问题

在java中可以支持多继承，如果两个接口实现了同样的默认方法，那么应该使用哪个呢？

比如：

public interface DemoA {

    default void test() {
        System.out.println("I'm DemoA.");
    }
}

public interface DemoB {

    default void test() {
        System.out.println("I'm DemoB.");
    }
}

如果一个DemoImpl继承以上两个接口，代码如下：

public class DemoImpl implements DemoA, DemoB {
}

这时，IDE会在DemoImpl下面有一条红线，提示不能继承在DemoA和DemoB中的test方法，需要实现该方法

public class DemoImpl implements DemoA, DemoB {
    @Override
    public void test() {
        DemoB.super.test();
        DemoA.super.test();;
    }
}