java8新特性之lambda

Java 8 Tutorial
1.先来一段lambda的常规应用

public class LambdaMain {

    /**
     * lambda典型应用
     */
    private static void print() {
        //1.8之前
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        }).start();

       //1.8
        new Thread(() -> System.out.println("hello world")).start();
    }

    /**
     * 主函数
     *
     * @param args
     */
    public static void main(String[] args) {
        print();
    }
}

我查看Runnable的源码发现，之所以可以使用lambda表达式，是因为Runnable的接口上有一个@FunctionalInterface的注解。所以，我们也可以自定义自己的lambda接口。

2.简单实践

public class LambdaMain {

    /**
     *   自定义接口
     */
    @FunctionalInterface
    private interface MathOperation {
        /**
         * 对a和b两数字的相关操作，并返回操作后的结果
         *
         * @param a
         * @param b
         * @return
         */
        int operate(int a, int b);
    }

    /**
     * 对a和b两数字按照operation进行操作
     *
     * @param a
     * @param b
     * @param operation
     * @return
     */
    private static int operate(int a, int b, MathOperation operation) {
        return operation.operate(a, b);
    }

    /**
     * lambda测试
     */
    private static void lambda() {

        //自定义一个add动作
        MathOperation add = (int a, int b) -> a + b;

        //对1，2两数字进行add操作
        int result1 = operate(1, 2, add);
        System.out.println(result1);

        //对2，3两数字进行乘法操作
        int result2 = operate(2, 3, (a, b) -> a * b);
        System.out.println(result2);
    }


    /**
     * 主函数
     *
     * @param args
     */
    public static void main(String[] args) {
        lambda();
    }
}

类似上面的lambda使用方法，免去了创建大量实现类和匿名类的麻烦，并且带给java函数式编程的能力。

3.方法引用

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

public class LambdaMain {

    /**
     *  实体类Car
     */
    private static class Car {
        /**
         * 将创建实例的具体实现下放给CarFactory，CarFactory可以有不同的实现
         *
         * @param supplier
         * @return
         */
        private static Car createInstance(Supplier<Car> supplier) {
            return supplier.get();
        }

        /**
         * 通过反射创建对象(静态函数)
         *
         * @return
         */
        public static Car newInstance() {
            try {
                return Car.class.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return null;
        }

        /**
         * 车启动
         */
        public void start() {
            System.out.println("车辆启动");
        }
    }

    /**
     * Car工厂类
     */
    private static class CarFactory {

        /**
         * 通过构造函数创建Car实例
         *
         * @return
         */
        public static Car createInstance1() {
            //Car.createInstance(()->new Car())的变形
            return Car.createInstance(Car::new);
        }

        /**
         * 通过调用newInstance静态方法创建对象
         *
         * @return
         */
        public static Car createInstance2() {
            //Car.createInstance(()->Car.newInstance())的变形
            return Car.createInstance(Car::newInstance);
        }

        /**
         * 修理车
         *
         * @param car
         */
        public static void repair(Car car) {
            System.out.println("repair a car");
        }
    }

    /**
     * 主函数
     *
     * @param args
     */
    public static void main(String[] args) {
        //用来装car
        List<Car> list = new ArrayList<>();
        //car1
        Car car1 = CarFactory.createInstance1();
        list.add(car1);
        //car2
        Car car2 = CarFactory.createInstance2();
        list.add(car2);
        //循环调用car实例方法
        list.forEach(Car::start);
        //循环调用CarFactory的静态方法
        list.forEach(CarFactory::repair);
        //循环调用println函数
        list.forEach(System.out::println);
    }
}

4.jdk8自带的函数接口
函数式接口(@FunctionalInterface注解)有且只有一个抽象方法，但是可以有多个默认实现方法。
jdk8之前已有的函数式接口：

java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler
java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListener

jdk8新增的函数式接口
整个java.util.function包下面的接口

结束语：上述的一些例子只是简单地对lambda表达式做了示范，更多的使用方法可以在Java 8 Tutorial中查看，里面有更多更详细的例子供大家参考和学习。