快速入门Java中的Lambda表达式
lambda简介
lambda表达式是java se 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
lambda表达式还增强了集合库。 java se 8添加了2个对集合数据进行批量操作的包: java.util.function 包以及 java.util.stream 包。 流(stream)就如同迭代器(iterator),但附加了许多额外的功能。 总的来说,lambda表达式和 stream 是自java语言添加泛型(generics)和注解(annotation)以来最大的变化。
lambda表达式本质上是匿名方法，其底层还是通过invokedynamic指令来生成匿名类来实现。它提供了更为简单的语法和写作方式，允许你通过表达式来代替函数式接口。在一些人看来，lambda就是可以让你的代码变得更简洁，完全可以不使用——这种看法当然没问题，但重要的是lambda为java带来了闭包。得益于lamdba对集合的支持，通过lambda在多核处理器条件下对集合遍历时的性能提高极大，另外我们可以以数据流的方式处理集合——这是非常有吸引力的。
lambda语法
lambda的语法极为简单，类似如下结构:
(parameters) -> expression
或者
(parameters) -> { statements; }
lambda表达式由三部分组成：
1、paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由jvm隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
2、->：可理解为“被用于”的意思
3、方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。
我们通过以下几个示例来做说明：
//示例1：不需要接受参数，直接返回10
()->10
//示例2：接受两个int类型的参数，并返回这两个参数相加的和
(int x,int y)->x+y;
//示例2：接受x,y两个参数，该参数的类型由jvm根据上下文推断出来，并返回两个参数的和
(x,y)->x+y;
//示例3：接受一个字符串，并将该字符串打印到控制到，不反回结果
(string name)->system.out.println(name);
//示例4：接受一个推断类型的参数name，并将该字符串打印到控制台
name->system.out.println(name);
//示例5：接受两个string类型参数，并分别输出，不反回
(string name,string sex)->{system.out.println(name);system.out.println(sex)}
//示例6：接受一个参数x，并返回该该参数的两倍
x->2*x
lambda用在哪里
在[函数式接口][1]中我们知道lambda表达式的目标类型是函数性接口——每一个lambda都能通过一个特定的函数式接口与一个给定的类型进行匹配。因此一个lambda表达式能被应用在与其目标类型匹配的任何地方，lambda表达式必须和函数式接口的抽象函数描述一样的参数类型，它的返回类型也必须和抽象函数的返回类型兼容，并且他能抛出的异常也仅限于在函数的描述范围中。
接下来，我们看一个自定义的函数式接口示例：
@functionalinterface
interface converter<f, t>{
t convert(f from);
}
首先用传统的方式来使用该接口：
converter<string ,integer> converter=new converter<string, integer>() {
@override
public integer convert(string from) {
return integer.valueof(from);
}
};
integer result = converter.convert("200");
system.out.println(result);
很显然这没任何问题，那么接下里就是lambda上场的时刻，用lambda实现converter接口：
converter<string ,integer> converter=(param) -> integer.valueof(param);
integer result = converter.convert("101");
system.out.println(result);
通过上例，我想你已经对lambda的使用有了个简单的认识，下面，我们在用一个常用的runnable做演示：
在以前我们可能会写下这种代码：
new thread(new runnable() {
@override
public void run() {
system.out.println("hello lambda");
}
}).start();
在某些情况下，大量的匿名类会让代码显得杂乱无章。现在可以用lambda来使它变得简洁：
new thread(() -> system.out.println("hello lambda")).start();
方法引用
方法引用是lambda表达式的一个简化写法。所引用的方法其实是lambda表达式的方法体的实现，其语法结构为:
objectref::methodname
左边可以是类名或者实例名，中间是方法引用符号”::”，右边是相应的方法名。
方法引用被分为三类：
1. 静态方法引用
在某些情况下，我们可能写出这样的代码：
public class referencetest {
public static void main(string[] args) {
converter<string ,integer> converter=new converter<string, integer>() {
@override
public integer convert(string from) {
return referencetest.string2int(from);
}
};
converter.convert("120");
}
@functionalinterface
interface converter<f,t>{
t convert(f from);
}
static int string2int(string from) {
return integer.valueof(from);
}
}
这时候如果用静态引用会使的代码更加简洁：
converter<string, integer> converter = referencetest::string2int;
converter.convert("120");
2. 实例方法引用
我们也可能会写下这样的代码：
public class referencetest {
public static void main(string[] args) {
converter<string, integer> converter = new converter<string, integer>() {
@override
public integer convert(string from) {
return new helper().string2int(from);
}
};
converter.convert("120");
}
@functionalinterface
interface converter<f, t> {
t convert(f from);
}
static class helper {
public int string2int(string from) {
return integer.valueof(from);
}
}
}
同样用实例方法引用会显得更加简洁：
helper helper = new helper();
converter<string, integer> converter = helper::string2int;
converter.convert("120");
3. 构造方法引用
现在我们来演示构造方法的引用。首先我们定义一个父类animal:
class animal{
private string name;
private int age;
public animal(string name, int age) {
this.name = name;
this.age = age;
}
public void behavior(){
}
}
接下来，我们在定义两个animal的子类：dog、bird
public class bird extends animal {
public bird(string name, int age) {
super(name, age);
}
@override
public void behavior() {
system.out.println("fly");
}
}
class dog extends animal {
public dog(string name, int age) {
super(name, age);
}
@override
public void behavior() {
system.out.println("run");
}
}
随后我们定义工厂接口：
interface factory<t extends animal> {
t create(string name, int age);
}
接下来我们还是用传统的方法来创建dog类和bird类的对象：
factory factory=new factory() {
@override
public animal create(string name, int age) {
return new dog(name,age);
}
};
factory.create("alias", 3);
factory=new factory() {
@override
public animal create(string name, int age) {
return new bird(name,age);
}
};
factory.create("smook", 2);
仅仅为了创建两个对象就写了十多号代码，现在我们用构造函数引用试试：
factory<animal> dogfactory =dog::new;
animal dog = dogfactory.create("alias", 4);
factory<bird> birdfactory = bird::new;
bird bird = birdfactory.create("smook", 3);
这样代码就显得干净利落了。通过dog::new这种方式来穿件对象时，factory.create函数的签名选择相应的造函数。
lambda的域以及访问限制
域即作用域，lambda表达式中的参数列表中的参数在该lambda表达式范围内（域）有效。在作用lambda表达式内，可以访问外部的变量：局部变量、类变量和静态变量，但操作受限程度不一。
访问局部变量
在lambda表达式外部的局部变量会被jvm隐式的编译成final类型，因此只能访问外而不能修改。
public class referencetest {
public static void main(string[] args) {
int n = 3;
calculate calculate = param -> {
//n=10; 编译错误
return n + param;
};
calculate.calculate(10);
}
@functionalinterface
interface calculate {
int calculate(int value);
}
}
访问静态变量和成员变量
在lambda表达式内部，对静态变量和成员变量可读可写。
public class referencetest {
public int count = 1;
public static int num = 2;
public void test() {
calculate calculate = param -> {
num = 10;//修改静态变量
count = 3;//修改成员变量
return n + param;
};
calculate.calculate(10);
}
public static void main(string[] args) {
}
@functionalinterface
interface calculate {
int calculate(int value);
}
}
lambda不能访问函数接口的默认方法
java8增强了接口，其中包括接口可添加default关键词定义的默认方法，这里我们需要注意，lambda表达式内部不支持访问默认方法。
lambda实践
在[函数式接口][2]一节中，我们提到java.util.function包中内置许多函数式接口，现在将对常用的函数式接口做说明。
predicate接口
输入一个参数，并返回一个boolean值，其中内置许多用于逻辑判断的默认方法:
@test
public void predicatetest() {
predicate<string> predicate = (s) -> s.length() > 0;
boolean test = predicate.test("test");
system.out.println("字符串长度大于0:" + test);
test = predicate.test("");
system.out.println("字符串长度大于0:" + test);
test = predicate.negate().test("");
system.out.println("字符串长度小于0:" + test);
predicate<object> pre = objects::nonnull;
object ob = null;
test = pre.test(ob);
system.out.println("对象不为空:" + test);
ob = new object();
test = pre.test(ob);
system.out.println("对象不为空:" + test);
}
function接口
接收一个参数，返回单一的结果，默认的方法（andthen）可将多个函数串在一起，形成复合funtion（有输入，有输出）结果，
@test
public void functiontest() {
function<string, integer> tointeger = integer::valueof;
//tointeger的执行结果作为第二个backtostring的输入
function<string, string> backtostring = tointeger.andthen(string::valueof);
string result = backtostring.apply("1234");
system.out.println(result);
function<integer, integer> add = (i) -> {
system.out.println("frist input:" + i);
return i * 2;
};
function<integer, integer> zero = add.andthen((i) -> {
system.out.println("second input:" + i);
return i * 0;
});
integer res = zero.apply(8);
system.out.println(res);
}
supplier接口
返回一个给定类型的结果，与function不同的是，supplier不需要接受参数(供应者，有输出无输入)
@test
public void suppliertest() {
supplier<string> supplier = () -> "special type value";
string s = supplier.get();
system.out.println(s);
}
consumer接口
代表了在单一的输入参数上需要进行的操作。和function不同的是，consumer没有返回值(消费者，有输入，无输出)
@test
public void consumertest() {
consumer<integer> add5 = (p) -> {
system.out.println("old value:" + p);
p = p + 5;
system.out.println("new value:" + p);
};
add5.accept(10);
}
以上四个接口的用法代表了java.util.function包中四种类型，理解这四个函数式接口之后，其他的接口也就容易理解了，现在我们来做一下简单的总结：
predicate用来逻辑判断，function用在有输入有输出的地方，supplier用在无输入，有输出的地方，而consumer用在有输入，无输出的地方。你大可通过其名称的含义来获知其使用场景。
stream
lambda为java8带了闭包，这一特性在集合操作中尤为重要：java8中支持对集合对象的stream进行函数式操作，此外，stream api也被集成进了collection api，允许对集合对象进行批量操作。
下面我们来认识stream。
stream表示数据流，它没有数据结构，本身也不存储元素，其操作也不会改变源stream，而是生成新stream.作为一种操作数据的接口，它提供了过滤、排序、映射、规约等多种操作方法，这些方法按照返回类型被分为两类：凡是返回stream类型的方法，称之为中间方法（中间操作），其余的都是完结方法（完结操作）。完结方法返回一个某种类型的值，而中间方法则返回新的stream。中间方法的调用通常是链式的，该过程会形成一个管道，当完结方法被调用时会导致立即从管道中消费值，这里我们要记住：stream的操作尽可能以“延迟”的方式运行，也就是我们常说的“懒操作”，这样有助于减少资源占用，提高性能。对于所有的中间操作（除sorted外）都是运行在延迟模式下。
stream不但提供了强大的数据操作能力，更重要的是stream既支持串行也支持并行，并行使得stream在多核处理器上有着更好的性能。
stream的使用过程有着固定的模式：
1、创建stream
2、通过中间操作，对原始stream进行“变化”并生成新的stream
3、使用完结操作，生成最终结果
也就是
创建——>变化——>完结
stream的创建
对于集合来说，可以通过调用集合的stream()或者parallelstream()来创建，另外这两个方法也在collection接口中实现了。对于数组来说，可以通过stream的静态方法of(t … values)来创建，另外，arrays也提供了有关stream的支持。
除了以上基于集合或者数组来创建stream,也可以通过steam.empty()创建空的stream,或者利用stream的generate（）来创建无穷的stream。
下面我们以串行stream为例，分别说明stream几种常用的中间方法和完结方法。首先创建一个list集合：
list<string> lists=new arraylist<string >();
lists.add("a1");
lists.add("a2");
lists.add("b1");
lists.add("b2");
lists.add("b3");
lists.add("o1");
中间方法
过滤器（filter）
结合predicate接口，filter对流对象中的所有元素进行过滤,该操作是一个中间操作，这意味着你可以在操作返回结果的基础上进行其他操作。
public static void streamfiltertest() {
lists.stream().filter((s -> s.startswith("a"))).foreach(system.out::println);
//等价于以上操作
predicate<string> predicate = (s) -> s.startswith("a");
lists.stream().filter(predicate).foreach(system.out::println);
//连续过滤
predicate<string> predicate1 = (s -> s.endswith("1"));
lists.stream().filter(predicate).filter(predicate1).foreach(system.out::println);
}
排序（sorted）
结合comparator接口，该操作返回一个排序过后的流的视图，原始流的顺序不会改变。通过comparator来指定排序规则，默认是按照自然顺序排序。
public static void streamsortedtest() {
system.out.println("默认comparator");
lists.stream().sorted().filter((s -> s.startswith("a"))).foreach(system.out::println);
system.out.println("自定义comparator");
lists.stream().sorted((p1, p2) -> p2.compareto(p1)).filter((s -> s.startswith("a"))).foreach(system.out::println);
}
映射（map）
结合function接口，该操作能将流对象中的每个元素映射为另一种元素，实现元素类型的转换。
public static void streammaptest() {
lists.stream().map(string::touppercase).sorted((a, b) -> b.compareto(a)).foreach(system.out::println);
system.out.println("自定义映射规则");
function<string, string> function = (p) -> {
return p + ".txt";
};
lists.stream().map(string::touppercase).map(function).sorted((a, b) -> b.compareto(a)).foreach(system.out::println);
}
在上面简单介绍了三种常用的操作，这三种操作极大简化了集合的处理。接下来，介绍几种完结方法：
完结方法
“变换”过程之后，需要获取结果，即完成操作。下面我们来看相关的操作：
匹配（match）
用来判断某个predicate是否和流对象相匹配，最终返回boolean类型结果，例如：
public static void streammatchtest() {
//流对象中只要有一个元素匹配就返回true
boolean anystartwitha = lists.stream().anymatch((s -> s.startswith("a")));
system.out.println(anystartwitha);
//流对象中每个元素都匹配就返回true
boolean allstartwitha
= lists.stream().allmatch((s -> s.startswith("a")));
system.out.println(allstartwitha);
}
收集（collect）
在对经过变换之后，我们将变换的stream的元素收集，比如将这些元素存至集合中，此时便可以使用stream提供的collect方法，例如：
public static void streamcollecttest() {
list<string> list = lists.stream().filter((p) -> p.startswith("a")).sorted().collect(collectors.tolist());
system.out.println(list);
}
计数（count）
类似sql的count，用来统计流中元素的总数，例如：
public static void streamcounttest() {
long count = lists.stream().filter((s -> s.startswith("a"))).count();
system.out.println(count);
}
规约（reduce）
reduce方法允许我们用自己的方式去计算元素或者将一个stream中的元素以某种规律关联，例如：
public static void streamreducetest() {
optional<string> optional = lists.stream().sorted().reduce((s1, s2) -> {
system.out.println(s1 + "|" + s2);
return s1 + "|" + s2;
});
}
执行结果如下：
a1|a2 a1|a2|b1 a1|a2|b1|b2 a1|a2|b1|b2|b3 a1|a2|b1|b2|b3|o1
并行stream vs 串行stream
到目前我们已经将常用的中间操作和完结操作介绍完了。当然所有的的示例都是基于串行stream。接下来介绍重点戏——并行stream（parallel stream）。并行stream基于fork-join并行分解框架实现，将大数据集合切分为多个小数据结合交给不同的线程去处理，这样在多核处理情况下，性能会得到很大的提高。这和mapreduce的设计理念一致：大任务化小，小任务再分配到不同的机器执行。只不过这里的小任务是交给不同的处理器。
通过parallelstream（）创建并行stream。为了验证并行stream是否真的能提高性能，我们执行以下测试代码：
首先创建一个较大的集合：
list<string> biglists = new arraylist<>();
for (int i = 0; i < 10000000; i++) {
uuid uuid = uuid.randomuuid();
biglists.add(uuid.tostring());
}
测试串行流下排序所用的时间：
private static void notparallelstreamsortedtest(list<string> biglists) {
long starttime = system.nanotime();
long count = biglists.stream().sorted().count();
long endtime = system.nanotime();
long millis = timeunit.nanoseconds.tomillis(endtime - starttime);
system.out.println(system.out.printf("串行排序: %d ms", millis));
}
测试并行流下排序所用的时间：
private static void parallelstreamsortedtest(list<string> biglists) {
long starttime = system.nanotime();
long count = biglists.parallelstream().sorted().count();
long endtime = system.nanotime();
long millis = timeunit.nanoseconds.tomillis(endtime - starttime);
system.out.println(system.out.printf("并行排序: %d ms", millis));
}
结果如下：
串行排序: 13336 ms
并行排序: 6755 ms
看到这里，我们确实发现性能提高了约么50%，你也可能会想以后都用parallel stream不久行了么？实则不然，如果你现在还是单核处理器，而数据量又不算很大的情况下，串行流仍然是这种不错的选择。你也会发现在某些情况，串行流的性能反而更好，至于具体的使用，需要你根据实际场景先测试后再决定。
懒操作
上面我们谈到stream尽可能以延迟的方式运行，这里通过创建一个无穷大的stream来说明：
首先通过stream的generate方法来一个自然数序列，然后通过map变换stream：
//递增序列
class natureseq implements supplier<long> {
long value = 0;
@override
public long get() {
value++;
return value;
}
}
public void streamcreatetest() {
stream<long> stream = stream.generate(new natureseq());
system.out.println("元素个数："+stream.map((param) -> {
return param;
}).limit(1000).count());
}
执行结果为：
元素个数：1000
我们发现开始时对这个无穷大的stream做任何中间操作（如：filter,map等，但sorted不行）都是可以的，也就是对stream进行中间操作并生存一个新的stream的过程并非立刻生效的（不然此例中的map操作会永远的运行下去，被阻塞住），当遇到完结方法时stream才开始计算。通过limit()方法，把这个无穷的stream转为有穷的stream。
总结
以上就是java lambda快速入门详解的全部内容，看完本文后大家是不是对java lambda有了更深的了解，希望本文对大家学习java lambda能有所帮助。