在java中构建lambda函数_JAVA中Lambda函数

1、Lambda函数怎么发展来的

最开始得写接口+类实现

抽象类：

如果一个class定义了方法，但没有具体执行代码，这个方法就是抽象方法，抽象方法用abstract修饰。

因为无法执行抽象方法，因此这个类也必须申明为抽象类(abstract class)。

因为抽象类本身被设计成只能用于被继承，因此，抽象类可以强迫子类实现其定义的抽象方法，否则编译会报错。因此，抽象方法实际上相当于定义了“规范”。

接口：

如果一个抽象类没有字段，所有方法全部都是抽象方法，就可以把该抽象类改写为接口：interface。

然后改进了，写一个匿名类就行了

匿名类：

匿名类是不能有名字的类，它们不能被引用，只能在创建时用new语句来声明它们。

直接 new ，类的主体里面写实现方法，省得先定义一个接口，再定义一个类去实现

后来又改进了，写lambda函数就行了

2、常用的lambda接口，给定义好了，也可以自己定义接口

lambda接口

参数

返回值

Runnable

0

0

Consumer

1

0

Function

1

1

Supplier

0

1

3、样例代码

import java.util.List;

import java.util.function.Function;

import static java.util.Arrays.asList;

public class Test1 {

static void p(String s){

System.out.println(s);

}

public static void main(String[] args) {

//现用现写，不能复用

String s = guan(5, (a)-> ""+2*a);

p(s);

//现用现写，可以复用，把变量摘出来定义一下

Functionfun0 = (a)->""+3*a;

String s0 = guan(5, fun0);

p(s0);

//通过实例方法调用

Test1 obj = new Test1();

String s2 = guan(5, obj::fun2);

p(s2);

//通过类方法调用

String s3 = guan(5, Test1::fun3);

p(s3);

p("");

p("");

//summary, lambda可以当作数组元素

List> list = asList((a)->""+2*a, fun0, obj::fun2, Test1::fun3);

list.forEach(e->{

String s5= guan(5, e);

p(s5);

});

p("");

p("");

for(int i=0; ifun=list.get(i);

String s6= guan(5, fun);

p(s6);

}

}

//实例方法

String fun2(int a){

return ""+4*a;

}

//类方法

static String fun3(int a){

return ""+5*a;

}

//lambda函数的内置接口

static String guan(int a, Functionfun){

return fun.apply(a);

}

}

开始自己写接口。。。

import java.util.List;

import static java.util.Arrays.asList;

public class Test1 {

static void p(String s){

System.out.println(s);

}

public static void main(String[] args) {

//匿名类实现

String s="Guan";

guanguan0(s, new Interf0() {

public void sayhello(String s) {

p("Hello" + ", " + s);

}

});

p("");

p("");

//lambda实现

Interf inte = (ss)->p("Hello"+", "+ss);

Interf inte1 = (ss)->p("Meinv"+", "+ss);

Interf inte2 = (ss)->p("Cainv"+", "+ss);

guanguan("Guanguan", inte);

guanguan("Guanguan", inte1);

guanguan("Guanguan", inte2);

p("");

p("");

//lambda实现简洁版，可以省略用接口那一步

Interf inte3= (ss)->p("Hello"+", "+ss);//实现接口

inte.talktoguanguan("laowang");//用接口

//实现接口

Cmp cm00 = (a, b)-> {

if (a == b) {

return 0;

}

else if (a < b) {

return -1;

}

else return 1;

};

Cmp cm01 = (a, b)-> {

if (a == b) {

return 0;

}

else if (a > b) {

return -1;

}

else return 1;

};

Listlistint = asList(3, 5, 8, 7, 6);

sort(listint, cm00);

sort(listint, cm01);

}

//定义接口

@FunctionalInterface

interface Interf0{

void sayhello(String user);

}

//用接口

static void guanguan0(String s, Interf0 inte){

inte.sayhello(s);

}

//定义接口

@FunctionalInterface

interface Interf{

void talktoguanguan(String user);

}

//用接口

static void guanguan(String s, Interf inte){

inte.talktoguanguan(s);

}

//定义接口

@FunctionalInterface

interface Cmp{

int cmp(int a, int b);

}

//用接口

static void sort(Listarray, Cmp cm) {

for (int i = 0; i < array.size(); ++i) {

for (int j = i + 1; i < array.size(); ++j) {

if (cm.cmp(array.get(i), array.get(j)) < 0) {

int temp = array.get(i);

array.set(i, array.get(j));

array.set(j,temp);

}

}

}

}

}