新特性2-lambda表达式

最近几天学习了一下lambda表达式，看了不少博客，感觉有一篇博客总结的一句话总结的很好：lambda表达式是一段可以传递的代码，它的核心思想是将面向对象中的传递数据变成传递行为。其实以前也有传递行为的方式，c++里是函数指针，java中有一种神奇的东西叫做匿名内部类，而现在的lambda表达式，提供了一种取代匿名内部类的途径，并且将其更规范化的变成了一类接口——函数是接口。以下将分为三个大的部分进行介绍，第一部分将对lambda表达式的语法格式进行介绍，第二个部分将继续第一篇对函数式接口的介绍去大体介绍一下java.util.function，第三个部分会举例子

lambda表达式基本语法

lambda表达式的基本格式有两种：

(params)->expression 或者 (params)->{statements;}

对于这两种表达，有以下四条语法约束：

1、参数可选类型声明：可以不写出参数的类型，编译器会进行自动推断

2、可选参数圆括号：当只有一个从参数的时候，可以不加圆括号

3、可选大括号：当整个lambda函数体只有一行语句的时候，可以省略掉大括号

4、可选的返回关键字：当只有一条语句的时候，可以不显示的写出return

为了让大家明白上述规则，我们来看下面代码段（注意，当使用泛型的时候一定要传入类，不要传入基本类型）

 

public class LambdaExpTest {
    
    @FunctionalInterface
    interface LambdaFuncInterface<T> {
        public abstract T function(T x, T y);
    }
    
    @FunctionalInterface
    interface TestInterface<T> {
        public abstract T function(T x);
    }

    public static void main(String[] args) {
        /**
         * 我们可以看下面这个是最完整的lambda表达式，在上面的函数式接口中有一个两个参数的方法，所以这里也是声明了Integer类型的x和y
         * 函数体有两句话，第一句两个数相减，第二句话返回这个值
         */
        LambdaFuncInterface<Integer> helper = (Integer x, Integer y)->{
            int tmp = x - y;
            return tmp;
        };
        System.out.println(helper.function(10, 15));
        
        /**
         * 写成这个样子也是可以的，但是要注意的是一定要两个都不写，或者两个都写，如果写成(Integer x, y)这样子的话就会报错了
         */
        helper = (x, y)->{
            int tmp = x - y;
            return tmp;
        };
        
        /**
         * 写成这样也是可以的，就是只有一行函数体，然后就可以不写return和返回值
         */
        helper = (x, y)-> x - y;
        
        /**
         * 当我们的函数接口只需要一个参数的时候，可以省略掉参数的括号，一下两种写法都对
         */
        TestInterface<Integer> helper2 = (x) -> -x;
        helper2 = x -> -x;
    }
    
}

 

函数式接口java.util.function

java.util.function是jdk1.8新加入的一个函数式接口的包，在jdk1.8之前也有几个函数式接口，在这里给大家罗列一下

java.long.Runnable

java.util.concurrent.Callable

java.util.Comparator

java.io.FileFilter

 

java.security.PrivilegedAction

java.nio.file.PathMatcher

java.lang.reflect.InvocationHandler

java.beans.PropertyChangeListener

java.awt.event.ActionListener

javax.swing.event.ChangeListener

我们可以看一下java.util.function包下大概可以分成4大类接口：消费型接口、供给型接口、函数型接口和断言型接口

 

接口	参数	返回值	类别
Consumer	T	void	消费型接口
Supplier	None	T	供给型接口
Function	T	R	函数型接口
Predicate	T	boolean	断言型接口

 

 

 

 

 

消费型接口源码

/**
 * 这个接口不像其他函数式接口，这个接口期待以副作用的形式参与操作
 * 这里的副作用是指函数内部与外部互动（最典型的情况，就是修改全局变量的值），产生运算以外的其他结果
 */
@FunctionalInterface
public interface Consumer<T> {

    /**
     * 本方法是传入lambda表达式覆盖的方法
     */
    void accept(T t);

    /**
     * 这个方法给出是融合多个Consumer，按顺序组合成一个系列的消费型接口
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

 

供给型接接口源码

    /**
     * 看这个接口的定位，一般作为一个简单的工厂
     */
    @FunctionalInterface
    public interface Supplier<T> {

        /**
         * 这里通过lambda表达式传入行为，注意没有参数
         */
        T get();
    }

 

函数型接口库

    @FunctionalInterface
    public interface Function<T, R> {

        /**
         * 这个是来接收lambda表达式的方法
         */
        R apply(T t);

        /**
         * 这个是在运行apply方法之前可以执行的方法
         */
        default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
            Objects.requireNonNull(before);
            return (V v) -> apply(before.apply(v));
        }

        /**
         * 这个是在运行apply方法之后运行的方法
         */
        default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
            Objects.requireNonNull(after);
            return (T t) -> after.apply(apply(t));
        }

        /**
         * 这个方法将返回输入，在stream里面，生成List或者Map的时候会用到
         */
        static <T> Function<T, T> identity() {
            return t -> t;
        }
    }

 

断言型接口源代码

    @FunctionalInterface
    public interface Predicate<T> {

        /**
         * 通过lambda表达式来实现这个方法，注意lambda表达式要求一个参数，返回值为Boolean类型
         */
        boolean test(T t);

        /**
         * 和上面的test方法进行与操作
         */
        default Predicate<T> and(Predicate<? super T> other) {
            Objects.requireNonNull(other);
            return (t) -> test(t) && other.test(t);
        }

        /**
         * test方法进行非操作
         */
        default Predicate<T> negate() {
            return (t) -> !test(t);
        }

        /**
         * 和test方法进行或操作
         */
        default Predicate<T> or(Predicate<? super T> other) {
            Objects.requireNonNull(other);
            return (t) -> test(t) || other.test(t);
        }

        /**
         * 注意，这里返回的不是Boolean，而是一个Predicate
         */
        static <T> Predicate<T> isEqual(Object targetRef) {
            return (null == targetRef)
                    ? Objects::isNull
                    : object -> targetRef.equals(object);
        }
    }

