《Java8实战》-第六章读书笔记（用流收集数据-01）

时间  2019-11-10
标签 Java8实战 第六 读书 笔记 收集 数据 栏目 Java 繁體版
原文   原文链接

用流收集数据

咱们在前一章中学到，流能够用相似于数据库的操做帮助你处理集合。你能够把Java 8的流看做花哨又懒惰的数据集迭代器。它们支持两种类型的操做：中间操做（如 filter 或 map ）和终端操做（如 count 、 findFirst 、 forEach 和 reduce ）。中间操做能够连接起来，将一个流转换为另外一个流。这些操做不会消耗流，其目的是创建一个流水线。与此相反，终端操做会消耗流，以产生一个最终结果，例如返回流中的最大元素。它们一般能够经过优化流水线来缩短计算时间。java

咱们已经在前面用过了 collect 终端操做了，当时主要是用来把 Stream 中全部的元素结合成一个 List 。在本章中，你会发现 collect 是一个归约操做，就像 reduce 同样能够接受各类作法做为参数，将流中的元素累积成一个汇总结果。具体的作法是经过定义新的Collector 接口来定义的，所以区分 Collection 、 Collector 和 collect 是很重要的。git

如今，咱们来看一个例子，看看咱们用collect和收集器能作什么。程序员

  1. 对一个交易列表按照货币分组，得到该货币全部的交易总额和（返回一个 Map<Currency,Integer> ）。
  2. 将交易列表分红两组：贵的和不贵的（返回一个 Map<Boolean, List<Transaction>> ）。
  3. 建立多级分组，好比按城市对交易分组，而后进一步按照贵或不贵分组（返回一个

Map<Boolean, List<Transaction>> ）。github

咱们首先来看一个利用收集器的例子，想象一下，你有一个Transaction构成的List，而且想按照名义货币进行分组。在没有Lambda的Java里，哪怕像这种简单的用例实现起来都很啰嗦，就像下面这样：数据库

// 创建累积交易分组的Map
Map<Currency, List<Transaction>> transactionsByCurrencies = new HashMap<>(16);
// 迭代 Transaction 的 List
for (Transaction transaction : transactions) {
    // 提取 Transaction的货币
    Currency currency = transaction.getCurrency();
    List<Transaction> transactionsForCurrency = transactionsByCurrencies.get(currency);
    // 若是分组 Map 中没有这种货币的条目，就建立一个
    if (transactionsForCurrency == null) {
        transactionsForCurrency = new ArrayList<>();
        transactionsByCurrencies.put(currency, transactionsForCurrency);
    }
    // 将当前遍历的 Transaction加入同一货币的 Transaction 的 List
    transactionsForCurrency.add(transaction);
}
System.out.println(transactionsByCurrencies);

若是你是一位经验丰富的Java程序员，写这种东西可能挺顺手的，不过你必须认可，作这么简单的一件事就得写不少代码。更糟糕的是，读起来比写起来更费劲！代码的目的并不容易看出来，尽管换做白话的话是很直截了当的：“把列表中的交易按货币分组。”你在本章中会学到，用Stream 中 collect 方法的一个更通用的 Collector 参数，你就能够用一句话实现彻底相同的结果，而用不着使用上一章那个 toList 的特殊状况了：编程

Map<Currency, List<Transaction>> transactionsByCurrencies =
    transactions.stream().collect(groupingBy(Transaction::getCurrency));

这一比差得还真多，对吧？安全

收集器简介

前一个例子清楚地展现了函数式编程相对于指令式编程的一个主要优点：你只需指出但愿的结果——“作什么”，而不用操心执行的步骤——“如何作”。在上一个例子里，传递给 collect方法的参数是 Collector 接口的一个实现，也就是给 Stream 中元素作汇总的方法。上一章里的toList 只是说“按顺序给每一个元素生成一个列表”；在本例中， groupingBy 说的是“生成一个Map ，它的键是（货币）桶，值则是桶中那些元素的列表”。要是作多级分组，指令式和函数式之间的区别就会更加明显：因为须要好多层嵌套循环和条件，指令式代码很快就变得更难阅读、更难维护、更难修改。数据结构

收集器用做高级归约

