理论阶段

函数接口

函数接口是行为的抽象；

函数接口是数据转换器;

java.util.Function包。定义了四个最基础的函数接口：

Supplier<T>: 数据提供器，可以提供 T 类型对象；无参的构造器，提供了 get 方法；

Function<T,R>: 数据转换器，接收一个 T 类型的对象，返回一个 R类型的对象；单参数单返回值的行为接口；提供了 apply, compose, andThen, identity 方法；

Consumer<T>: 数据消费器，接收一个 T类型的对象，无返回值，通常用于设置T对象的值；单参数无返回值的行为接口；提供了 accept, andThen 方法；

Predicate<T>: 条件测试器，接收一个 T 类型的对象，返回布尔值，通常用于传递条件函数；单参数布尔值的条件性接口。提供了 test (条件测试) , and|or|negate(与或非) 方法。

其中, compose, andThen, and, or, negate 用来组合函数接口而得到更强大的函数接口。

其它的函数接口都是通过这四个扩展而来。

在参数个数上扩展：比如接收双参数的，有 Bi 前缀，比如 BiConsumer<T,U>, BiFunction<T,U,R> ;

在类型上扩展：比如接收原子类型参数的，有 [Int|Double|Long][Function|Consumer|Supplier|Predicate]

特殊常用的变形：比如 BinaryOperator ，是同类型的双参数 BiFunction<T,T,T> ，二元操作符； UnaryOperator 是 Function<T,T> 一元操作符。

这些函数接口可以接收哪些值呢？

类/对象的静态方法引用、实例方法引用。引用符号为双冒号 ::

类的构造器引用，比如 Class::new

lambda表达式

聚合器

每一个流式计算的末尾总有一个类似 collect(Collectors.toList()) 的方法调用。collect 是 Stream 的方法，而参数则是聚合器Collector。已有的聚合器定义在Collectors 的静态方法里。

那么这个聚合器是怎么实现的呢？大部分聚合器都是基于 Reduce 操作实现的。 Reduce ，名曰推导，含有三个要素：初始值 init, 二元操作符 BinaryOperator, 以及一个用于聚合结果的数据源S。

Reduce 的算法如下：

初始化结果 R = init ；

每次从 S 中取出一个值 v，通过二元操作符施加到 R 和 v ，产生一个新值赋给 R = BinaryOperator(R, v)；重复 STEP2，直到 S 中没有值可取为止。

一个聚合器的实现，通常需要提供四要素：

一个结果容器的初始值提供器 supplier ；

一个用于将每次二元操作的中间结果与结果容器的值进行操作并重新设置结果容器的累积器 accumulator ；

一个用于对Stream元素和中间结果进行操作的二元操作符 combiner ；

一个用于对结果容器进行最终聚合的转换器 finisher（可选) 。

Collectors.CollectorImpl 的实现展示了这一点：

static class CollectorImpl
     
       implements Collector
      
        {        private final Supplier
        supplier;        private final BiConsumer
        
          accumulator;        private final BinaryOperator
        
        combiner;        private final Function
        
          finisher;        private final Set
         
           characteristics;        CollectorImpl(Supplier
         
        
        supplier,                      BiConsumer
        
          accumulator,                      BinaryOperator
        
        combiner,                      Function
        
          finisher,                      Set
         
           characteristics) {            this.supplier = supplier;            this.accumulator = accumulator;            this.combiner = combiner;            this.finisher = finisher;            this.characteristics = characteristics;        }}

自定义聚合器

public class TestCollector implements Collector
     
      , List
      
       > {    public Supplier
       
        
         > supplier() {        return () -> {            List
         
           res = combiner().apply(Lists.newArrayList(), null);            res.add(4);            System.out.println("supplier\t" + res);            return res;        };    }    @Override    public BiConsumer
          
           
            , Integer> accumulator() { return (res, num) -> { System.out.println("accumulator\tres\t" + res + "num\t" + num); if (num > res.get(0)) { res.add(num); } }; } @Override public BinaryOperator
            
             
              > combiner() { System.out.println("combiner"); return (left, right) -> { System.out.println("combiner\tleft\t" + left + "right\t" + right); if (left != null) { return left; } return right; }; } @Override public Function
              
               
                , List
                
                 > finisher() { return res -> { System.out.println("finisher\t" + res); res.remove(0); return res; }; } @Override public Set
                 
                   characteristics() { System.out.println("characteristics"); return Collections.emptySet(); } public static void main(String[] args) { List
                  
                    test = Stream.of(1, 4, 3, 4, 5, 6, 7, 3, 9, 4).collect(new TestCollector()); System.out.println("result:" + test); }}//寻找比4大的值combinercharacteristicscombinercombiner left []right nullsupplier [4]accumulator res [4]num 1accumulator res [4]num 4accumulator res [4]num 3accumulator res [4]num 4accumulator res [4]num 5accumulator res [4, 5]num 6accumulator res [4, 5, 6]num 7accumulator res [4, 5, 6, 7]num 3accumulator res [4, 5, 6, 7]num 9accumulator res [4, 5, 6, 7, 9]num 4characteristicsfinisher [4, 5, 6, 7, 9]result:[5, 6, 7, 9]