在这里其实想补充一下断言型接口的那个静态方法的用法，第一次遇到这样的写法不太好理解

    public static void main(String[] args) {
        /**
         * 以下三种写法是等价的，第一种和第二种相比的优势在在于，多了一个isEqual可以传的参数，不会把程序写死，这里可以传递一个上下文的变量
         * 而第三种呢，其实就是isEqual这个静态方法返回了一个已经被lambda表达式赋值的Predicate接口，所以可以直接调用test
         */
        //第一种
        String s = "test";
        Predicate<String> p = Predicate.isEqual(s);
        System.out.println(p.test("test"));
        //第二种
        Predicate<String> p2 = (null == "test") ? Objects::isNull : object -> "test".equals(object);
        System.out.println(p2.test("test"));
        //第三种
        System.out.println(Predicate.isEqual("test").test("test"));
    }

 

手把手的来几发lambda表达式练习（这里借鉴了http://www.importnew.com/16436.html点击传送门过去）

1、用lambda表达式实现Runnable接口

 

    public static void main(String[] args) {
        //before java 8
        new Thread(new Runnable(){

            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println("before java 8");
            }
            
        }).start();
        //after java 8
        new Thread(()->System.out.println("after java 8")).start();
    }

 

2、使用lambda表达式进行事件处理

    public static void main(String[] args) {
        //before java 8
        JButton jb = new JButton();
        jb.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                // TODO Auto-generated method stub
                System.out.println("before java 8");
            }
            
        });
        //after java 8
        jb.addActionListener(e -> System.out.println("after java 8"));
    }

3、使用lambda表达式进行迭代

    public static void main(String[] args) {
        //before java 8
        List<String> abc = Arrays.asList("abc", "def", "jhi");
        for(String s : abc) {
            System.out.println(s);
        }
        //after java 8
        abc.forEach(System.out::println);
    }

这里我们来看一下List::forEach源码

    /**
     * forEach的参数是一个消费者接口，需要传入一个lambda表达式
     */
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

我们来继续做一些复杂的操作（注意：这里其实还是用java7以前的东西，否则这里应该用流）

    public static void main(String[] args) {
        List<String> abc = Arrays.asList("abc", "def", "jhi");
        List<String> t = new ArrayList<String>();
        abc.forEach(e -> {
            if(e.contains("a")) {
                t.add(e);
            }
        });
        System.out.println(t);
    }

4、使用lambda表达式和断言式接口

    public static void main(String[] args) {
        List<String> languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp", "JS");
        System.out.println("start with J");
        filter(languages, s -> s.startsWith("J"));
        System.out.println("start with J and contains a");
        andFilter(languages, s -> s.startsWith("J"), s -> s.contains("a"));
        System.out.println("start with J or contains a");
        orFilter(languages, s -> s.startsWith("J"), s -> s.contains("a"));
        
    }
    
    public static void filter(List<String> name, java.util.function.Predicate<? super String> condition) {
        name.stream().filter(condition).forEach(System.out::println);;
    }
    
    public static void andFilter(List<String> name, Predicate<String> condition1, Predicate<String> condition2) {
        name.stream().filter(condition1.and(condition2)).forEach(System.out::println);
    }
    
    public static void orFilter(List<String> name, Predicate<String> condition1, Predicate<String> condition2) {
        name.stream().filter(condition1.or(condition2)).forEach(System.out::println);
    }

5、lambda表达式与map和reduce

    public static void main(String[] args) {
        List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
        costBeforeTax.stream().map((cost) -> cost + .12*cost).forEach(System.out::println);
        //注意到这里的reduce中的sum等于map后的第一个值，cost等于map后的第二个值，但是之后的行为是 ，将返回值赋给sum
        //而map中继续传进来的值赋给cont
        double d = costBeforeTax.stream().map((cost) -> cost + .12*cost).reduce((sum, cost) -> {
            System.out.println("sum=" + sum);
            System.out.println("cost2=" + cost);
            return sum + cost;
        }).get();
        System.out.println(d);        
    }

6、用lambda表达式写一个简单的 AOP

    public static void main(String[] args) {
        AOP(x -> {
            System.out.println("deal x"); 
            return x;
            }, 
            x -> {
            System.out.println("before deal x"); 
            return x;
            }, 
            x -> {
            System.out.println("after deal x");
            return x;
            });        
    }
    
    public static void AOP(Function<Object, Object> aim, Function<Object, Object> before, Function<Object, Object> after) {
        aim.compose(before).andThen(after).apply(1);
    }

 

总结

本文重要描述了lambda表达式的用法，但是并没有对其原理进行探究，不过还是继续说一些我的感受吧，lambda表达式看起来确实比从前的代码更简练，可读性更高一些，但是这都是建立在行为比较短暂的基础上，基本上三五行就描述清楚了，如果一个行为需要大量的语句去描述，我还是建议大家写成匿名内部类的形式，或者写一个类去实现接口，让自己的代码看起来更干净一些。第二部分介绍的几个函数式接口只是java.util.function中最基础的四个接口，其他接口基本上都是从这四个接口衍生出来的，大家可以自行阅读Bi开头的接口，就是变成了两个参数。第三部分举例子的时候不可比免的使用了stream，我们第三篇新特性的讲解，就会介绍stream