Lambda表达式

9、Lambda表达式

　　java是强类型语言，必须指定类型

（String first, String second）->first.length()-second.length();

　　如果lambda表达式的表达体执行一个无法用一个表达式表示的计算，那么用{}包裹代码并明确些上return语句。

　　

1 (String first, String second) -> {
2     int difference = first.length() < second.length(); 3 if(difference <0) return -1; 4 else if(difference >0) return 1; 5 else return 0; 6 }

　　如果lambda表达式没有参数，则写一个空的小括号。

1 Runnable task = () -> { for(int i=0;i<1000;i++) doWork();}

　　如果lambda表达式的参数类型可以被对到出来，则可以省略类型。　　

Comparator<String> comp = (first, second) -> first.length() - second.lenght();

　　这里因为lambda表达式被赋值给String比较器，编译器可以推断出类型。如果某方法只有一个参数，且参数类型可推导，甚至可以省略小括号。

1 EventHandler<ActionEvent> listener = event -> System.out.println();

　　永远不要为lambda表达式指定返回类型，编译器会从lambda表达式推断出类型，并检查返回类型是否与期望的类型匹配。

10、函数式接口

　　无论何时，当你期望只有一个抽象方法的接口对象时，就可以提供一个lambda表达式。这样的接口被称为函数式接口

　　Arrays.sort方法。该方法的第二个参数要求一个Comparator接口的实例。直接提供一个lambda：

1 Array.sort(words,(first, second) -> first.length()-second.length());

　　表达式背后，Arrays.sort方法的第二个参数变量接受一个实现了Comparator<String>接口的类的实例。调用该对象的compare方法会执行lambda表达式中的代码。这些对象和类的管理完全依赖于实现，并是高度优化的。

　　在Java中，lambda表达式只能将其放入类型为函数式接口的变量中，这样他就被转换为该接口的实例。

　　不能将lambda表达式复制给Object的变量，因为Object是类，不是函数式接口。

11、方法引用

　　当传递给其他代码的操作已经有实现的方法了，可以使用方法引用

1 Arrays.sort(Strings, (x,y) -> x.compareToIgnoreCase(y));
2 //也可以传入方法表达式:
3 Arrays.sort(strings, String::compareToIgnoreCase);

　　Object定义了inNull方法，返回x==null的值。

list.removeIf(Object::isNull);

1 list.forEach(x-> System.out.println(x));
2 //可以写成
3 list.forEach(System.out::println);

 　　操作符::将方法名与类或对象分隔开

　　　　1、类::实例方法　　第一个参数变成方法的接受者，其他的参数也传递给该方法。

　　　　　　String::compareToIgnoreCase　　等同于　　(x,y)->x.compareToIgnoreCase(y)

　　　　2、类::静态方法　　所有的参数传递给静态方法。

　　　　　　Objects::isNull　　等同于　　x->Objects.isNull(x)

　　　　3、对象::实例方法　　在给定的对象上调用方法，并且参数传递给实例方法。

　　　　　　System.out::println　　等同于　　x->System.out.println(x)

　　　　在内部类中，可以用"外部类.this::方法名称"捕获外部类的this引用。

　　使用数组构造函数可以绕过java的限制，构造一个泛型数组。

　　　　Employee[] buttons = stream.toArray(Employee[]::new)

12、使用lambda表达式

　　1、实现延迟执行

　　　　使用lambda表达式就在于延迟执行。如果想立即执行一段代码，无需将代码封装进lambda，可以直接调用。

　　　　延迟执行的原因：（其实就是支持函数式变成的接口有哪些）

　　　　　　在另一个单独的线程中运行代码

　　　　　　多次运行代码

　　　　　　在算法的恰当时刻运行代码（排序中的比较操作）

　　　　　　当某些情况发生时运行代码（按钮被点击，数据到达）

　　　　　　只有在需要时才运行的代码

　　　　如：想将一个行为重复10次　　　　

repeat(10,()->System.out.println("a"));
//要选择一个函数式接口来接受lambda表达式
public static void repeat(int n, Runnalbe action){ for(int i=0;i<n;i++) action.run(); } //当action.run()被调用时，lambda表达式体被执行。

　　2、常用的函数式接口

　　

　　大多数标准的函数式接口都有用来产生或者组装函数的非抽象方法。Predicate.isEqual(a)与a::equals相同　

　　表3-2 为原始类型提供的函数式接口：p、q 为int、long、double 类型，P、Q 为Int、Long、Double 类型

 　　比如可以用IntConsumer代替Consumer<Integer>

　　3、实现自己的函数式接口

　　　　如果想用颜色填充一张图片，用户可以提供为每个像素产生颜色的函数，标准类型中没有（int,int）->color。这时可以用BiFunction<Integer,Integer,Color>但是这样会自动装箱。

　　或者定义一个新的接口：

1 @FunctionalInterface
2 public interface PixelFunction{ 3 Color apply(int x, int y) 4 }

　　用@FunctionalInterface注解标记函数式接口，这样编译器会检查出被注释的实体是一个带有单个抽象方法的接口。JavaDoc页面也会有函数式接口的声明。