刚刚的结论又引出了优秀的函数式API设计的另外一个好处：更易复合和重用。收集器很是有用，由于用它能够简洁而灵活地定义collect用来生成结果集合的标准。更具体地说，对流调用collect方法将对流中的元素触发一个归约操做（由Collector来参数化）。通常来讲， Collector 会对元素应用一个转换函数（不少时候是不体现任何效果的恒等转换，例如 toList ），并将结果累积在一个数据结构中，从而产生这一过程的最终输出。例如，在前面所示的交易分组的例子中，转换函数提取了每笔交易的货币，随后使用货币做为键，将交易自己累积在生成的 Map 中。app

归约和汇总

为了说明从 Collectors 工厂类中能建立出多少种收集器实例，咱们重用一下前一章的例子：包含一张佳肴列表的菜单！就像你刚刚看到的，在须要将流项目重组成集合时，通常会使用收集器（ Stream 方法 collect的参数）。再宽泛一点来讲，但凡要把流中全部的项目合并成一个结果时就能够用。这个结果能够是任何类型，能够复杂如表明一棵树的多级映射，或是简单如一个整数——也许表明了菜单的热量总和。框架

咱们先来举一个简单的例子，利用 counting 工厂方法返回的收集器，数一数菜单里有多少
种菜：

long howManyDishes = menu.stream().collect(Collectors.counting());

这还能够写得更为直接：

long howManyDishes = menu.stream().count();

counting 收集器在和其余收集器联合使用的时候特别有用，后面会谈到这一点。

查找流中的最大值和最小值

假设你想要找出菜单中热量最高的菜。你可使用两个收集器， Collectors.maxBy和Collectors.minBy ，来计算流中的最大或最小值。这两个收集器接收一个 Comparator 参数来
比较流中的元素。你能够建立一个 Comparator来根据所含热量对菜肴进行比较，并把它传递给
Collectors.maxBy ：

List<Dish> menu =  Dish.MENU;
Comparator<Dish> dishCaloriesComparator =
        Comparator.comparingInt(Dish::getCalories);
Optional<Dish> mostCalorieDish =
        menu.stream().max(dishCaloriesComparator);
System.out.println(mostCalorieDish.get());

你可能在想 Optional<Dish> 是怎么回事。要回答这个问题，咱们须要问“要是 menu 为空怎么办”。那就没有要返回的菜了！Java 8引入了 Optional ，它是一个容器，能够包含也能够不包含值。这里它完美地表明了可能也可能不返回菜肴的状况。

另外一个常见的返回单个值的归约操做是对流中对象的一个数值字段求和。或者你可能想要求平均数。这种操做被称为汇总操做。让咱们来看看如何使用收集器来表达汇总操做。

汇总

Collectors 类专门为汇总提供了一个工厂方法： Collectors.summingInt 。它可接受一个把对象映射为求和所需 int 的函数，并返回一个收集器；该收集器在传递给普通的 collect 方法后即执行咱们须要的汇总操做。举个例子来讲，你能够这样求出菜单列表的总热量：

List<Dish> menu =  Dish.MENU;
int totalCalories = menu.stream().collect(summingInt(Dish::getCalories));

除了Collectors.summingInt，还有Collectors.summingLong 和Collectors.summingDouble 方法的做用彻底同样，能够用于求和字段为 long 或 double 的状况。

但汇总不只仅是求和；还有 Collectors.averagingInt ，连同对应的 averagingLong 和
averagingDouble 能够计算数值的平均数：

List<Dish> menu =  Dish.MENU;
double avgCalories =
                menu.stream().collect(averagingInt(Dish::getCalories));

到目前为止，你已经看到了如何使用收集器来给流中的元素计数，找到这些元素数值属性的最大值和最小值，以及计算其总和和平均值。不过不少时候，你可能想要获得两个或更多这样的结果，并且你但愿只需一次操做就能够完成。在这种状况下，你可使用 summarizingInt 工厂方法返回的收集器。例如，经过一次 summarizing 操做你能够就数出菜单中元素的个数，并获得菜肴热量总和、平均值、最大值和最小值：

List<Dish> menu =  Dish.MENU;
IntSummaryStatistics menuStatistics =
        menu.stream().collect(summarizingInt(Dish::getCalories));
