Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失?请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

Lambda in Java VS in C#

李新杰 2019-02-03 12:05:00 阅读数:193 评论数:0 点赞数:0 收藏数:0

核心+变化“凡是钱能解决的问题,就不是大问题。有很多问题是钱无法解决的,比如生老病死,比如不再相爱。”,看过《蜗居》的朋友一眼就能认出来。虽然这部电视剧讲的是chugui,但是毫无违和感,我当时都看出来真感情了。海藻和宋思明虽然是因借钱开始的,但是后面的发展却远远超出了它。这里面钱是问题的核心,后面发生的事情都是围绕着核心的变化。社会是一张庞大而复杂的网,有节点和连线组成。节点就是人,连线就是人际关系。这里面人是核心,人际关系是围绕着核心的变化。那到底是核心影响变化呢,还是变化影响核心呢,还是二者皆而有之呢?不管怎样,请记住都是:核心+变化。如果把核心看作是数据,那变化就是行为。如果把核心看作是字段,那变化就是方法。哎呀,终于回到了编程上,差点没绕回来。那些年,我的专业课老师“好了,我们这本书已经讲完了”。老师,明明后面还有一半呢,怎么就讲完了呢?“后面那是指针,给你们讲了你们也不懂”。都看看,这可是我计算机生涯的第一门语言,C语言呀,碰上这样的老师,“不仅侮辱了我们的人格,还侮辱了我们的智商”。所以我今天取得的“成就”都是我自己努力得来的。哈哈,开个玩笑,不管怎样,还是要感谢老师带我“上道”的。其它老师的“名言”,后续再分享。有句话怎么讲,“明知山有虎、偏向虎山行”,就是不信这个邪了,我倒要看看指针有多难。事实证明,很多事情因人而异。好多人都说指针很难,但是我从一开始学习指针,直到现在,从来没觉得它难。指针只不过是在变量的基础上又往前走了一步。变量对应的是数据本身,指针对应的是数据的地址。所以从指针获取数据需要执行一步解引用,即星号(/*)操作符。不过变量类型很多,所以指针的类型也很多,还有指向指针的指针,因此指针在写法上比较繁琐,不容易记住,但并不难理解。C语言中的函数指针人们对带“美”字的东西都比较感兴趣。如美景、美食、美酒、美元、美女等。当然也有讨厌的,如美国。来个美食吧。鱼类绝对算一个,特别是深海鱼。无污染,低脂肪,高蛋白,维生素,不饱和脂肪酸,而且肉质嫩滑,味道鲜美。关键还符合我国的传统文化,年年有鱼啊。岛国喜欢做成生鱼片或寿司。我国的花样就多了,红烧鱼,清蒸鱼,水煮鱼,麻辣鱼,剁椒鱼,酸菜鱼,蕃茄鱼,烤鱼等等。那么问题来了,如何用C语言实现这么多的做鱼呢?首先从生活入手,厨房 + 厨师 + 生鱼 = 熟鱼。假设每个厨师只会做一种鱼。用伪代码表示:

CookedFish kitchen(UncookedFish, CookWay) {     if (CookWay == "生鱼片") {         //厨师A做生鱼片     } else if (CookWay == "红烧鱼") {         //厨师B做红烧鱼     } else if (CookWay == "酸菜鱼") {         //厨师C做酸菜鱼     }... }

这个方法看起来很臃肿,因为它把所有的做鱼方法都放进来了。就像所有的厨师都在厨房里候着,然后进来一条生鱼,并告知要做成什么样的,对应的厨师起身去做鱼,剩余的厨师仍继续候着。现实中是厨师都在自己的岗位上,而非厨房里,需要做鱼的时候,厨师和生鱼进厨房即可。就像这样,厨房(厨师,生鱼)= 熟鱼,用伪代码表示:

CookedFish kitchen(Cooker/*, UncookedFish) {     //厨师做鱼     Cooker(UncookedFish); }

这里已经不需要CookWay了,因为一个厨师只会做一种鱼,从厨师就可以知道鱼的做法了。这里面的核心是鱼,围绕核心的变化是厨师。如果鱼是字段,那厨师就是方法了。第一种方法之所以繁琐,是因为我们只把字段传进来了,方法全部在“厨房”里。其实即使厨房里有再多的方法,一次也只能用一个。为了简洁和更加符合实际,我们除了把字段传进来之外,也把方法传进来了。即,既把鱼传进来,也把厨师传经来。这样厨房里只有一个厨师在工作,就清爽多了。我们可以看到,除了数据(鱼)可以当作参数传递外,行为(厨师)也可以当作参数传递。C语言不是OO的,没有对象的概念,也没有方法的概念,只有函数,一段可执行的代码就是函数。为了传递函数,需要用到函数指针,Cooker/*就是函数指针,它指向的就是一个代码片段。函数指针代表的是函数签名,即某一类函数。如void (/*fp)();这里的fp就是函数指针,它表示所有没有入参也没有返回值的这类函数。如下:

//函数 void foo(){...}; void bar(){...}; //把函数赋给函数指针 fp = &foo; fp = &bar; //通过指针调用函数 (/*fp)();

再看一个例子:

//函数指针 int (/fp2)(int, int); //加 int add(int a, int b) {     return a + b; } //减 int sub(int a, int b) {     return a + b; } //乘 int mul(int a, int b) {     return a + b; } //除 int div(int a, int b) {     return a + b; } //函数 int op2(int (/fp2)(int, int), int a, int b) {     return fp2(a, b); } //调用,把函数当作参数传入 op2(add, 1, 2) == 3; op2(sub, 2, 1) == 1; op2(mul, 1, 2) == 2; op2(div, 4, 2) == 2;

看不懂函数指针没关系,后面还有C/#和Java代码。C/#中的Lambda表达式初次接触lambda表达式就是在C/#中,已是很多年前的事了。C/#确实从C和C++中继承了很多特性。在C/#中应该也支持指针,但是不推荐使用。为了完成C语言中函数指针这种功能,C/#提供了类型安全的“函数指针”,就是委托。委托的关键字是delegate,它的用法如下:

public delegate void FB(int a);

委托表示的是方法签名,即一类方法。此处定义的委托类型是FB,它表示所有入参为一个整型且没有返回值的方法。所以可以把方法赋值给委托,自然可以调用委托,如下:

//一个整型入参,无返回值 public void Foo(int a) {     Console.WriteLine("Foo: " + a); } //一个整型入参,无返回值 public void Bar(int a) {     Console.WriteLine("Bar: " + a); } //委托的赋值与调用 public void TestDelegate() {     //把方法赋给委托     FB fb = this.Foo;     //调用委托     fb(1);     //把方法赋给委托     fb = this.Bar;     //调用委托     fb(2); }

委托还可以用作方法的参数,此时就可以把一个方法当作参数传给其它方法。

//第一个参数FB就是委托 public void TestDelegate(FB fb, int a) {     fb(a); } //下面是对这个方法的调用 Program p = new Program(); //p.Foo是一个方法,可以作为参数传入 p.TestDelegate(p.Foo, 1); //p.Bar是一个方法,可以作为参数传入 p.TestDelegate(p.Bar, 2);

lambda表达式本质上就是一段可执行的代码,但是不同语言对它的实现是不同的,在C/#中就实现为委托。

public void TestLambda() {     //这就是lambda表达式的写法,它被赋值给了委托     FB fb = (int a) => Console.WriteLine("lambda 1: " + a);     fb(1);     //lambda表达式     fb = (a) =>      {      Console.WriteLine("lambda 2: " + a);      };     fb(2); }

由于编译器会进行类型推断,所以可以省略参数类型。如果只有一个入参的话,可以省略那个小括号。如果只有一个语句的话,可以不用要大括号。lambda表达式作为参数传递:

public void TestLambda(FB fb, int a) {     fb(a); } //lambda表达式直接作为参数 p.TestLambda((int a) => Console.WriteLine("lambda 1: " + a), 1); //lambda表达式直接作为参数 p.TestLambda((a) => { Console.WriteLine("lambda 2: " + a); }, 2);

C/#中的匿名方法,如下:

public void TestAnonymousMethod() {     //匿名方法可以赋值给委托,用关键字delegate替代方法名     FB fb = delegate(int a)     {      Console.WriteLine("anonymous method: " + a);     };     fb(1);     fb(2); }

匿名方法作为参数传递:

public void TestAnonymousMethod(FB fb, int a) {     fb(a); } //匿名方法直接作为方法参数 p.TestAnonymousMethod(delegate(int a) { Console.WriteLine("anonymous method: " + a); }, 1); //匿名方法直接作为方法参数 p.TestAnonymousMethod(delegate(int a) { Console.WriteLine("anonymous method: " + a); }, 2);

总之,C/#中的普通方法,lambda表达式,匿名方法,最后都可以赋值给委托进行传递和调用。看不懂C/#没关系,后面还有Java代码。Java中的Lambda表达式自从Java换了爸爸后,简直像坐上了火箭。各种其它语言的特性都陆续加进来了。从Java 8开始也可以使用lambda表达式了。不过说来惭愧,我用的不多,因为它在我的编程生涯中已经不再“稀奇”了,因为之前已经在C/#中体验过了。Java也是从C和C++发展过来的,继承了一些特性,但抛弃的更多。类似函数指针的功能,就被优化没了。因此在Java语言中,对于行为(可执行代码片段)的传递,无法做到方法级别,只能再往上走一步,做到接口级别或类级别。也就是说,你想传递一个方法时,必须要传递一个类或对象作为方法的载体才行。这种使用方式其实一直都存在着的。Java 8中引入一个新的概念叫做函数式接口。它规定这样的接口只能包含一个抽象方法,但可以包含其它带默认实现的任意方法。函数式接口也可以像普通接口那样使用。只不过会有一些特定功能,毕竟是为了配合Java 8支持函数式编程而特意起的这个名字。有一个函数式接口叫做Consumer,它只有一个抽象方法是void accept(T t);这个方法接收一个入参但没有返回值。所以这个函数式接口就代表了这样一类方法,即有一个入参但没有返回值的所有方法。所以函数式接口大致上也可以看作是一类方法的“方法签名”。定义一个函数式接口变量,表示只有一个入参但没有返回值的这类方法。

//函数式接口变量 public Consumer fb;

可以把方法赋值给函数式接口,然后进行调用,如下:

//只有一个入参且没有返回值的方法 public void foo(int a) {     System.out.println("foo: " + a); } //只有一个入参且没有返回值的方法 public void bar(int a) {     System.out.println("bar: " + a); } //函数式接口的赋值与调用 public void testFunctionalInterface() {     //把方法赋值给函数式接口变量     fb = this::foo;     //调用函数式接口,就是调用赋给它的方法     fb.accept(1);     //把方法赋给函数式接口变量     fb = this::bar;     //调用     fb.accept(2); }

注意引用方法时使用了::操作符,这个应该是C++中的写法吧。函数式接口作为方法参数:

public void testFunctionalInterface(Consumer fb, int a) {     fb.accept(a); } Program p = new Program(); //把方法作为参数传给其它方法 p.testFunctionalInterface(p::foo, 1); //把方法作为参数传给其它方法 p.testFunctionalInterface(p::bar, 2);

毫无悬念,lambda表达式可以赋给函数式接口变量。

public void testLambda() {     //lambda表达式的写法     fb = (Integer a) -> System.out.println("lambda 1: " + a);     fb.accept(1);     //lambda表达式     fb = (a) -> {         System.out.println("lambda 2: " + a);      };     fb.accept(2); }

很显然,没有太多的惊喜。lambda表达式作为参数传递:

public void testLambda(Consumer fb, int a) {     fb.accept(a); } //lambda表达式直接作为参数传递 p.testLambda((Integer a) -> System.out.println("lambda 1: " + a), 1); //lambda表达式直接作为参数传递 p.testLambda((a) -> { System.out.println("lambda 2: " + a); }, 2);

Java中的匿名类:

public void testAnonymousClass() {     //匿名类,函数式接口作为普通接口使用     fb = new Consumer() {             @Override             public void accept(Integer a) {                 System.out.println("anonymous class: " + a);             }         };     fb.accept(1);     fb.accept(2); }

匿名类作为参数传递:

public void testAnonymousClass(Consumer fb, int a) {     fb.accept(a); } //匿名类直接做参数 p.testAnonymousClass(new Consumer() {         @Override         public void accept(Integer a) {             System.out.println("anonymous class: " + a);         }     }, 1); //匿名类直接做参数 p.testAnonymousClass(new Consumer() {         @Override         public void accept(Integer a) {             System.out.println("anonymous class: " + a);         }     }, 2);

总之,在Java中无论是普通方法,还是lambda表达式,或是匿名类,其实它们最后都变成了一个类,且都实现了这个函数式接口。只不过匿名类是我们自己定义的。lambda表达式最后对应的类是编译器造出来的,所以它是“人造”的,但不是匿名的。看不懂Java没关系,只要明白了原理就算是知道了精髓。in C/# VS in Java为了“模拟”函数指针的功能,在C/#中使用委托,在Java中使用函数式接口。函数式接口其实就是一个接口,它看起来具有表示“方法签名”的功能,但是很丑陋。委托看起来更像“方法签名”,也很优雅,但不要被迷惑,其实它也是一个类,没有什么高级东西。对于引用方法的写法不同,C/#中使用this.Foo,this.Bar,Java中使用this::foo,this::bar。lambda表达式的写法略微不同,C/#中是() => {},Java中是() -> {}。关于匿名,C/#中虽然叫匿名方法,其实最后还是一个类,而且是委托类型的。直接用delegate关键字定义匿名方法。Java中就叫匿名类,名副其实,最后就是一个类。只不过需要先定义一个接口,然后直接使用接口实现匿名类。我们发现C/#和Java对lambda表达式的支持其实差不多。不同的是C/#更优雅一些,Java更丑陋一些。

思想提升

一定要明白不仅普通数据可以当作参数传递,代码片段(就是逻辑)也可以当作参数传递。这个思想就是核心,至于写法和用法就是围绕着核心的变化而已。

PS:最近几年很少看到语言之争啊,莫非大家都觉得PHP是世界上最好的语言啦。Oracle选择收费和有闭源的趋势,微软却选择免费、开源和跨平台,上帝才知道这是怎么回事。

编程新说

用独特的视角说技术

版权声明
本文为[李新杰]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/lixinjie/p/lambda-in-java-vs-in-csharp.html

编程之旅,人生之路,不止于编程,还有诗和远方。
阅代码原理,看框架知识,学企业实践;
赏诗词,读日记,踏人生之路,观世界之行;

支付宝红包,每日可领