java Lambda表达式

Lambda 表达式：传递方法、代码块（函数式编程）。

Lambda表达式定义

• Lambda表达式组成：参数，箭头，一个表达式或者多个语句。

例子1：

(String first, String second)
    -> first.length() - second.length()

//形参可以不写类型。
//一个形参可以不写括号，
//没有形参就保留括号。
//有return 或多个语句一定要接大括号。
//单个语句，可直接写返回值。

例子2

(first, second) -> 
{ 
    int resurt = first.length() - second.length();
    return result;
}

例子3

new Thread(
    () ->{
             int sum = 0;
             for(int i = 1; i <= 100; i++)
                 sum += i;
             System.out.println("the sum is " + sum);
    }
).start();

例子4

//函数式接口
public interface Add{
    public int selfAdd(int x);
}

Add A = x -> x++;
//其中，x是传入的参数，x++是表达式。该表达式会自动与函数式接口Add中的唯一一个为实现的方法selfAdd组合。
//再使用对象A调用组合实现的selfAdd。
A.selfAdd(10);

---

函数式接口

• 是一个只包含一个抽象方法（未实现）的接口；
• 可以包含default，static，private方法。
• 采用Lambda表达式可以自动创建一个（伪）嵌套类对象:（没有实际的.class文件产生），然后使用。比真正的嵌套类更加简洁高效。

例子5

Arrays.sort(T[], Comparator<? supper T>c);

写法1：

String[] s = {"a", "bbbb", "ccc", "dd"};
Arrays.sort(s, (String first, String second) 
                    -> first.length() - second.length());

写法2：

String[] s = {"a", "bbbb", "ccc", "dd"};
Comparator<String> c = (String first, String second) 
                    -> first.length() - second.length());
Arrays.sort(s, c);

写法1等效于写法2。由于Arrays.sort()方法的第二个参数就是为Comparator接口，可以不写，直接定义Lambdab表达式即可。

Lambda表达式的定义等效于匿名内部类的定义：

Comparator<String> c = new Comparator<String>(){
    public int compara(String first, String second){
        return first.length() - second.length();
    }
};

• Lambda表达式自动成为接口方法的实现。
• 自定义函数式接口：

@FunctionalInterface
//系统自带函数式接口，用于编译器检查。若函数式接口中定义多个未实现的方法时，编译器就会检查出错误。
public interface selfFunctionalInterface{
    public boolean tesst(String s);
}

• 系统自带的函数式接口。
  –位于java.util.function包中。

1. Predicate，接收一个参数，返回boolean类型。

public interface Predicate<T>{
    public boolean test(T, t);
}

2. Consumer，接收一个参数，做操作，无返回。

public interface Consumer<T>{
    public void accept(T, t);
}

3. Supplier，无输入参数，返回一个数据，数据工厂。

public interface Supplier<T>{
    public T get();
}

4. Function，接收一个参数，返回一个参数。

public interface Function<T>{
    public R apply(T, t);
}
//实例化：
Function<String, String> upper = s -> s.toUpperCase();
upper.apply("english");

方法引用

• 方法引用：Method Reference。
  – Lambda表达式支持传递现有的类库函数。
  1. 类::静态方法（Class::staticMethod），如：

Math::abs 等价于 x -> Math.abs(x);

2. Class::instanceMethod，如：

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

String[] s = new String[]{"aa", "b", "cccc", "ddd"};
Arrays.sort(s, String::compareToIgnoreCase());
System.out.println(Arrays.toString(s));

3. object::instanceMethod，如：

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

this::instanceMethod，应用本类中定义的其他方法。

super::instanceMethod，使用父类中定义的方法。

4. Class::new，调用某类构造函数，创建一个对象。

public class Person{
    private String name;

    public String getName(){
        return name;
    }
}
//对象的创建。
Supplier<Person> P = Person::new;
Person person = P.get();
System.out.println(person.getName());

5. Class[]::new，调用某类构造函数，创建一个数组对象。

public class Person{
//一些类成员定义。
pri
}
//数组对象的创建
Function<Integer, Person[]> P = Person[]::new;
Person[] person = P.apply(5);//大小为5。