Lambda 详解

Lambda表达式详解

lambda简介

    lambda运算符：所有的lambda表达式都是用新的lambda运算符 " => ",可以叫他，“转到”或者 “成为”。运算符将表达式分为两部分，左边指定输入参数，右边是lambda的主体。

        lambda表达式：

               1.一个参数：param=>expr

               2.多个参数：（param-list）=>expr

        上面这些东西，记着，下面我们开始应用并阐述lambda，让你乐在其中。

lambda应用阐述    

         阐述这技术，我先上一个例子，然后再慢慢深入分析。例子如下：         

namespace 阐述lambda{    public class Person    {        public string Name { get; set; }        public int Age  {  get;set; }        }    class Program    {        public static List<Person> PersonsList()        {            List<Person> persons = new List<Person>();            for (int i = 0; i < 7; i++)            {                Person p = new Person() { Name = i + "儿子", Age = 8 - i, };                persons.Add(p);                            }            return persons;        }        static void Main(string[] args)        {            List<Person> persons = PersonsList();            persons = persons.Where(p => p.Age > 6).ToList();       //所有Age>6的Person的集合            Person per = persons.SingleOrDefault(p => p.Age == 1);  //Age=1的单个people类            persons = persons.Where(p => p.Name.Contains("儿子")).ToList();   //所有Name包含儿子的Person的集合        }    }}

     看啦上面的例子，相信你能看出它确实是个甜枣，呵呵，下面我们来看下（p=>p.Age>6）这样的表达式，到底是怎么回事。。

     首先我们看下委托  

        //委托  逛超市        delegate int GuangChaoshi(int a);        static void Main(string[] args)        {            GuangChaoshi gwl = JieZhang;            Console.WriteLine(gwl(10) + "");   //打印20，委托的应用            Console.ReadKey();        }                //结账        public static int JieZhang(int a)        {            return a + 10;        }

    再看表达式

        //委托  逛超市        delegate int GuangChaoshi(int a);        static void Main(string[] args)        {                     // GuangChaoshi gwl = JieZhang;            GuangChaoshi gwl = p => p + 10;            Console.WriteLine(gwl(10) + "");   //打印20，表达式的应用            Console.ReadKey();        }               

     委托跟表达式的两段代码，我们可以看出一些东东吧：其实表达式（p => p + 10;）中的 p 就代表委托方法中的参数，而表达式符号右边的 p+10，就是委托方法中的返回结果。 大侠绕道，小虾理解下。

    下面再上两个稍微复杂点的理解理解。

    1.多参数的 

        //委托  逛超市        delegate int GuangChaoshi(int a,int b);        static void Main(string[] args)        {                        GuangChaoshi gwl = (p,z) => z-(p + 10);            Console.WriteLine(gwl(10,100) + "");   //打印80，z对应参数b，p对应参数a            Console.ReadKey();        }

        2. lambda主体运算复杂  

        /// <summary>        /// 委托  逛超市        /// </summary>        /// <param name="a">花费</param>        /// <param name="b">付钱</param>        /// <returns>找零</returns>        delegate int GuangChaoshi(int a,int b);        static void Main(string[] args)        {            GuangChaoshi gwl = (p, z) =>            {                int zuidixiaofei = 10;                if (p < zuidixiaofei)                {                    return 100;                }                else                {                    return z - p - 10;                }                       };            Console.WriteLine(gwl(10,100) + "");   //打印80，z对应参数b，p对应参数a            Console.ReadKey();        }

上面这些例子，好好理解下，下面我要介绍一个系统指定的 Fun<T>委托。

Func<T>委托

 T 是参数类型，这是一个泛型类型的委托，用起来很方便的。

 先上例子

