java lambda表达式以及Predicate接口

了解lambda之前先了解下什么是函数式接口,函数式接口即接口里必须有一个抽象方法(抽象的方法只能有一个,可以有其他的用default修饰的方法以及从Object继承的方法)

jdk8里新增了一个@FunctionalInterface注解,这个注解标注此接口为函数式接口,但是并不是必须的,任何满足我上面所说的只有一个抽象方法的接口都可以称之为函数式接口,但是如果一个接口上标注了此注解,就必须满足上述条件

lambda表达式用来重写函数式接口中的那个抽象方法,lambda直接看做匿名抽象类,因为lambda可以对接口赋值

lambda表达式的语法包括3个部分:

1.参数列表(...) 如(String s,Integer i)  ()  (s) 等,没有参数时就是(),只有一个参数时可以写成str,省略掉参数的小括号

2.箭头  ->

3.执行的代码 { },执行的代码只有一行时,可以省略大括号

4.需要注意的是lambda无法在其方法体中修改局部变量的值

lambda表达式整体看作一个某个接口的匿名类，lambda的参数，方法体是该匿名类的下唯一重写抽象方法的参数，方法体，lambda是对匿名类的简化

下面以创建线程为例

　　　　//匿名内部类创建线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类启动线程");
            }
        }).start();
        
        //使用lambda表达式启动一个新的线程
        //()对应run方法的参数
        //->后面表示run的方法体
        new Thread(()->System.out.println("使用lambda启动线程")).start();

来看下jedis中execute方法关于lambda的例子

 从上图可以看到execute方法需要一个RedisCallBack，这是一个接口，内部只有一个抽象方法，虽然没有@FunctionalInterface注解，但这是一个抽象接口

唯一的抽象方法doInRedis需要一个RedisConnection参数，返回一个泛型参数，我们抽取下excute需要的关于语法的关键代码

 execute((RedisCallback<List<Object>>) connection -> {
                connection.openPipeline();
                return xx;
 });

connection -> {connection.openPipeline();return xx;}); connection是doInRedis的形参，{}中doInRedis的方法体，而connection前面的(RedisCallback<List<Object>>)是对lambda的类型说明（RedisCallback<T>）

下面再举一个Runnable接口的例子

/**
 * lambda语法包括3个部分:
 * (参数列表)->{方法体;}
 * 只有一个参数时,()可以省略
 * 方法体只有一行时可以省略{;}
 * @author tele
 *
 */
public class Demo1 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        //遍历list
        list.forEach(i->System.out.println(i));
        
        
        //>=可以直接判断符号
    /*    int  a = 1;
        int  b = 2;
        System.out.println(b>=a?"b>a":"b<a");*/
        
        //匿名内部类创建线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类启动线程");
            }
        }).start();
        
        //使用lambda表达式启动一个新的线程
        //()对应run方法的参数
        //->后面表示run的方法体
        new Thread(()->System.out.println("使用lambda启动线程")).start();
        
        
        //如果要使用lambda来声明接口那么接口中只能有一个抽象方法
        //因为函数接口是只有一个抽象方法的接口(抽象的方法只能有一个,可以有其他的用default修饰的方法)
        
        String s = "lambda test";
        int i= 100;
        MyInterface myInterface = (str,m)->{
            //i++; 错误,无法对i的值进行修改
            System.out.println(i);
            System.out.println(str + "  " + m);
            return str+"----"+str;
        };
        String result = myInterface.test(s,0);
        System.out.println(result);
        
        
    }

    //定义一个内部的函数式接口
    static interface MyInterface {
        //void test(String s,int i);
        String test(String s,int i);
    }
}

到这再次说明,lambda表达式是重写了接口中的抽象方法,包括第16行的代码把lambda表达式传入到foreach中,传入的lambda表达式实质是对Consumer接口的accept方法的重写

参数类型的省略是因为java的类型推断,编译器知道函数式接口中的那个抽象方法需要什么类型

下面结合Predicate接口再来深入了解下lambda表达式,这个接口主要用于断言,当然他是一个函数式接口,可以看到他的抽象方法是test(),所以我们写的lambda表达式就是重写test方法

注意这里用了泛型

先看filter方法,filter方法对list进行遍历,满足test()后进行输出,而test的方法体就是我们传入的lambda表达式,从这一点上看,使用lambda有点绕的地方就是按照以往的做法我们调用filter时出了传入list,另一个参数应该为Precidate类型,然而使用了lambda后,我们直接传入Predicate接口中的抽象方法的参数与方法体即可,即使我们传入一个Predicate类型的参数,接下来仍然是去调用test(),从这点看lambda可以说是一步到位了

完整代码,and对应&& or对应|| negate对应!

/**
 * Predicate接口的使用
 * @author tele
 *
 */
public class Demo2 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("java","hadoop","python","php","lucene");
        filter(list,s->s.startsWith("j"));//java
//        filter(list, s->true);//全部输出
        
        
        Predicate<String> condition1 = str->str.startsWith("j");
        Predicate<String> condition2 = str->str.endsWith("h");
        
        //and
        Predicate<String> andCondition = condition1.and(condition2);        
        boolean result = andCondition.test("jsadh");
        System.out.println(result);//true
        
        //or
        Predicate<String> orCondition = condition1.or(condition2);
        result = orCondition.test("jasd");
        System.out.println(result);//true
        
        //negate,对判断条件取反
        Predicate<String> negate = condition1.negate();
        System.out.println(negate.test("aj"));//true
        
        //isEqual(了解,比较两个对象是否相等)
        result = Predicate.isEqual("as").test("aaa");
        System.out.println(result);
        
    }
    
    //test方法是predicate中的唯一一个抽象方法
    public static void filter(List<String> list,Predicate<String> predicate) {
            list.forEach(t->{
                if(predicate.test(t)){
                    System.out.println(t);
                }
            });
    }
}