流

Stream 主要有四类接口：

流到流之间的转换：比如 filter(过滤), map(映射转换), mapTo[Int|Long|Double] (到原子类型流的转换), flatMap(高维结构平铺)，flatMapTo[Int|Long|Double], sorted(排序)，distinct(不重复值)，peek(执行某种操作，流不变，可用于调试)，limit(限制到指定元素数量), skip(跳过若干元素) ；

流到终值的转换：比如 toArray（转为数组），reduce（推导结果），collect（聚合结果），min(最小值), max(最大值), count (元素个数)， anyMatch (任一匹配), allMatch(所有都匹配)， noneMatch(一个都不匹配)， findFirst（选择首元素），findAny(任选一元素) ；

直接遍历： forEach (不保序遍历，比如并行流), forEachOrdered（保序遍历) ；

构造流： empty (构造空流)，of (单个元素的流及多元素顺序流)，iterate (无限长度的有序顺序流)，generate (将数据提供器转换成无限非有序的顺序流)， concat (流的连接)， Builder (用于构造流的Builder对象)

流的类型主要有：Reference(对象流)， IntStream (int元素流), LongStream (long元素流)， Double (double元素流) ，定义在类 StreamShape 中，主要将操作适配于类型系统。

λ表达式语法

λ表达式本质上是一个匿名方法。

λ表达式有三部分组成：参数列表，箭头（->），以及一个表达式或语句块。

基本语法: (parameters) -> expression或(parameters) ->{ statements; }

lambda表达式的语法由参数列表、箭头符号->和函数体组成。函数体既可以是一个表达式，也可以是一个语句块：

表达式：表达式会被执行然后返回执行结果。语句块：语句块中的语句会被依次执行，就像方法中的语句一样。
- return语句会把控制权交给匿名方法的调用者
- break和continue只能在循环中使用
- 如果函数体有返回值，那么函数体内部的每一条路径都必须返回值

λ表达式的类型

λ表达式的类型，叫做“目标类型（target type）”。λ表达式的目标类型是“函数接口（functional interface）”。

它的定义是：一个接口，如果只有一个显式声明的抽象方法，那么它就是一个函数接口。一般用@FunctionalInterface标注(在编译期可以验证你这个接口是否是函数接口)（也可以不标）。

λ表达式的类型是由其上下文推导而来。

Callable<String> c = () -> "done";

PrivilegedAction<String> a = () -> "done";

第一个lambda表达式() -> "done"是Callable的实例，而第二个lambda表达式则是PrivilegedAction的实例。

编译器负责推导lambda表达式的类型。它利用lambda表达式所在上下文所期待的类型进行推导，这个被期待的类型被称为目标类型。

lambda表达式对目标类型也是有要求的。编译器会检查lambda表达式的类型和目标类型的方法签名（method signature）是否一致。

当且仅当下面所有条件均满足时，lambda表达式才可以被赋给目标类型T（@FunctionalInterface验证的维度）：

T是一个函数式接口

lambda表达式的参数和T的方法参数在数量和类型上一一对应

lambda表达式的返回值和T的方法返回值相兼容（Compatible）

lambda表达式内所抛出的异常和T的方法throws类型相兼容

lambda表达式并不是第一个拥有上下文相关类型的Java表达式：泛型方法调用和“菱形”构造器调用也通过目标类型来进行类型推导：

List<String> ls = Collections.emptyList(); List<Integer> li = Collections.emptyList();

Map<String, Integer> m1 = new HashMap<>(); Map<Integer, String> m2 = new HashMap<>();

变量捕获（Variable capture）

捕获的概念在于解决在λ表达式中我们可以使用哪些外部变量（即除了它自己的参数和内部定义的本地变量）的问题。