  static void Main(string[] args)        {            Func<int, string> gwl = p => p + 10 + "--返回类型为string";                        Console.WriteLine(gwl(10) + "");   //打印‘20--返回类型为string’，z对应参数b，p对应参数a            Console.ReadKey();        }

说明：我们可以看到，这里的p为int 类型参数， 然而lambda主体返回的是string类型的。

再上一个例子

        static void Main(string[] args)        {            Func<int, int, bool> gwl = (p, j) =>                {                    if (p + j == 10)                    {                        return true;                    }                    return false;                };            Console.WriteLine(gwl(5,5) + "");   //打印‘True’，z对应参数b，p对应参数a            Console.ReadKey();        }

说明：从这个例子，我们能看到，p为int类型，j为int类型，返回值为bool类型。

看完上面两个例子，相信大家应该明白啦Func<T>的用法：多个参数，前面的为委托方法的参数，最后一个参数，为委托方法的返回类型。

 lambda表达式树动态创建方法  

   static void Main(string[] args)        {            //i*j+w*x            ParameterExpression a = Expression.Parameter(typeof(int),"i");   //创建一个表达式树中的参数，作为一个节点，这里是最下层的节点            ParameterExpression b = Expression.Parameter(typeof(int),"j");            BinaryExpression be = Expression.Multiply(a,b);    //这里i*j,生成表达式树中的一个节点，比上面节点高一级            ParameterExpression c = Expression.Parameter(typeof(int), "w");            ParameterExpression d = Expression.Parameter(typeof(int), "x");            BinaryExpression be1 = Expression.Multiply(c, d);            BinaryExpression su = Expression.Add(be,be1);   //运算两个中级节点，产生终结点            Expression<Func<int, int, int, int, int>> lambda = Expression.Lambda<Func<int, int, int, int, int>>(su,a,b,c,d);            Console.WriteLine(lambda + "");   //打印‘(i,j,w,x)=>((i*j)+(w*x))’，z对应参数b，p对应参数a            Func<int, int, int, int, int> f= lambda.Compile();  //将表达式树描述的lambda表达式，编译为可执行代码，并生成该lambda表达式的委托；            Console.WriteLine(f(1, 1, 1, 1) + "");  //打印2            Console.ReadKey();        }

 

这段代码，放上来，仔细理解下，理解透彻啦，lambda表达式基本上也没什么啦。呵呵。。

算啦，我还是画个图算是结尾吧，以便于理解。

上段代码的lambda表达式树，图。

 

文章来自：http://www.cnblogs.com/knowledgesea/p/3163725.html

================================================分割线=============================================================

深入浅出 Java 8 Lambda 表达式

摘要：此篇文章主要介绍 Java8 Lambda 表达式产生的背景和用法，以及 Lambda 表达式与匿名类的不同等。本文系 OneAPM 工程师编译整理。

Java 是一流的面向对象语言，除了部分简单数据类型，Java 中的一切都是对象，即使数组也是一种对象，每个类创建的实例也是对象。在 Java 中定义的函数或方法不可能完全独立，也不能将方法作为参数或返回一个方法给实例。

从 Swing 开始，我们总是通过匿名类给方法传递函数功能，以下是旧版的事件监听代码：

someObject.addMouseListener(new MouseAdapter() {        public void mouseClicked(MouseEvent e) {                         //Event listener implementation goes here...               }    });

在上面的例子里，为了给 Mouse 监听器添加自定义代码，我们定义了一个匿名内部类 MouseAdapter 并创建了它的对象，通过这种方式，我们将一些函数功能传给 addMouseListener 方法。

简而言之，在 Java 里将普通的方法或函数像参数一样传值并不简单，为此，Java 8 增加了一个语言级的新特性，名为 Lambda 表达式。

为什么 Java 需要 Lambda 表达式？

如果忽视注解(Annotations)、泛型(Generics)等特性，自 Java 语言诞生时起，它的变化并不大。Java 一直都致力维护其对象至上的特征，在使用过 JavaScript 之类的函数式语言之后，Java 如何强调其面向对象的本质，以及源码层的数据类型如何严格变得更加清晰可感。其实，函数对 Java 而言并不重要，在 Java 的世界里，函数无法独立存在。

在函数式编程语言中，函数是一等公民，它们可以独立存在，你可以将其赋值给一个变量，或将他们当做参数传给其他函数。JavaScript 是最典型的函数式编程语言。点击此处以及此处可以清楚了解 JavaScript 这种函数式语言的好处。函数式语言提供了一种强大的功能——闭包，相比于传统的编程方法有很多优势，闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。Java 现在提供的最接近闭包的概念便是 Lambda 表达式，虽然闭包与 Lambda 表达式之间存在显著差别，但至少 Lambda 表达式是闭包很好的替代者。

在 Steve Yegge 辛辣又幽默的博客文章里，描绘了 Java 世界是如何严格地以名词为中心的，如果你还没看过，赶紧去读吧，写得非常风趣幽默，而且恰如其分地解释了为什么 Java 要引进 Lambda 表达式。

Lambda 表达式为 Java 添加了缺失的函数式编程特点，使我们能将函数当做一等公民看待。尽管不完全正确，我们很快就会见识到 Lambda 与闭包的不同之处，但是又无限地接近闭包。在支持一类函数的语言中，Lambda 表达式的类型将是函数。但是，在 Java 中，Lambda 表达式是对象，他们必须依附于一类特别的对象类型——函数式接口(functional interface)。我们会在后文详细介绍函数式接口。

Mario Fusco 的这篇思路清晰的文章介绍了为什么 Java 需要 Lambda 表达式。他解释了为什么现代编程语言必须包含闭包这类特性。

Lambda 表达式简介

Lambda 表达式是一种匿名函数(对 Java 而言这并不完全正确，但现在姑且这么认为)，简单地说，它是没有声明的方法，也即没有访问修饰符、返回值声明和名字。

你可以将其想做一种速记，在你需要使用某个方法的地方写上它。当某个方法只使用一次，而且定义很简短，使用这种速记替代之尤其有效，这样，你就不必在类中费力写声明与方法了。

Java 中的 Lambda 表达式通常使用 (argument) -> (body) 语法书写，例如：

(arg1, arg2...) -> { body } (type1 arg1, type2 arg2...) -> { body }

以下是一些 Lambda 表达式的例子：

(int a, int b) -> {  return a + b; } () -> System.out.println("Hello World"); (String s) -> { System.out.println(s); } () -> 42 () -> { return 3.1415 };

Lambda 表达式的结构

让我们了解一下 Lambda 表达式的结构。

• 一个 Lambda 表达式可以有零个或多个参数

• 参数的类型既可以明确声明，也可以根据上下文来推断。例如：(int a)与(a)效果相同

• 所有参数需包含在圆括号内，参数之间用逗号相隔。例如：(a, b) 或 (int a, int b) 或 (String a, int b, float c)

• 空圆括号代表参数集为空。例如：() -> 42

• 当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：a -> return a*a

• Lambda 表达式的主体可包含零条或多条语句

• 如果 Lambda 表达式的主体只有一条语句，花括号{}可省略。匿名函数的返回类型与该主体表达式一致

• 如果 Lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中（形成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空

什么是函数式接口

在 Java 中，Marker（标记）类型的接口是一种没有方法或属性声明的接口，简单地说，marker 接口是空接口。相似地，函数式接口是只包含一个抽象方法声明的接口。

java.lang.Runnable 就是一种函数式接口，在 Runnable 接口中只声明了一个方法 void run()，相似地，ActionListener 接口也是一种函数式接口，我们使用匿名内部类来实例化函数式接口的对象，有了 Lambda 表达式，这一方式可以得到简化。

每个 Lambda 表达式都能隐式地赋值给函数式接口，例如，我们可以通过 Lambda 表达式创建 Runnable 接口的引用。

Runnable r = () -> System.out.println("hello world");

当不指明函数式接口时，编译器会自动解释这种转化：

new Thread(   () -> System.out.println("hello world")).start();

因此，在上面的代码中，编译器会自动推断：根据线程类的构造函数签名 public Thread(Runnable r) { }，将该 Lambda 表达式赋给 Runnable 接口。

以下是一些 Lambda 表达式及其函数式接口：

Consumer<Integer>  c = (int x) -> { System.out.println(x) }; BiConsumer<Integer, String> b = (Integer x, String y) -> System.out.println(x + " : " + y); Predicate<String> p = (String s) -> { s == null };

@FunctionalInterface 是 Java 8 新加入的一种接口，用于指明该接口类型声明是根据 Java 语言规范定义的函数式接口。Java 8 还声明了一些 Lambda 表达式可以使用的函数式接口，当你注释的接口不是有效的函数式接口时，可以使用 @FunctionalInterface 解决编译层面的错误。

以下是一种自定义的函数式接口：

@FunctionalInterfacepublic interface WorkerInterface {    public void doSomeWork(); }

根据定义，函数式接口只能有一个抽象方法，如果你尝试添加第二个抽象方法，将抛出编译时错误。例如：

@FunctionalInterfacepublic interface WorkerInterface {     public void doSomeWork();     public void doSomeMoreWork(); }

错误：

Unexpected @FunctionalInterface annotation     @FunctionalInterface ^ WorkerInterface is not a functional interface multiple     non-overriding abstract methods found in interface WorkerInterface 1 error

函数式接口定义好后，我们可以在 API 中使用它，同时利用 Lambda 表达式。例如：

 //定义一个函数式接口@FunctionalInterfacepublic interface WorkerInterface {   public void doSomeWork();}

public class WorkerInterfaceTest {public static void execute(WorkerInterface worker) {    worker.doSomeWork();}public static void main(String [] args) {    //invoke doSomeWork using Annonymous class    execute(new WorkerInterface() {        @Override        public void doSomeWork() {            System.out.println("Worker invoked using Anonymous class");        }    });     //invoke doSomeWork using Lambda expression     execute( () -> System.out.println("Worker invoked using Lambda expression") );}}

输出：

Worker invoked using Anonymous class Worker invoked using Lambda expression

这上面的例子里，我们创建了自定义的函数式接口并与 Lambda 表达式一起使用。execute() 方法现在可以将 Lambda 表达式作为参数。

Lambda 表达式举例

学习 Lambda 表达式的最好方式是学习例子。

线程可以通过以下方法初始化：

//旧方法:new Thread(new Runnable() {@Overridepublic void run() {    System.out.println("Hello from thread");}}).start();//新方法:new Thread(() -> System.out.println("Hello from thread")).start();

事件处理可以使用 Java 8 的 Lambda 表达式解决。下面的代码中，我们将使用新旧两种方式向一个 UI 组件添加 ActionListener：

  //Old way:button.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {    System.out.println("The button was clicked using old fashion code!");}});//New way:button.addActionListener( (e) -> {    System.out.println("The button was clicked. From Lambda expressions !");});

以下代码的作用是打印出给定数组中的所有元素。注意，使用 Lambda 表达式的方法不止一种。在下面的例子中，我们先是用常用的箭头语法创建 Lambda 表达式，之后，使用 Java 8 全新的双冒号(::)操作符将一个常规方法转化为 Lambda 表达式：

//Old way:List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);for(Integer n: list) {   System.out.println(n);} //New way:List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);list.forEach(n -> System.out.println(n));  //or we can use :: double colon operator in Java 8list.forEach(System.out::println);

在下面的例子中，我们使用断言(Predicate)函数式接口创建一个测试，并打印所有通过测试的元素，这样，你就可以使用 Lambda 表达式规定一些逻辑，并以此为基础有所作为：

import java.util.Arrays;import java.util.List;import java.util.function.Predicate;public class Main {public static void main(String [] a)  {    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);    System.out.println("Print all numbers:");    evaluate(list, (n)->true);    System.out.println("Print no numbers:");    evaluate(list, (n)->false);    System.out.println("Print even numbers:");    evaluate(list, (n)-> n%2 == 0 );    System.out.println("Print odd numbers:");    evaluate(list, (n)-> n%2 == 1 );    System.out.println("Print numbers greater than 5:");    evaluate(list, (n)-> n > 5 );}public static void evaluate(List<Integer> list, Predicate<Integer> predicate) {    for(Integer n: list)  {        if(predicate.test(n)) {            System.out.println(n + " ");        }    }}}   

输出：

Print all numbers: 1 2 3 4 5 6 7 Print no numbers: Print even numbers: 2 4 6 Print odd numbers: 1 3 5 7 Print numbers greater than 5: 6 7

下面的例子使用 Lambda 表达式打印数值中每个元素的平方，注意我们使用了 .stream() 方法将常规数组转化为流。Java 8 增加了一些超棒的流 APIs。java.util.stream.Stream 接口包含许多有用的方法，能结合 Lambda 表达式产生神奇的效果。我们将 Lambda 表达式 x -> x*x 传给 map() 方法，该方法会作用于流中的所有元素。之后，我们使用 forEach 方法打印数据中的所有元素：

//Old way:List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);for(Integer n : list) {    int x = n * n;    System.out.println(x);} //New way:List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);list.stream().map((x) -> x*x).forEach(System.out::println);

下面的例子会计算给定数值中每个元素平方后的总和。请注意，Lambda 表达式只用一条语句就能达到此功能，这也是 MapReduce 的一个初级例子。我们使用 map() 给每个元素求平方，再使用 reduce() 将所有元素计入一个数值：

//Old way:List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);int sum = 0;for(Integer n : list) {    int x = n * n;    sum = sum + x;}System.out.println(sum); //New way:List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);int sum = list.stream().map(x -> x*x).reduce((x,y) -> x + y).get();System.out.println(sum);

Lambda 表达式与匿名类的区别

使用匿名类与 Lambda 表达式的一大区别在于关键词的使用。对于匿名类，关键词 this 解读为匿名类，而对于 Lambda 表达式，关键词 this 解读为写就 Lambda 的外部类。

Lambda 表达式与匿名类的另一不同在于两者的编译方法。Java 编译器编译 Lambda 表达式并将他们转化为类里面的私有函数，它使用 Java 7 中新加的 invokedynamic 指令动态绑定该方法，关于 Java 如何将 Lambda 表达式编译为字节码，Tal Weiss 写了一篇很好的文章。

到此为止啦，亲们！

Mark Reinhold，甲骨文的首席架构师，将 Lambda 表达式描述为该编程模型最大的提升——比泛型(generics)还强大。事实的确如此，Lambda 表达式赋予了 Java 程序员相较于其他函数式编程语言缺失的特性，结合虚拟扩展方法之类的特性，Lambda 表达式能写出一些极好的代码。

希望这篇文章能让您对 Java 8 的新特性所有了解。

原文地址：http://viralpatel.net/blogs/Lambda-expressions-java-tutorial/

OneAPM for Java 能够深入到所有 Java 应用内部完成应用性能管理和监控，包括代码级别性能问题的可见性、性能瓶颈的快速识别与追溯、真实用户体验监控、服务器监控和端到端的应用性能管理。想阅读更多技术文章，请访问 OneAPM 官方博客。

文章来自：https://segmentfault.com/a/1190000003941446

================================================================分割线===================================================================================

                                 Func和Action系统委托

为了方便开发，.net基类库针对在实际开发中最常用的情形提供了几个预定义好的委托，这些预定义委托用得很广。

 

Func，Action 
的介绍及其用法

Func是一种委托，这是在3.5里面新增的，2.0里面我们使用委托是用Delegate，Func位于System.Core命名空间下，使用委托可以提升效率，例如在反射中使用就可以弥补反射所损失的性能。

Action<T>和Func<T,TResult>的功能是一样的，只是Action<T>没有返类型，

Func<T,T,Result>：有参数，有返回类型
Action，则既没有返回也没有参数，


Func<T,TResult> 
的表现形式分为以下几种：

1。Func<T,TResult>
2。Func<T，T1,TResult>
3。Func<T,T1,T2,TResult>
4。Func<T,T1,T2,T3,TResult>
5。Func<T,T1,T2,T3,T4,TResult>

分别说一下各个参数的意义，TResult表示 
委托所返回值 所代表的类型， T,T1,T2,T3,T4表示委托所调用的方法的参数类型，
Func委托声明的最后一个泛型类型参数是委托所接收方法的返回值类型，前面的泛型类型参数（如果有的话）就是委托所接收的方法的形参类型。

 

以下是使用示例：

示例一：

static long Add(int x ,int y){    return x + y;}static void Main(string[] args){    //以下泛型委托变量接收拥有两个int类型参数，返回一个long数值的方法。    Func<int,int,long> func = Add;    long result = func(100,200); //result=300}

示例二：

Func<int, bool> myFunc = null;//全部变量myFunc = x => CheckIsInt32(x); //给委托封装方法的地方 使用了Lambda表达式private bool CheckIsInt32(int pars)//被封装的方法{　　return pars == 5;}  bool ok = myFunc(5);//调用委托

示例三：（将方法作为另一个方法的参数）

namespace FuncAsFuncArgu{    class Program    {        static void Main(string[] args)        {            int[] numbers = new int[7] { 0, 1, 2, 3, 4, 5, 6 };            Console.WriteLine(Process(Add, numbers, 0, 5));            Console.WriteLine(Process(Multiply, numbers, 1, 5));            Console.ReadKey();        }        static int Process(Func<int, int, int> op, int[] numbers, int from, int to)        {            int result = numbers[from];            for (int i = from + 1; i <= to; i++)                result = op(result, numbers[i]);            return result;        }        static int Add(int i, int j)        {            return i + j;        }        static int Multiply(int i, int j)        {            return i * j;        }    }}

但是如果我们需要所封装的方法不返回值，增么办呢？就使用Action！

可以使用 
Action<T1, T2, T3, T4>委托以参数形式传递方法，而不用显式声明自定义的委托。封装的方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有四个均通过值传递给它的参数，并且不能返回值。（在 C# 中，该方法必须返回 void。在 Visual Basic 中，必须通过 Sub…End Sub 结构来定义它。）通常，这种方法用于执行某个操作。
使用Action 委托，接收拥有0到4个参数且返回值类型为void的方法。
使用方法和Func类似！

文章来自：http://www.cnblogs.com/eagle1986/archive/2012/01/19/2327337.html