java8之lambda表达式

lambda表达式是java8提供了一个比较重要的新特性之一，简化了很多代码的编写。

1、先看一个简单的例子，不是用lambda表达式创建一个线程：

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        });

在Thread构造函数内传入一个Runnable接口的实现类。

2、再看一下使用lambda表达式创建线程的例子：

        Thread thread1 = new Thread(()->{
            System.out.println("hello world");
        });

使用lambda表达式以后回省略很多代码，不用再去重复的写要实现的方法名称，当然并不是所有的接口都能使用lambda表达式，必须要是函数式接口才能使用lambda。

函数式接口

有且只有一个抽象方法的接口被称为函数式接口。

函数式接口可以显示的被@FunctionalInterface所修饰，当被标识的接口不满足规定时，编译器会报错。

例：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

lambda表达式的转换方式

//下面是三个自定义的函数式接口
interface T1{
    void say(int a);
}
interface T2{
    String say(int a);
}
interface T3{
    int say(int a,int b,int c);
}

    //()里面的数据表示参数，后面跟一个箭头->,最后面是大括号{}
    Runnable runnable = ()->{
        System.out.println("hello world");
    };
    //当参数只有一个时，可以省去()
    T1 t1 = a->{
        System.out.println("hi");
    };
    //当方法体只有一行时，可以省去{}
    T1 t2 = a-> System.out.println("hi");
    //有返回值的方法
    T2 t21 = (a)->{
        return a+"hi";
    };
    //同样的，方法体只有一行时，可以省略{},并且省略return
    T2 t22 = a -> a+ "hi";
    //有多个参数的方法,只需要在()内写上参数就行，并不需要写参数类型,因为lambda会自己推断参数类型，
    T3 t3 = (a,b,c)-> a + b + c;

使用lambda在实际项目开发者确实能省略很多的代码，比如在使用线程池处理线程，使用Comparable进行比较等等。

Java8内置的函数式接口

Java8提供了一个java.util.function包，包含了很多函数式接口，下面是最为基本也是最常用的4个，这四个函数式接口在我上一篇说stream的时候基本上都提到过，所以下面只是列出以下代码并做一个简单的说明，就不再去写例子了，有兴趣的可以自己去写一些实现类去了解一下，都是非常简单的接口，这些接口在stream里面用到的非常多。

Function接口：

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

Function接口的唯一抽象方法是apply，作用是接收一个指定类型的参数，返回一个指定类型的结果

Consumer接口

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Consumer接口中accept方法的作用是接收指定参数类型，无返回值，重点在于内部消费

Predicate接口

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

Predicate中的test方法，传入指定类型参数，返回布尔类型的结果，用于判断，断言

Supplier接口：

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

Supplier意为供应，只有一个方法get，不接收任何参数，只返回指定类型结果。