与内部类非常相似，但有不同点。不同点在于内部类总是持有一个其外部类对象的引用。λ表达式呢，除非在它内部用到了其外部类对象的方法或者成员，否则它就不持有这个对象的引用。

这个特性对内存管理是一件好事：内部类实例会一直保留一个对其外部类实例的强引用，而那些没有捕获外部类成员的lambda表达式则不会保留对外部类实例的引用。要知道内部类的这个特性往往会造成内存泄露。

在Java8以前，如果要在内部类访问外部对象的一个本地变量，那么这个变量必须声明为final才行。在Java8中，这种限制被去掉了，代之以一个新的概念，有效只读－“effectively final”。它的意思是你可以声明为final，也可以不声明final但是按照final来用，也就是一次赋值永不改变。换句话说，保证它加上final前缀后不会出编译错误。

Java要求本地变量final或者effectively final的原因是多线程并发问题。内部类、λ表达式都有可能在不同的线程中执行，允许多个线程同时修改一个本地变量不符合Java的设计理念。lambda表达式对值封闭，对变量开放。

lambda表达式不支持修改捕获变量的另一个原因是我们可以使用更好的方式来实现同样的效果：使用规约（reduction）。

java.util.stream包提供了各种通用的和专用的规约操作（例如sum、min和max）。

int sum = list.stream() .mapToInt(e -> e.size()) .sum();

sum()等价于下面的规约操作： int sum = list.stream() .mapToInt(e -> e.size()) .reduce(0 , (x, y) -> x + y);

规约需要一个初始值（以防输入为空）和一个操作符（在这里是加号），然后用下面的表达式计算结果：0 + list[0] + list[1] + list[2] + ...

方法引用（Method references）

任何一个λ表达式都可以代表某个函数接口的唯一方法的匿名描述符。我们也可以使用某个类的某个具体方法来代表这个描述符，叫做方法引用。

方法引用和lambda表达式拥有相同的特性，我们并不需要为方法引用提供方法体，我们可以直接通过方法名称引用已有方法。

下面是一组例子，教你使用方法引用代替λ表达式：

//c1 与 c2 是一样的（静态方法引用）

Comparator<Integer> c2 = (x, y) -> Integer.compare(x, y);

Comparator<Integer> c1 = Integer::compare;

//下面两句是一样的（实例方法引用1）

persons.forEach(e -> System.out.println(e));

persons.forEach(System.out::println);

//下面两句是一样的（实例方法引用2）

persons.forEach(person -> person.eat());

persons.forEach(Person::eat);

//下面两句是一样的（构造器引用）

strList.stream().map(s -> new Integer(s));

strList.stream().map(Integer::new);

还有一些其它的方法引用:

super::toString //引用某个对象的父类方法

String[]::new //引用一个数组的构造器

默认方法和静态接口方法

Java8中，接口声明里可以有方法实现了，叫做默认方法。在此之前，接口里的方法全部是抽象方法。

这实际上混淆了接口和抽象类，但一个类仍然可以实现多个接口，而只能继承一个抽象类。

这么做的原因是：由于Collection库需要为批处理操作添加新的方法，如forEach()，stream()等，但是不能修改现有的Collection接口——如果那样做的话所有的实现类都要进行修改，包括很多客户自制的实现类。所以只好使用这种妥协的办法。

如此一来，我们就面临一种类似多继承的问题。如果类Sub继承了两个接口，Base1和Base2，而这两个接口恰好具有完全相同的两个默认方法，那么就会产生冲突。这时Sub类就必须通过重载来显式指明自己要使用哪一个接口的实现（或者提供自己的实现）。