　　实现如下：

 1 BufferedImage createImage(int width, int height, PixelFunction f){
 2     BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB); 3 for(int x =0;x<width;x++){ 4 for(int y =0;y<height;y++){ 5 Color color = f.apply(x,y)//这里f就是传入的lambda表达式 6  image.setRGB(x,y,color.getRGB()); 7  } 8  retrun image; 9  } 10 } 11 12 //调用 13 BufferedImage frenchFlag = createImage(150,100, 14 (x,y)->x<50?Color.Blue:x<100?Color.WHITE:Color.Red);

 13、lambda表达式的作用域

　　lambda表达式的方法体与嵌套代码块有相同的作用域。在lambda中不允许声明一个与局部变量同名的参数或局部变量。

int first = 0;
Comparator<String> comp =(first,second) ->first.length() - second.length();
//错误：变量first已经定义了

　　lambda中的this代表的是创建lambda表达式方法的this参数。

public class Application(){
  public void dowork(){
      Runnable runner = () ->{...;Sysout(this.toString);}
  }      
}

　　this.toString是调用Application对象的toString()方法，lambda的作用域被嵌套在dowork方法中。

14、访问来自闭合作用域的变量

　　在lambda中访问来自闭合方法或类的变量。

public static void repeatMessage(String text,int count){
  Runnable r = () -> {
       for(int i =0;i<count;i++){
            System.out.println(text);
       }
   };
    new Thread(r).start();  
}    

　　lambda访问了定义在闭合域，而不是定义在表达式自身中的参数标量text

　　如果repeatMessage（“A”，1000）//在单独的线程中将A打印1000次

　　如果lambda在repeatMessage返回之后很久才运行，此时参数变量已经消失了。

15、lambda表达式的理解

　　lambda表达式分为三个部分：1、代码块　　2、参数　　3、自由变量的值（既不是参数标量，也不是代码内部定义的变量）

　　在repeatMessage中lambda由两个自由变量，text和count。这些变量其实已经被lambda捕获了（通过一个具体的实现细节来完成捕获工作，将lambda转变为带有一个方法的对象，这样自由变量的值就可以复制到对象的实例变量中）

　　闭包（closure）描述带有自由变量值得代码块的技术，在java中lambda就是闭包

　　lambda只能引用哪些值不会改变的变量，只能捕获变量的值，而不是变量的引用。

for(int i=0;i<n;i++){
    new Thread(()->System.out.println(i)).start();
    //错误，不能捕获i
}

　　lambda只能访问来自闭合作用域的final局部变量。（同样的规则适用于被局部内部类捕获的变量）

　　注意：增强的for循环中的变量是有效final的，因为他的作用域是单个迭代。

for(String arg: args){
    new Thread(()->System.out.println(arg)).start();
    //可以捕获
}

　　作为“有效final”规则的结果，lambda不能改变任何捕获的变量。可以有效的防止多线程下的冲突。

　　　　禁止修改变量只是针对局部变量。如果count是实例变量或者外部类的静态变量，及时并发时结果不确定，也不会有错误报告。

//可以用长度为1的数组绕过限制
int[] counter = new int[1];
button.setOnAction(event->counter[0]++);
//counter是有效final的，一直引用同意个数组。但是是线程不安全的。

16、高阶函数

　　处理货返回函数的函数称为高阶函数。

　　1、返回函数的方法

　　　　假如想对字符串进行升序或降序排序。创建一个会产生正确比较器（comparator）的方法

public static Comparator<String> compareInDirection(int direction){
    return (x,y) -> direction * x.compareTo(y);
}

　　　　可以传递给另一个期望这种借口的方法

　　　　Arrays.sort(friends, comparaInDirection(-1));

　　2、修改函数的方法

list.sort(reverse(compare()));

  public static Comparator<Integer> compare() {
    return (x,y) -> x.compareTo(y);
  }

  public static Comparator<Integer> reverse(Comparator<Integer> comp){
    return (x,y) -> comp.compare(y, x);
  }

　　3、Comparator

　　Comparator接口有很多有用的静态方法，他们是产生comparator的高阶函数。

　　　　comparing方法接受“key提取器”函数，将类型T映射到可比较的类型。函数可以引用到被比较的对象，并且是在返回的key上进行的比较。

Arrays.sort(people, Comparator.comparing(Person::getName));
Arrays.sort(people, Comparator.comparing(Person::getName).thenComparing(Person::getFirstName));
// 根据名字长度进行排序
Arrays.sort(people, Comparator.comparing(Person::getName),(s,t)->s.lenght-t.length()));

　　　　为了避免装箱可以使用comparingInt

Arrays.sort(people,Comparator.comparingInt(p->p.getName().length()));

　　　　为了防止空指针异常，当有空对象时可以使用nullsFirst和nullsLast。使用naturalOrder和reserveOrder可以返回正序和逆序两种比较器（自动推断类型）。

Arrays.sort(people, comparing(Person::getMiddleName, nullsFirst(naturalOrder())));

17、局部内部类

　　在方法里定义的类为局部类。

//产生给定范围的无限序列随机整数
public static IntSequence randomInts(int low, int high)
//因为IntSequence是个接口，所以必须返回实现该接口的某个类的对象

private static Random generator = new Random();

public static InSequence randomInts(int low, int high){
    Class RandomSequence implements IntSequence{
        public int next() {return low+generator.nextInt(high-low+1);}
        public boolean hasNext() {return true;}
    }
    return new RandomSequence();
}

　　局部类没有声明为public或private，因为对方法外部而言它是永远不可访问的。如果将RandomSequence转变为嵌套类，将不得不提供一个显示的构造函数，接受闭合作用域变量，但是用内部类就不用。

//现在可以使用lambda表达式
public static IntSequence randomInts(int low, int high){
    return ()->low + generator.nextInt(high - low + 1);
}