System.out.println(menuStatistics.getMax());
System.out.println(menuStatistics.getAverage());
System.out.println(menuStatistics.getMin());
System.out.println(menuStatistics.getCount());
System.out.println(menuStatistics.getSum());

一样，相应的 summarizingLong 和 summarizingDouble 工厂方法有相关的LongSummaryStatistics 和 DoubleSummaryStatistics 类型，适用于收集的属性是原始类型 long 或double 的状况。

链接字符串

joining 工厂方法返回的收集器会把对流中每个对象应用 toString 方法获得的全部字符
串链接成一个字符串。这意味着你把菜单中全部菜肴的名称链接起来，以下所示：

String shortMenu = menu.stream().map(Dish::getName).collect(joining());

请注意， joining 在内部使用了 StringBuilder 来把生成的字符串逐个追加起来。结果：

porkbeefchickenfrench friesriceseason fruitpizzaprawnssalmon

但该字符串的可读性并很差。幸亏， joining 工厂方法有一个重载版本能够接受元素之间的
分界符，这样你就能够获得一个逗号分隔的菜肴名称列表：

String shortMenu = menu.stream().map(Dish::getName).collect(joining(", "));

结果：

pork, beef, chicken, french fries, rice, season fruit, pizza, prawns, salmon

到目前为止，咱们已经探讨了各类将流归约到一个值的收集器。在下一节中，咱们会展现为何全部这种形式的归约过程，其实都是 Collectors.reducing 工厂方法提供的更广义归约收集器的特殊状况。

广义的归约汇总

事实上，咱们已经讨论的全部收集器，都是一个能够用 reducing 工厂方法定义的归约过程的特殊状况而已。 Collectors.reducing 工厂方法是全部这些特殊状况的通常化。能够说，先前讨论的案例仅仅是为了方便程序员而已。（可是，请记得方便程序员和可读性是头等大事！）例如，能够用 reducing 方法建立的收集器来计算你菜单的总热量，以下所示：

List<Dish> menu =  Dish.MENU;
int totalCalories = menu.stream().collect(reducing(
        0, Dish::getCalories, (i, j) -> i + j));
System.out.println(totalCalories);

它须要三个参数：

  1. 第一个参数是归约操做的起始值，也是流中没有元素时的返回值，因此很显然对于数值和而言0是一个合适的值。
  2. 第二个参数是Lambda的语法糖，将菜肴转换成一个表示其所含热量的 int 。
  3. 第三个参数是一个 BinaryOperator ，将两个项目累积成一个同类型的值。这里它就是

对两个 int 求和。

一样，你可使用下面这样单参数形式的 reducing 来找到热量最高的菜，以下所示：