public class Sub implements Base1, Base2 {        public void hello() {            Base1.super.hello(); //使用Base1的实现        }    }

除了默认方法，Java8的接口也可以有静态方法的实现

public interface MyInterf {        String m1();        default String m2() {            return "Hello default method!";        }        static String m3() {            return "Hello static method in Interface!";        }    }

生成器函数（Generator function）

有时候一个流的数据源不一定是一个已存在的集合对象，也可能是个“生成器函数”。一个生成器函数会产生一系列元素，供给一个流。

Stream.generate(Supplier<T> s)就是一个生成器函数。其中参数Supplier是一个函数接口，里面有唯一的抽象方法 <T> get()。

下面这个例子生成并打印5个随机数：Stream.generate(Math::random).limit(5).forEach(System.out::println);

注意这个limit(5)，如果没有这个调用，那么这条语句会永远地执行下去。也就是说这个生成器是无穷的。这种调用叫做终结操作，或者短路（short-circuiting）操作。

λ表达式与集合类批处理操作（或者叫块操作）

集合类的批处理操作API的目的是实现集合类的“内部迭代”，并期望充分利用现代多核CPU进行并行计算。

Java8之前集合类的迭代（Iteration）都是外部的，即客户代码。而内部迭代意味着改由Java类库来进行迭代，而不是客户代码。

for(Object o: list) { // 外部迭代

System.out.println(o);

}

可以写成: list.forEach(o -> {System.out.println(o);}); //forEach函数实现内部迭代

集合类（包括List）现在都有一个forEach方法，对元素进行迭代（遍历），所以我们不需要再写for循环了。forEach方法接受一个函数接口Consumer做参数，所以可以使用λ表达式。

Java8为集合类引入了另一个重要概念：流（stream）。一个流通常以一个集合类实例为其数据源，然后在其上定义各种操作。

流的API设计使用了管道（pipelines）模式。对流的一次操作会返回另一个流。stream()如同IO的API或者StringBuffer的append方法那样，从而多个不同的操作可以在一个语句里串起来。

还有一个方法叫parallelStream()，顾名思义它和stream()一样，只不过指明要并行处理，以期充分利用现代CPU的多核特性。

//给出一个String类型的数组，找出其中所有不重复的素数

public void distinctPrimary(String... numbers) {

List<String> l = Arrays.asList(numbers);

List<Integer> r = l.stream()

.map(e -> new Integer(e))

.filter(e -> Primes.isPrime(e))

.distinct()

.collect(Collectors.toList());

System.out.println("distinctPrimary result is: " + r);

}

第一步：传入一系列String（假设都是合法的数字），转成一个List，然后调用stream()方法生成流。

第二步：调用流的map方法把每个元素由String转成Integer，得到一个新的流。map方法接受一个Function类型的参数，上面介绍了，Function是个函数接口，所以这里用λ表达式。

第三步：调用流的filter方法，过滤那些不是素数的数字，并得到一个新流。filter方法接受一个Predicate类型的参数，上面介绍了，Predicate是个函数接口，所以这里用λ表达式。

第四步：调用流的distinct方法，去掉重复，并得到一个新流。这本质上是另一个filter操作。

第五步：用collect方法将最终结果收集到一个List里面去。collect方法接受一个Collector类型的参数，这个参数指明如何收集最终结果。在这个例子中，结果简单地收集到一个List中。我们也可以用Collectors.toMap(e->e, e->e)把结果收集到一个Map中，它的意思是：把结果收到一个Map，用这些素数自身既作为键又作为值。toMap方法接受两个Function类型的参数，分别用以生成键和值，Function是个函数接口，所以这里都用λ表达式。

你可能会觉得在这个例子里，List l被迭代了好多次，map，filter，distinct都分别是一次循环，效率会不好。实际并非如此。这些返回另一个Stream的方法都是“懒（lazy）”的，而最后返回最终结果的collect方法则是“急（eager）”的。在遇到eager方法之前，lazy的方法不会执行。

当遇到eager方法时，前面的lazy方法才会被依次执行。而且是管道贯通式执行。这意味着每一个元素依次通过这些管道。例如有个元素“3”，首先它被map成整数型3；然后通过filter，发现是素数，被保留下来；又通过distinct，如果已经有一个3了，那么就直接丢弃，如果还没有则保留。这样，3个操作其实只经过了一次循环。

使用阶段

基本栗子

String[] atp = {"Rafael Nadal", "Novak Djokovic",         "Stanislas Wawrinka",         "David Ferrer","Roger Federer",         "Andy Murray","Tomas Berdych",         "Juan Martin Del Potro"};  List
     
       players =  Arrays.asList(atp);    // 以前的循环方式  for (String player : players) {       System.out.print(player + "; ");  }    // 使用 lambda 表达式以及函数操作(functional operation)  players.forEach((player) -> System.out.print(player + "; "));     // 在 Java 8 中使用双冒号操作符(double colon operator)  players.forEach(System.out::println);

匿名内部类栗子

// 使用匿名内部类  btn.setOnAction(new EventHandler
     
