2018-11-04

2018-11-04  本文已影响0人  mascot_75

java学习笔记(五)

这篇简单的介绍流

集合是 Java 中使用最多的 API 。几乎每个 Java 应用都会制造和处理集合，但集合操作却算不上完美。为了让程序员活得更轻松，Java 语言设计者提供一种新的方式，那就是流。

什么是流

流是 Java API 的新成员，它允许你以声明式的方式处理集合（通过查询语句来表达，而不是临时编写一个实现）。你可以把它们看成遍历数据集合的高级迭代，而且流是可以透明的并行处理，你无需写任何多线程代码。下面两段代码都是用来返回低热量的菜肴名称，并按卡路里排序，一个是 Java7 写的，另一个是 Java8 的流写的。

Java7：

List<Dish> lowCaloricDishes = new ArrayList<>();
for (Dish d : menu) {
    if (d.getCalories() < 400) {
        lowCaloric.add(d);
    }
}

Collections.sort(lowCaloricDishes. new Comparator(){
    public int compare(Dish d1, Dish d2) {
        return Integer.compare(d1.getCalories(), d2.getCalories());
    }
});

List<String> lowCaloricDishesName = new ArrayList<>();
for (Dish d : lowCaloricDishes) {
    lowCaloricDishesName.add(d.getName());
}

在这段代码中，你使用了一个”垃圾变量” lowCaloricDishes， 它的作用就是作为一次性的中间容器。

Java8:

List<String> lowCaloricDishesName = menu.stream()
                                    .filter(d -> d.getCalores() < 400)
                                    .sorted(comparing(Dish::getCalories))
                                    .map(Dish::getName)
                                    .collect(toList());

如果你想使用多核架构执行这段代码，你可以这样：

List<String> lowCaloricDishesName = menu.parallelStream()
                                    .filter(d -> d.getCalores() < 400)
                                    .sorted(comparing(Dish::getCalories))
                                    .map(Dish::getName)
                                    .collect(toList());

选择，你可以看出几个显而易见的好处：

filter 、sorted 、map 和 collect 等操作是和线程模型无关的高层次构件，所以它们的内部实现可以是单线程，也可以是多核架构。

新的 Stream API 表达能力非常强，你在简单学习后可以写出如下代码：

Map<Dish.Type, List<Dish>> dishesByType = menu.stream().collect(groupingBy(Dish::getType));

这行代码的意思是，按照 map 里面的类别对菜肴进行分组。

简单的总结一下，Java8 的 Stream API 可以让你写出这样代码:

流简介

要讨论流，就先谈谈集合，这是最容易上手的方式了。Java8 中的集合支持一个新的 stream 方法，它返回一个流。

那么，流到底是什呢? 简短的定义就是：“从支持数据处理操作的源生成的元素序列”让我们进一步剖析这个定义：

此外还有两个特性：

让我们看一段能体现下面新概念的代码：

List<String> threeHighCaloricDishName = 
    menu.stream()           //从menu获得流  
        .filter(d -> d.getCalores() > 300)  //建立操作流水线：首先选出高热量的菜肴
        .map(Dish::getName)     //获取菜名
        .limit(3)              //只需按着前三个
        .collect(toList());     //将结果保留到另一个集合中
System.out.println(threeHighCaloricDishName);

简单的介绍上面的各种流的操作：

流与集合

Java 现有的集合概念和新的流的概念都提供了接口，来配合表达元素类型和有序值的数据接口。所谓有序，就是按顺序去所用值，而不是随机取用。

粗略地说，流与集合的差异在于什么时候计算。集合是一个内存中的数据结构，它包含数据结构目前所有值--集合的每个元素都得先算出来才能添加到集合中。

相比之下，流则在概念上是固定的数据结构（你不能添加和删除元素），其他元素则是按需计算。

只能遍历一次

和迭代器类似，流只能遍历一次。遍历完之后，这个流就已经被消费了。你可以从数据源从新获取再次遍历，就像迭代器一样。例如：下面代码就会抛出异常。

List<String> title = Arrays.asList("Java8", "in", "action");
Stream<String> s = title.stream();
s.forEach(System.out::println);
//这句话会报异常，应为流已被操作
s.forEach(System.out::println);

所以务必记住，留着能被消费一次。

外部迭代和内部迭代

使用 collection 接口需要用户自己去迭代（如 for-each），则成为外部迭代。相反，流使用内部迭代 —— 它帮你迭代。下面代码说明区别：

集合：用 for-each外部迭代

List<String> names = new ArrayList<>();
for (Dish d : menu) {
    names.add(d.getName());
}

集合：用背后的迭代器迭代

List<String> names = new ArrayLsit<>();
Iterator<Dish> iterator = menu.iterator();
while (iterator.hasNext()) {
    Dish d = iterator.next();
    names.add(d.getName());
}

流：内部迭代

List<String> names = menu.stream().map(Dish::getName()).collect(toList());

流操作

Stream 接口定义了 许多操作，基本可以分为两大类操作：

中间操作

像 filter 和 map 等中间操作会返回另一个流，这让可以让多个操作连接在一起形成一个查询。除非执行一个终端操作，否则中间操作不会正真执行 —— 他们都是延时执行的。这是因为中间操作一般都可以合并起来，在终端操作中一起执行。

你可以修改代码，做一下尝试：

List<String> names = 
    menu.stream()
    .filter(d -> {
        System.out.println("filtering: " + d.getName());
        return d.getCalories() > 300;
    })
    .map(d -> {
        System.out.println("mappong: " + d.getName());
        return d.getName();
    })
    .limit(3);
    .collect(toList());
//打印结果菜名
System.out.println(names);

你会得到如下结果：

filtering pork
mapping pork
filtering beef
mapping beef
filtering chicken
mapping chicken
[pork, beef, chicken]

有些操作就是利用了流的这种延时性质。尽管 filter 和 map 是个两个独立的操作，但是它们被合并到同一次遍历中（这种技术叫循环合并）。

终端操作

终端操作会从流水线中生成结果，结果是一个非流值。比如List 、Integer，甚至是 void 。例如：下面这个 forEach 操作就返回一个 void 的终端操作。

menu.stream().forEach(System.out::println);

使用流

总而言之，流的使用一般包括三件事：

流的流水线背后的理念类似于构建器模式。在构建器模式中有一条调用连用来设置一套配置（流的中间链），接着调用 build 方法（流的终端操作）。

总结

上一篇 下一篇

猜你喜欢

热点阅读