Java Lambda

java lambda表达式

基本语法

(VarList)->{Statement}
例如:
(int a, int b) -> {return a+b;};

应用场景

例如：对某对象执行某操作，但是这个操作经常被用户修改
比如：需要选出字符串串长小于100的，但是用户可能要求突然又变成字符串的首字母为a
怎么办？
前面写死的代码不宜更改

方法：实现一个interface, 在interface中写方法 boolean chooser(T elem)
接下来，可以具体实现这个方法，之后传入到相关操作中。

但是，还有更加直接的办法，这个时候Java Lambda就出场了

public class Main {
    public static <T> List<T> filter(List<T> list, Predicate<T> p) {
    //调用Predicate接口的test方法
        List<T> results = new ArrayList<>();
        for(T t: list) {
            if(p.test(t)) {
                results.add(t);
            }
        }
        return results;
    }

    public static void main(String[] args) {
        Predicate<String> chooser = (String a)->{return a.length() > 4;};
        //这一步实际上是把Predicate接口中的方法进行实例化
        ArrayList<String> a = new ArrayList<>();
        a.add("1232");
        a.add("23114");
        a.add("2314");
        a.add("214");
        // 把实例化完成后的Interface传入到filter方法中，就可以实现filter了
        System.out.println(filter(a, chooser).toString());
        System.out.println();
    }
}

再比如下面例子

interface BINARYOP {
    int op(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        BINARYOP add = (int a, int b) -> a+b ;
        BINARYOP sub = (int a, int b) -> a-b ;
        BINARYOP mul = (int a, int b) -> a*b ;
        BINARYOP div = (int a, int b) -> a/b ;
        System.out.println(div.op(1, 2));
    }
}

再比如下面例子

interface CMP<T> {
    boolean compare(T a, T b);
}

class Sort<T> {
      void sort(T []elem, CMP<T> compare) {
        for(int i = 0; i < elem.length; i++) {
            for (int j = 0; j < elem.length - 1; j++) {
                if(compare.compare(elem[j], elem[j+1])) {
                    T a = elem[j];
                    elem[j] = elem[j+1];
                    elem[j+1] = a;
                }
            }
        }
    }

}
+
class intpair{
    int a,b;
    intpair() {a=0;b=0;};
    intpair(int a,int b) {this.a = a; this.b = b;};
    void set(int a,int b) {this.a = a; this.b = b;};
    public String toString() {
        return "a:"+a+" b:"+b;
    }
}

public class Main {
    public static void main(String[] args) {
        intpair [] elem = new intpair[30];
        Random random = new Random(-1);
        for (int i = 0; i < elem.length; i++) {
            elem[i] = new intpair(random.nextInt()%10, random.nextInt()%10);
        }

        CMP<intpair> cmp = (intpair a, intpair b)->{return a.a>b.a? true : (a.a<b.a ? false : a.b > b.b);};
        new Sort().sort(elem, cmp);
        for (intpair e : elem)
            System.out.println(e.toString());
    }
}

总而言之，一般的语法范式是：
对某对象(A)做某类事情(B)，
声明接口B,
这类事情中的一件B1, B B1= ()->{} // lambda表达式就是表示B1
那么把B1传入，在其中调用B中被实例化的方法即可

值得注意的问题

接口中只可以有一个抽象方法，不可以有多个！