      () {            @Override            public void handle(ActionEvent event) {                System.out.println("Hello World!");             }      });     // 或者使用 lambda expression  btn.setOnAction(event -> System.out.println("Hello World!"));

Runable栗子

// 1.1使用匿名内部类  new Thread(new Runnable() {      @Override      public void run() {          System.out.println("Hello world !");      }  }).start();    // 1.2使用 lambda expression  new Thread(() -> System.out.println("Hello world !")).start();    // 2.1使用匿名内部类  Runnable race1 = new Runnable() {      @Override      public void run() {          System.out.println("Hello world !");      }  };    // 2.2使用 lambda expression  Runnable race2 = () -> System.out.println("Hello world !");     // 直接调用 run 方法(没开新线程哦!)  race1.run();  race2.run();

使用Lambdas排序集合

String[] players = {"Rafael Nadal", "Novak Djokovic",       "Stanislas Wawrinka", "David Ferrer",      "Roger Federer", "Andy Murray",      "Tomas Berdych", "Juan Martin Del Potro",      "Richard Gasquet", "John Isner"};     // 1.1 使用匿名内部类根据 name 排序 players  Arrays.sort(players, new Comparator
     
      () {      @Override      public int compare(String s1, String s2) {          return (s1.compareTo(s2));      }  });  // 1.2 使用 lambda expression 排序 players  Comparator
      
        sortByName = (String s1, String s2) -> (s1.compareTo(s2));  Arrays.sort(players, sortByName);    // 1.3 也可以采用如下形式:  Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));  // 1.1 使用匿名内部类根据 surname 排序 players  Arrays.sort(players, new Comparator
       
        () {      @Override      public int compare(String s1, String s2) {          return (s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" "))));      }  });    // 1.2 使用 lambda expression 排序,根据 surname  Comparator
        
          sortBySurname = (String s1, String s2) ->       ( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) );  Arrays.sort(players, sortBySurname);    // 1.3 或者这样,怀疑原作者是不是想错了,括号好多...  Arrays.sort(players, (String s1, String s2) ->         ( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) )       );    // 2.1 使用匿名内部类根据 name lenght 排序 players  Arrays.sort(players, new Comparator
         
          () {      @Override      public int compare(String s1, String s2) {          return (s1.length() - s2.length());      }  });    // 2.2 使用 lambda expression 排序,根据 name lenght  Comparator
          
            sortByNameLenght = (String s1, String s2) -> (s1.length() - s2.length()); Arrays.sort(players, sortByNameLenght); // 2.3 or this Arrays.sort(players, (String s1, String s2) -> (s1.length() - s2.length())); // 3.1 使用匿名内部类排序 players, 根据最后一个字母 Arrays.sort(players, new Comparator
           
            () { @Override public int compare(String s1, String s2) { return (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)); } }); // 3.2 使用 lambda expression 排序,根据最后一个字母 Comparator
            
              sortByLastLetter = (String s1, String s2) -> (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)); Arrays.sort(players, sortByLastLetter); // 3.3 or this Arrays.sort(players, (String s1, String s2) -> (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)));

使用Lambdas和Streams

public class Person {    private String firstName, lastName, job, gender;  private int salary, age;    public Person(String firstName, String lastName, String job,                  String gender, int age, int salary)       {            this.firstName = firstName;            this.lastName = lastName;            this.gender = gender;            this.age = age;            this.job = job;            this.salary = salary;  }  // Getter and Setter   // . . . . .  }  List
     
       javaProgrammers = new ArrayList
      
