目录

简介

• 集合，包括数组、文件等，只要是可以转换成流，可以借助流式处理

  
  流式处理图.png
• 更多含义可参考最底下的参考文章。
• 流是懒加载的。这代表着它只在绝对必要时才计算。你可以将流看作“延迟列表”。由于计算延迟，流使我们能够表示非常大（甚至无限）的序列，而不需要考虑内存问题

实例

将SearchHit[]转换成 List<ESSearchHit>

 List<ESSearchHit> hits = new ArrayList<>();
 Arrays.asList(searchHits.getHits()).stream().forEach(item -> hits.add(new ESSearchHit(item)));

过滤掉偶数数据

List<Integer> evens = nums.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());

方法引用

• 未绑定方法引用（如果将方法引用或 Lambda 表达式赋值给函数式接口（类型需要匹配），Java 会适配你的赋值到目标接口。 编译器会在后台把方法引用或 Lambda 表达式包装进实现目标接口的类的实例中。）

class X {
  String f() { return "X::f()"; }
}

interface MakeString {
  String make();
}

interface TransformX {
  String transform(X x);
}

public class UnboundMethodReference {
  public static void main(String[] args) {
    // 此方法时未绑定方法引用
    TransformX sp = X::f;
    X x = new X();
    // 此方法最终调用x.f()
    System.out.println(sp.transform(x)); 
    System.out.println(x.f()); // 同等效果
  }
}

• 构造函数方法引用（有点像未绑定方法引用）

class Dog {
  String name;
  int age = -1;
  Dog(String nm) { name = nm; }
}

interface Make1Arg {
  Dog make(String nm);
}


public class CtorReference {
  public static void main(String[] args) {
    Make1Arg m1a = Dog::new;   
    Dog d1 = m1a.make("Comet");
  }
}

• 被 Lambda 表达式引用的局部变量，参数必须是 final。

1. 新开线程: 外部线程可能都执行完了，新开的线程还没执行完，用fianl延迟变量的生命周期，不然可能就找不到对应变量值了
2. 内部类: 通常都含有回调，引用那个匿名内部类的函数执行完了就没了，所以内部类中引用外面的局部变量需要是final的，这样在回调的时候才能找到那个变量(延长生命周期)，而如果是外围类的成员变量就不需要是final的，因为内部类本身都会含有一个外围了的引用（外围类.this），所以回调的时候一定可以访问到。为了避免：1. 外部方法修改引用，而导致内部类得到的引用值不一致 2.内部类修改引用，而导致外部方法的参数值在修改前和修改后不一致。

IntSupplier makeFun(int x) {
    Integer i = 0;
    i = i + 1;
    return () -> x + i;
}

IntSupplier makeFun1(int x) {
    int i = 0;
    // 同样规则的应用两个都无法通过编译:
     i++; // 非等同 final 效果
     x++; // 同上
    return new IntSupplier() {
        public int getAsInt() { return x + i; }
    };
}

new Thread(() -> {
    x = x + 3;
    System.out.println("ee");
});

• 柯里化，多参数

public static void main(String[] args) {
  // 柯里化的函数:
  Function<String, Function<String, String>> sum =
     a -> b -> a + b; // [1]

  System.out.println(uncurried("Hi ", "Ho"));

  Function<String, String>
    hi = sum.apply("Hi "); // [2]
  System.out.println(hi.apply("Ho"));

  // 部分应用:
  Function<String, String> sumHi =
    sum.apply("Hup ");
  System.out.println(sumHi.apply("Ho"));
  System.out.println(sumHi.apply("Hey"));
}

参考文章

• java8新特性