Optional<Dish> mostCalorieDish =
            menu.stream().collect(reducing(
                    (d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2));

你能够把单参数 reducing 工厂方法建立的收集器看做三参数方法的特殊状况，它把流中的第一个项目做为起点，把恒等函数（即一个函数仅仅是返回其输入参数）做为一个转换函数。

收集框架的灵活性：以不一样的方法执行一样的操做

你还能够进一步简化前面使用 reducing 收集器的求和例子——引用 Integer 类的 sum 方法，而不用去写一个表达同一操做的Lambda表达式。这会获得如下程序：

int totalCalories2 = menu.stream()
                .collect(reducing(0, // 初始值
                        Dish::getCalories, // 转换函数
                        Integer::sum)); // 积累函数

使用语法糖，能帮助咱们简化一部分代码。

还有另一种方法不使用收集器也能执行相同操做——将菜肴流映射为每一道菜的热量，而后用前一个版本中使用的方法引用来归约获得的流：

int totalCalories =
            menu.stream().map(Dish::getCalories).reduce(Integer::sum).get();

请注意，就像流的任何单参数 reduce 操做同样， reduce(Integer::sum) 返回的不是 int而是 Optional<Integer> ，以便在空流的状况下安全地执行归约操做。而后你只需用 Optional对象中的 get 方法来提取里面的值就好了。请注意，在这种状况下使用 get 方法是安全的，只是由于你已经肯定菜肴流不为空。通常来讲，使用容许提供默认值的方法，如 orElse 或 orElseGet来解开Optional中包含的值更为安全。最后，更简洁的方法是把流映射到一个 IntStream ，而后调用 sum 方法，你也能够获得相同的结果：

int totalCalories = menu.stream().mapToInt(Dish::getCalories).sum();
根据状况选择最佳解决方案

这再次说明了，函数式编程（特别是Java 8的 Collections 框架中加入的基于函数式风格原理设计的新API）一般提供了多种方法来执行同一个操做。这个例子还说明，收集器在某种程度上比Stream 接口上直接提供的方法用起来更复杂，但好处在于它们能提供更高水平的抽象和归纳，也更容易重用和自定义。在《Java8实战》中的的建议是，尽量为手头的问题探索不一样的解决方案，但在通用的方案里面，始终选择最专门化的一个。不管是从可读性仍是性能上看，这通常都是最好的决定。例如，要计菜单的总热量，咱们更倾向于最后一个解决方案（使用 IntStream ），由于它最简明，也极可能最易读。同时，它也是性能最好的一个，由于 IntStream 可让咱们避免自动拆箱操做，也就是从Integer到int的隐式转换，它在这里毫无用处。

分组

一个常见的数据库操做是根据一个或多个属性对集合中的项目进行分组。就像前面讲到按货币对交易进行分组的例子同样，若是用指令式风格来实现的话，这个操做可能会很麻烦、啰嗦并且容易出错。可是，若是用Java 8所推崇的函数式风格来重写的话，就很容易转化为一个很是容易看懂的语句。咱们来看看这个功能的第二个例子：假设你要把菜单中的菜按照类型进行分类，有肉的放一组，有鱼的放一组，其余的都放另外一组。用 Collectors.groupingBy 工厂方法返回的收集器就能够轻松地完成这项任务，以下所示：

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

其结果是下面的 Map：

{OTHER=[Dish{name='french fries'}, Dish{name='rice'}, Dish{name='season fruit'}, Dish{name='pizza'}], MEAT=[Dish{name='pork'}, Dish{name='beef'}, Dish{name='chicken'}], FISH=[Dish{name='prawns'}, Dish{name='salmon'}]}

这里，你给 groupingBy 方法传递了一个 Function （以方法引用的形式），它提取了流中每一道 Dish 的 Dish.Type 。咱们把这个 Function 叫做分类函数，由于它用来把流中的元素分红不一样的组。分组操做的结果是一个 Map ，把分组函数返回的值做为映射的键，把流中全部具备这个分类值的项目的列表做为对应的映射值。在菜单分类的例子中，键就是菜的类型，值就是包含全部对应类型的菜肴的列表。

可是，分类函数不必定像方法引用那样可用，由于你想用以分类的条件可能比简单的属性访问器要复杂。例如，你可能想把热量不到400卡路里的菜划分为“低热量”（diet），热量400到700卡路里的菜划为“普通”（normal），高于700卡路里的划为“高热量”（fat）。因为 Dish 类的做者没有把这个操做写成一个方法，你没法使用方法引用，但你能够把这个逻辑写成Lambda表达式：

public enum CaloricLevel {
    /**
        * 卡路里等级
        */
    DIET, NORMAL, FAT
}

 Map<Dish.CaloricLevel, List<Dish>> dishesByCaloricLevel = menu.stream().collect(
                groupingBy(dish -> {
                    if (dish.getCalories() <= 400) {
                        return Dish.CaloricLevel.DIET;
                    } else if (dish.getCalories() <= 700) {
                        return Dish.CaloricLevel.NORMAL;
                    } else {
                        return Dish.CaloricLevel.FAT;
                    }
                }));

多级分组

要实现多级分组，咱们可使用一个由双参数版本的 Collectors.groupingBy 工厂方法建立的收集器，它除了普通的分类函数以外，还能够接受 collector 类型的第二个参数。那么要进行二级分组的话，咱们能够把一个内层 groupingBy 传递给外层groupingBy ，并定义一个为流中项目分类的二级标准。

Map<Dish.Type, Map<Dish.CaloricLevel, List<Dish>>> dishesByTypeCaloricLevel =
                menu.stream().collect(
                        groupingBy(Dish::getType,
                                groupingBy(dish -> {
                                    if (dish.getCalories() <= 400) {
                                        return Dish.CaloricLevel.DIET;
                                    } else if (dish.getCalories() <= 700) {
                                        return Dish.CaloricLevel.NORMAL;
                                    } else {
                                        return Dish.CaloricLevel.FAT;
                                    }
                                })
                        )
                );

这个二级分组的结果就是像下面这样的两级 Map ：

{OTHER={DIET=[Dish{name='rice'}, Dish{name='season fruit'}], NORMAL=[Dish{name='french fries'}, Dish{name='pizza'}]}, MEAT={DIET=[Dish{name='chicken'}], FAT=[Dish{name='pork'}], NORMAL=[Dish{name='beef'}]}, FISH={DIET=[Dish{name='prawns'}], NORMAL=[Dish{name='salmon'}]}}

这里的外层 Map 的键就是第一级分类函数生成的值：“fish, meat, other”，而这个 Map 的值又是一个 Map ，键是二级分类函数生成的值：“normal, diet, fat”。最后，第二级 map 的值是流中元素构成的 List ，是分别应用第一级和第二级分类函数所获得的对应第一级和第二级键的值：“salmon、pizza…” 这种多级分组操做能够扩展至任意层级，n级分组就会获得一个表明n级树形结构的n级Map 。

通常来讲，把 groupingBy 看做“桶”比较容易明白。第一个 groupingBy 给每一个键创建了一个桶。而后再用下游的收集器去收集每一个桶中的元素，以此获得n级分组。

按子组收集数据

在上一节中，咱们看到能够把第二个 groupingBy 收集器传递给外层收集器来实现多级分组。但进一步说，传递给第一个 groupingBy 的第二个收集器能够是任何类型，而不必定是另外一个 groupingBy 。例如，要数一数菜单中每类菜有多少个，能够传递 counting 收集器做为groupingBy 收集器的第二个参数：

Map<Dish.Type, Long> typesCount = menu.stream().collect(groupingBy(Dish::getType, counting()));

其结果是下面的 Map ：

{OTHER=4, MEAT=3, FISH=2}

还要注意，普通的单参数 groupingBy(f) （其中 f 是分类函数）其实是 groupingBy(f,toList()) 的简便写法。
再举一个例子，你能够把前面用于查找菜单中热量最高的菜肴的收集器改一改，按照菜的类型分类：

Map<Dish.Type, Optional<Dish>> mostCaloricByType =
                menu.stream()
                        .collect(groupingBy(Dish::getType,
                                maxBy(comparingInt(Dish::getCalories))));

这个分组的结果显然是一个 map ，以 Dish 的类型做为键，以包装了该类型中热量最高的 Dish的 Optional<Dish> 做为值：

{OTHER=Optional[Dish{name='pizza'}], MEAT=Optional[Dish{name='pork'}], FISH=Optional[Dish{name='salmon'}]}
把收集器的结果转换为另外一种类型

由于分组操做的 Map 结果中的每一个值上包装的 Optional 没什么用，因此你可能想要把它们去掉。要作到这一点，或者更通常地来讲，把收集器返回的结果转换为另外一种类型，你可使用Collectors.collectingAndThen 工厂方法返回的收集器，以下所示。

查找每一个子组中热量最高的 Dish：

List<Dish> menu = Dish.MENU;
        Map<Dish.Type, Dish> mostCaloricByType =
                menu.stream()
                        .collect(groupingBy(Dish::getType, // 分类函数
                                collectingAndThen(
                                        maxBy(comparingInt(Dish::getCalories)), // 包装后的收集器
                                        Optional::get))); // 转换函数

这个工厂方法接受两个参数——要转换的收集器以及转换函数，并返回另外一个收集器。这个收集器至关于旧收集器的一个包装， collect 操做的最后一步就是将返回值用转换函数作一个映射。在这里，被包起来的收集器就是用 maxBy 创建的那个，而转换函数 Optional::get 则把返回的 Optional 中的值提取出来。前面已经说过，这个操做放在这里是安全的，由于 reducing收集器永远都不会返回 Optional.empty() 。其结果是下面的 Map ：

{OTHER=Dish{name='pizza'}, MEAT=Dish{name='pork'}, FISH=Dish{name='salmon'}}

把好几个收集器嵌套起来很常见，它们之间到底发生了什么可能不那么明显。从最外层开始逐层向里，注意如下几点：

  1. 收集器用虚线表示，所以 groupingBy 是最外层，根据菜肴的类型把菜单流分组，获得三个子流。
  2. groupingBy 收集器包裹着 collectingAndThen 收集器，所以分组操做获得的每一个子流都用这第二个收集器作进一步归约。
  3. collectingAndThen 收集器又包裹着第三个收集器 maxBy 。
  4. 随后由归约收集器进行子流的归约操做，而后包含它的 collectingAndThen 收集器会对其结果应用 Optional:get 转换函数。
  5. 对三个子流分别执行这一过程并转换而获得的三个值，也就是各个类型中热量最高的Dish ，将成为 groupingBy 收集器返回的 Map 中与各个分类键（ Dish 的类型）相关联的值。
与 groupingBy 联合使用的其余收集器的例子

通常来讲，经过 groupingBy 工厂方法的第二个参数传递的收集器将会对分到同一组中的全部流元素执行进一步归约操做。例如，你还重用求出全部菜肴热量总和的收集器，不过此次是对每一组 Dish 求和：

Map<Dish.Type, Integer> totalCaloriesByType = menu.stream()
                .collect(groupingBy(Dish::getType,
                        summingInt(Dish::getCalories)));

然而经常和 groupingBy 联合使用的另外一个收集器是 mapping 方法生成的。这个方法接受两个参数：一个函数对流中的元素作变换，另外一个则将变换的结果对象收集起来。其目的是在累加以前对每一个输入元素应用一个映射函数，这样就可让接受特定类型元素的收集器适应不一样类型的对象。咱们来看一个使用这个收集器的实际例子。比方说你想要知道，对于每种类型的 Dish ，菜单中都有哪些 CaloricLevel 。咱们能够把 groupingBy 和 mapping 收集器结合起来，以下所示：

Map<Dish.Type, Set<Dish.CaloricLevel>> caloricLevelsByType =
                menu.stream().collect(
                        groupingBy(Dish::getType, mapping(
                                dish -> {
                                    if (dish.getCalories() <= 400) {
                                        return Dish.CaloricLevel.DIET;
                                    } else if (dish.getCalories() <= 700) {
                                        return Dish.CaloricLevel.NORMAL;
                                    } else {
                                        return Dish.CaloricLevel.FAT;
                                    }
                                },
                                toSet())));

传递给映射方法的转换函数将 Dish 映射成了它的CaloricLevel ：生成的CaloricLevel 流传递给一个 toSet 收集器，它和 toList 相似，不过是把流中的元素累积到一个 Set 而不是 List 中，以便仅保留各不相同的值。如先前的示例所示，这个映射收集器将会收集分组函数生成的各个子流中的元素，让你获得这样的 Map 结果：

{OTHER=[DIET, NORMAL], MEAT=[DIET, FAT, NORMAL], FISH=[DIET, NORMAL]}

由此你就能够轻松地作出选择了。若是你想吃鱼而且在减肥，那很容易找到一道菜；一样，若是你饥肠辘辘，想要不少热量的话，菜单中肉类部分就能够知足你的饕餮之欲了。请注意在上一个示例中，对于返回的 Set 是什么类型并无任何保证。但经过使用 toCollection ，你就能够有更多的控制。例如，你能够给它传递一个构造函数引用来要求 HashSet ：

Map<Dish.Type, Set<Dish.CaloricLevel>> caloricLevelsByType =
                menu.stream().collect(
                        groupingBy(Dish::getType, mapping(
                                dish -> {
                                    if (dish.getCalories() <= 400) {
                                        return Dish.CaloricLevel.DIET;
                                    } else if (dish.getCalories() <= 700) {
                                        return Dish.CaloricLevel.NORMAL;
                                    } else {
                                        return Dish.CaloricLevel.FAT;
                                    }
                                },
                                toCollection(HashSet::new))));

使用流收集数据这一章，内容是比较多的，使用分组等特性能帮助咱们简化很大一部分的工做，从而提升咱们的开发效率。

代码

Github:chap6

Gitee:chap6

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程