       () {    {      add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000));      add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500));      add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800));      add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600));      add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200));      add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900));      add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300));      add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700));      add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000));      add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300));    }  };    List
       
         phpProgrammers = new ArrayList
        
         () {    {      add(new Person("Jarrod", "Pace", "PHP programmer", "male", 34, 1550));      add(new Person("Clarette", "Cicely", "PHP programmer", "female", 23, 1200));      add(new Person("Victor", "Channing", "PHP programmer", "male", 32, 1600));      add(new Person("Tori", "Sheryl", "PHP programmer", "female", 21, 1000));      add(new Person("Osborne", "Shad", "PHP programmer", "male", 32, 1100));      add(new Person("Rosalind", "Layla", "PHP programmer", "female", 25, 1300));      add(new Person("Fraser", "Hewie", "PHP programmer", "male", 36, 1100));      add(new Person("Quinn", "Tamara", "PHP programmer", "female", 21, 1000));      add(new Person("Alvin", "Lance", "PHP programmer", "male", 38, 1600));      add(new Person("Evonne", "Shari", "PHP programmer", "female", 40, 1800));    }  };  现在我们使用forEach方法来迭代输出上述列表:System.out.println("所有程序员的姓名:");  javaProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));  phpProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));  我们同样使用forEach方法,增加程序员的工资5%:System.out.println("给程序员加薪 5% :");  Consumer
         
           giveRaise = e -> e.setSalary(e.getSalary() / 100 * 5 + e.getSalary());  javaProgrammers.forEach(giveRaise);  phpProgrammers.forEach(giveRaise);  另一个有用的方法是过滤器filter() ,让我们显示月薪超过1400美元的PHP程序员:System.out.println("下面是月薪超过 $1,400 的PHP程序员:")  phpProgrammers.stream()            .filter((p) -> (p.getSalary() > 1400))            .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));  我们也可以定义过滤器,然后重用它们来执行其他操作:// 定义 filters  Predicate
          
            ageFilter = (p) -> (p.getAge() > 25); Predicate
           
             salaryFilter = (p) -> (p.getSalary() > 1400); Predicate
            
              genderFilter = (p) -> ("female".equals(p.getGender())); System.out.println("下面是年龄大于 24岁且月薪在$1,400以上的女PHP程序员:"); phpProgrammers.stream() .filter(ageFilter) .filter(salaryFilter) .filter(genderFilter) .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); // 重用filters System.out.println("年龄大于 24岁的女性 Java programmers:"); javaProgrammers.stream() .filter(ageFilter) .filter(genderFilter) .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 使用limit方法,可以限制结果集的个数:System.out.println("最前面的3个 Java programmers:"); javaProgrammers.stream() .limit(3) .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); System.out.println("最前面的3个女性 Java programmers:"); javaProgrammers.stream() .filter(genderFilter) .limit(3) .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 根据名字和薪水排序Java程序员,放到一个list中,然后显示列表System.out.println("根据 name 排序,并显示前5个 Java programmers:"); List
             
               sortedJavaProgrammers = javaProgrammers .stream() .sorted((p, p2) -> (p.getFirstName().compareTo(p2.getFirstName()))) .limit(5) .collect(toList()); sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName())); System.out.println("根据 salary 排序 Java programmers:"); sortedJavaProgrammers = javaProgrammers .stream() .sorted( (p, p2) -> (p.getSalary() - p2.getSalary()) ) .collect( toList() ); sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName())); 如果我们只对最低和最高的薪水感兴趣,比排序后选择第一个/最后一个 更快的是min和max方法:System.out.println("工资最低的 Java programmer:"); Person pers = javaProgrammers .stream() .min((p1, p2) -> (p1.getSalary() - p2.getSalary())) .get() System.out.printf("Name: %s %s; Salary: $%,d.", pers.getFirstName(), pers.getLastName(), pers.getSalary()) System.out.println("工资最高的 Java programmer:"); Person person = javaProgrammers .stream() .max((p, p2) -> (p.getSalary() - p2.getSalary())) .get() System.out.printf("Name: %s %s; Salary: $%,d.", person.getFirstName(), person.getLastName(), person.getSalary()) 结合 map 方法,我们可以使用 collect 方法来将我们的结果集放到一个字符串,一个 Set 或一个TreeSet中System.out.println("将 PHP programmers 的 first name 拼接成字符串:"); String phpDevelopers = phpProgrammers .stream() .map(Person::getFirstName) .collect(joining(" ; ")); // 在进一步的操作中可以作为标记(token) System.out.println("将 Java programmers 的 first name 存放到 Set:"); Set
              
                javaDevFirstName = javaProgrammers .stream() .map(Person::getFirstName) .collect(toSet()); System.out.println("将 Java programmers 的 first name 存放到 TreeSet:"); TreeSet
               
                 javaDevLastName = javaProgrammers .stream() .map(Person::getLastName) .collect(toCollection(TreeSet::new)); Streams 还可以是并行的(parallel)System.out.println("计算付给 Java programmers 的所有money:"); int totalSalary = javaProgrammers .parallelStream() .mapToInt(p -> p.getSalary()) .sum(); 以使用summaryStatistics方法获得stream 中元素的各种汇总数据。 接下来,我们可以访问这些方法,比如getMax, getMin, getSum或getAverage//计算 count, min, max, sum, and average for numbers List
                
                  numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); IntSummaryStatistics stats = numbers .stream() .mapToInt((x) -> x) .summaryStatistics(); System.out.println("List中最大的数字 : " + stats.getMax()); System.out.println("List中最小的数字 : " + stats.getMin()); System.out.println("所有数字的总和 : " + stats.getSum()); System.out.println("所有数字的平均值 : " + stats.getAverage());