java8 Lambda表达式 详解

1、Lambda表达式

Lambda表达式（也称为闭包），Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中），或者把代码看成数据。一个lambda可以由用逗号分隔的参数列表、–>符号与函数体三部分表示
*A、一般语法*

    (Type1 param1, Type2 param2, ..., TypeN paramN) -> {
          statment1;
          statment2;
          //.............
          return statmentM;
    }

B、简略语法
1、 参数类型省略–绝大多数情况，编译器都可以从上下文环境中推断出lambda表达式的参数类型。这样lambda表达式就变成了：

(param1,param2, ..., paramN) -> {
  statment1;
  statment2;
  //.............
  return statmentM;
}

2、当lambda表达式的参数个数只有一个，可以省略小括号。lambda表达式简写为：

param1 -> {
  statment1;
  statment2;
  //.............
  return statmentM;
}

3、当lambda表达式只包含一条语句时，可以省略大括号、return和语句结尾的分号。lambda表达式简化为：

param1 -> statment

例子
a、java8之前写法：

List<String> names = new ArrayList<>();
        names.add("苹果");
        names.add("香蕉");
        //普通用户
        List<String> lowercaseNames = new ArrayList<>();
        for (String name : names) {
          lowercaseNames.add(name.toLowerCase());
        }

b、简略写法

List<String> names = new ArrayList<>();
        names.add("苹果");
        names.add("香蕉");
List<String> lowercaseNamesLambda1 = names.stream().map(
                (name) -> {return name.toLowerCase();}
                ).collect(Collectors.toList());

c、一个参数省略小括号写法

List<String> names = new ArrayList<>();
        names.add("苹果");
        names.add("香蕉");
//一个参数时可以省略小括号
        List<String> Lambda1 = names.stream().map(name -> {
            return name.toLowerCase();
        }).collect(Collectors.toList());

d、省略大括号、return和语句结尾的分号

List<String> names = new ArrayList<>();
        names.add("苹果");
        names.add("香蕉");
//省略大括号、return和语句结尾的分号
        List<String> Lambda2 = names.stream().map(
                name -> name.toLowerCase()
                ).collect(Collectors.toList());

通过若干例子学习

创建Command接口：

public interface Command {

    /** 未知的接口行为需要实现
     */
      void  process ( int [] tagrs);
}

数组求和接口实现
public class AddCommand implements Command{

@Override
public void process(int[] tagrs) {
    int sum=0;
    for (int i : tagrs) {
        sum+=i;
    }
    System.out.println("数组求和输出"+sum);
}

}

数组输出接口实现

public class PrintComment implements Command{
    @Override
    public void process(int[] tagrs) {
         for (int i : tagrs) {
                System.out.print("数组迭代输出="+i);
            }
         System.out.println();
    }
}

通过ProcessArray 类确定 行为处理

public class ProcessArray {
    //通过ProcessArray 类确定 行为处理
    public void process(int[] tagrs, Command com) {
        com.process(tagrs);
    }
}

CommonTest测试类

public class CommonTest {
    public static void main(String[] args) {
        ProcessArray processArray=new ProcessArray();
        int tagrs[] ={0,6,2,4,5};
        /**
         * 数组输出行为
         */
        processArray.process(tagrs, new PrintComment());

        /**
         * 数组求和行为
         */
        processArray.process(tagrs, new AddCommand());
        /**
         * 数组排序行为 内部类实现
         */
        processArray.process(tagrs, new Command() {

            @Override
            public void process(int[] tagrs) {
                Arrays.sort(tagrs);
                processArray.process(tagrs, new PrintComment());
            }
        });
        /**
         * 数组求和行为 Lambda 实现
         */
        processArray.process(tagrs,tagr->{
            int sum=0;
            for (int i : tagrs) {
                sum+=i;
            }
            System.out.println("数组求和输出"+sum);
        });
        /**
         * 创建线程 --java8 之前写法
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
            System.out.println("java8 之前写法");
            }
        }).start();

        //创建线程  ---Java 8方式：
        new Thread( () -> System.out.println("java8 写法 ") ).start();
    }
}

参数从 无到 有的写法

public class lamTest {
    // 吃饭接口
    interface Eatable {
            void taste();
    }
        // 飞行接口
    interface Flyable {
        void fly(String weather);
    }
    // 相加接口
    interface Addable {
        void add(int a, int b);
    }

    public void eat(Eatable e) {
        e.taste();
    }
    public void drive(Flyable e) {
        e.fly("天气明媚");
    }
    public void sum(Addable e){
        e.add(2, 8);
    }

    public static void main(String[] args) {
        lamTest test = new lamTest();
        /**
         *  参数为空  用（）    ，->后面为 接口中需要输出的内容 
         */
        test.eat(()->System.out.println("正在吃！。。。"));

        /**
         * 参数为接口中的 weather
         */
        test.drive( weather-> {
            System.out.println("今天天气"+weather);
        });
        //不同的写法  
        test.drive((String weather)-> 
            System.out.println("今天天气"+weather)
        );

        /**
         * 求和
         */
        test.sum((int a,int b)->{
            int c =a+b;
            System.out.println("和为="+c);
        });

    }
}

由上述写法发现Lambda表达式的作用就是代替匿名内部类的繁琐写法，Lambda代替匿名内部类创建对象时，表达式的代码将会代替实现抽象方法的方法体.

总结：Lambda表达式的学习在于 ，在实践中学习，在实践中理解。建议大家还是多写代码，多使用

源码见地址：
http://download.csdn.net/download/u011105400/10176475

2、函数式接口 - Functional Interface

1.函数式接口（Functional Interface）:
函数式接口， 首先是一个接口，在这个接口里面只能有一个抽象方法。也称为SAM接口
1.1函数式接口里允许定义默认
1.2 函数式接口里允许定义静态
1.3 函数式接口里允许定义java.lang.Object里的public
1.4 函数式接口里允许子接口继承多个父接口，但每个父接口中都只能存在一个抽象方法，且必须的相同的抽象方法