Lambda in Java VS in C#


核心+变化



“凡是钱能解决的问题,就不是大问题。有很多问题是钱无法解决的,比如生老病死,比如不再相爱。”,看过《蜗居》的朋友一眼就能认出来。虽然这部电视剧讲的是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)(intint);
//加
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)(intint), int a, int b) {
    return fp2(a, b);
}
//调用,把函数当作参数传入
op2(add12) == 3;
op2(sub, 21) == 1;
op2(mul, 12) == 2;
op2(div, 42) == 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<T>,它只有一个抽象方法是void accept(T t);这个方法接收一个入参但没有返回值。

所以这个函数式接口就代表了这样一类方法,即有一个入参但没有返回值的所有方法。所以函数式接口大致上也可以看作是一类方法的“方法签名”。

定义一个函数式接口变量,表示只有一个入参但没有返回值的这类方法。


//函数式接口变量
public Consumer<Integer> 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<Integer> 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<Integer> 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<Integer>() {
            @Override
            public void accept(Integer a
{
                System.out.println("anonymous class: " + a);
            }
        };

    fb.accept(1);
    fb.accept(2);
}


匿名类作为参数传递:


public void testAnonymousClass(Consumer<Integer> fb, int a{
    fb.accept(a);
}

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

//匿名类直接做参数
p.testAnonymousClass(new Consumer<Integer>() {
        @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选择收费和有闭源的趋势,微软却选择免费、开源和跨平台,上帝才知道这是怎么回事。


编程新说


用独特的视角说技术