流式编程基础内容解读

内容讲解：

介绍：

Stream相当于一个数据渠道，用于操作集合、数组等多种数据源所生成的元素序列

注意：

1、Stream 自己不会存储元素。

2、Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

3、Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream流步骤：

（1）创建 Stream：一个数据源(如:集合、数组)，获取一个流；

（2）中间操作：一个中间操作链，对数据源的数据进行处理；

（3）终止操作(终端操作)：一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用；

详细步骤及API解读：

步骤一：创建操作，Stream实例化

1）1）方式一：通过集合

Collection 接口被扩展，提供了两个获取流 的方法:

• default Stream<E> stream() : 返回一个顺序流
• default Stream<E> parallelStream() : 返回一个并行流

举例：Stream<Employee> stream = employees.stream();

2）方式二：通过数组

Arrays 的静态方法 stream() 可以获取数组流: 

• static <T> Stream<T> stream(T[] array): 返回一个流

举例：

        IntStream stream = Arrays.stream(arr);

        Stream<Employee> stream = Arrays.stream(arr);

3）方式三：通过Stream的of()

可以调用Stream类静态方法 of(), 通过显示值创建一个 流。它可以接收任意数量的参数。

• public static<T> Stream<T> of(T... values) : 返回一个流

4）方式四：创建无限流（了解，用得少）

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流

• 迭代：public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) 
• 生成：public static<T> Stream<T> generate(Supplier<T> s)

步骤二：中间操作

1）筛选与切片

• filter(Predicate p)：接收Lambda， 从流中排除某些元素

• distinct()：筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素

• limit(long maxSize)：截断流，使其元素不超过给定数量

• skip(long n)：跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n) 互补

2）映射

• map(Function f)：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

• mapToDouble(ToDoubleFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。

• mapToInt(ToIntFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream

• mapToLong(ToLongFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream

• flatMap(Function f)：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

3）排序

• sorted()：产生一个新流，其中按自然顺序排序

• sorted(Comparator com)：产生一个新流，其中按比较器顺序排序

步骤三：终止操作

注意：流终止操作后，就不能再使用了

1）匹配与查找

• allMatch(Predicate p)：检查是否匹配所有元素

• anyMatch(Predicate p)：检查是否至少匹配一个元素

• noneMatch(Predicate p)：检查是否没有匹配所有元素

• findFirst()：返回第一个元素

• findAny()：返回当前流中的任意元素

• count()：返回流中元素总数

• max(Comparator c)：返回流中最大值

• min(Comparator c)：返回流中最小值

• forEach(Consumer c)：内部迭代

2）归约

• reduce(T iden, BinaryOperator b)：从初始值iden开始，将流中元素反复结合起来，得到一个值。返回 T

• reduce(BinaryOperator b)：可以将流中元素反复结合起来，得到一 个值。返回 Optional<T>

3）收集

• collect(Collector c)：将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

试验demo：

要求：编写一个流式编程的demo

实际做法：找了一道流式编程的题目，使用代码进行8个问题的回答，实际代码如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class StreamDemo {

    private static List<Transaction> createTransactionList(){
        Trader trader1 = new Trader("wang", "北京");
        Trader trader2 = new Trader("li", "上海");
        Trader trader3 = new Trader("qian", "北京");

        List<Transaction> list = Arrays.asList(
                new Transaction(trader1,2011, 300),
                new Transaction(trader1, 2012, 1000),
                new Transaction(trader2, 2011, 400),
                new Transaction(trader2, 2012, 710),
                new Transaction(trader3, 2012, 700),
                new Transaction(trader3, 2012, 950)
        );

        return list;
    }

    //1. 找出 2011 年发生的所有交易， 并按交易额排序（从低到高）
    private static void test1(){
        List<Transaction> list = createTransactionList();
        list.stream()
                .filter((y) -> y.getYear() == 2011)
                .sorted((s1,s2) -> Integer.compare(s1.getValue(), s2.getValue()))
                .forEach(System.out::println);
    }

    //2. 交易员都在哪些不同的城市工作过
    private static void test2(){
        List<Transaction> list = createTransactionList();
        list.stream()
                .map((r) -> r.getTrader().getCity())
                .distinct()
                .forEach(System.out::println);
    }

    //3. 查找所有来自北京的交易员，并按姓名排序
    private static void test3(){
        List<Transaction> list = createTransactionList();
        list.stream()
                .map(Transaction::getTrader)
                .filter((n) -> n.getCity().equals("北京"))
                .distinct()
                .sorted((t1, t2) -> t1.getName().compareTo(t2.getName()))
                .forEach(System.out::println);
    }

    //4. 返回所有交易员的姓名字符串，按字母顺序排序
    private static void test4(){
        List<Transaction> list = createTransactionList();
        list.stream()
                .map((p) -> p.getTrader().getName())
                .distinct()
                .sorted(String::compareTo)
                .forEach(System.out::println);
    }

    //5. 有没有交易员是在北京工作的
    private static void test5(){
        List<Transaction> list = createTransactionList();
        list.stream()
                .map(Transaction::getTrader)
                .filter((p) -> p.getCity().equals("北京"))
                .distinct()
                .forEach(System.out::println);
    }

    //6. 打印生活在北京的交易员的所有交易额
    private static void test6(){
        List<Transaction> list = createTransactionList();
        Optional<Integer> t = list.stream()
                .filter((p) -> p.getTrader().getCity().equals("北京"))
                .map(Transaction::getValue)
                .reduce(Integer::sum);
        System.out.println(t.get());
    }

    //7. 所有交易中，最高的交易额是多少
    private static void test7(){
        List<Transaction> list = createTransactionList();
        Optional<Integer> optional = list.stream()
                .map(Transaction::getValue)
                .max(Integer::compare);
        System.out.println(optional.get());
    }

    //8. 找到交易额最小的交易
    private static void test8(){
        List<Transaction> list = createTransactionList();
        Optional<Transaction> first = list.stream()
                .sorted((s1, s2) -> Integer.compare(s1.getValue(), s2.getValue()))
                .findFirst();
        System.out.println(first.get());
    }

    public static void main(String[] args) {
        test8();
    }
}