Java Lambda表达式(Java Lambda Expression)

从匿名内部类说起

在Java中，存在这么一个问题，就是当一个 匿名内部类 的实现非常简单，就像一个 Interface 只包含一个方法，此时该 内部类 的语法看起来就相当的笨拙且极不简洁，此时我们可能更希望能通过一个函数式的方法来解决这样的问题，传递给他一个参数，然后完成某个动作，在 Java8 中Lambda表达式可以帮我们完成这样的工作。

1. 我们先看一个匿名内部类的例子

public class AnonymouseDemo {

    //内部接口
    interface InnerInterface{
        //定义一个say()方法,没有参数
        public abstract void say();
    }

    public static void main(String[] args) {
        /**
         * 实现匿名内部类  --  new InnerInterface{  }
         */
        InnerInterface inter=new InnerInterface() {

            @Override
            public void say() {
                System.out.println("Hello Inner Interface!");
            }
        };

        inter.say();
    }
}

• 运行结果 : Hello Inner Interface!

---

从结果来看，实现一个输出Hello Inner Interface并不是那么简洁，现在，很多语言都支持Lambda表达式Java8的新特性里面就包含了Lambda表达式。

---

• Java 中 Lambda表达式的语法为：( argument )->(body)即( 参数 )->(body)

 (int a,int b)->{return a-b}

 //表示输出一句话 
 (String demo) -> { System.out.println(demo); }

 //表示返回666   return 666
 () -> 666

 () ->{ return 0.618 };

• 有了Lambda表达式上面的匿名内部类可以可以可以这样

public class LambdaDemo {

    //内部接口
        interface InnerInterface{
            //定义一个say()方法，没有参数
            public abstract void say();
        }

        public static void main(String[] args) {

            //使用Lambda表达式，没有参数
            InnerInterface inner=()->System.out.println("Lambda Expression!");
            inner.say();
        }
}

• 运行结果 : Lambda Expression!

相比而言Lambda Expression是不是更简单呢？ 那么问题来了！？什么样的情况下我们能使用Lambda Expression表达式呢？，还记得前面提到的函数式的方法吗？

---

Functional Interfaces函数式接口.

A functional interface is any interface that contains only one abstract method. (A functional interface may contain one or more default methods or static methods.)

1. 函数式接口是一个仅包含一个抽象方法的接口
2. 一个函数式接口可能包含一或者多个Default或Static方法(接口扩展类方法)
3. 函数式接口可以用@FunctionalInterface注解进行标记，当被标记的接口不是一个正确的函数式接口的话，将会产生编译级别的Error

• Java中函数式接口有很多，例如Runable，Thread，Consumer，Predicate等 ，可以这样使用Lambda Expression。

//JDK中Runnable 接口的定义，便是一个函数式接口，用@FunctionalInterface进行标记
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

//Anonymouse Class
Runnable run=new Runnable() {

    @Override
    public void run() {
        System.out.println("Old Way");
    }
};
//Lambda Expression
Runnable r = () -> System.out.println("Ha Ha ..Lambda Expression!");

//Anonymouse Class
new Thread(new Runnable() {

                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    System.out.println("Old Way");
                }
            }).start();
//Lambda Expression ...
new Thread(
    () -> System.out.println("Ha Ha ..Lambda Expression!")
).start();

*以上都是不带参数的Lambda Expression示例，以下讲解带参数的Lambda Expression以及泛型函数式接口示例

/**
 * @author junit
 * 带参数的 泛形函数式接口
 */
@FunctionalInterface
public interface FunctionalClassParamters<T> {
    /**
     * @param n
     * @return
     */
    public abstract T getResults(T n);
}


/**
 * @param args
 *  Lambda Expression Test
 *  带参数的Lambda 表达式
 */
public static void main(String[] args){

    System.out.println("With Parameters..");
    /*
    * 指定参数类型为String
    */
    FunctionalClassParamters<String> parameters;
    /*
    *
    * 可以指定参数类型，也可以不指定参数类型。
    * parameters=(String n)->n;也是合法的。
    * 当只有一个参数时，可以不用括号如：
    * parameters=n->n 也是合法的。
    * 
    */
    parameters=(n)-> n;
    System.out.println(paramters.getResults("String Type"));
    /*
    * 指定参数类型为Integer
    */
    FunctionalClassParamters<Integer> integer_parameters;
    integer_parameters=(p)->{
        p++;
        p*=100;
        return p;
    };
    System.out.println(integer_parameters.getResults(50));
}

• 
  
• 运行结果：
  

With Parameters..
String Type
5100