这里有新鲜出炉的Java并发编程示例,程序狗速度看过来!
java 是一种可以撰写跨平台应用软件的面向对象的程序设计语言,是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台(即JavaEE(j2ee), JavaME(j2me), JavaSE(j2se))的总称。
Lambda作为函数式编程中的基础部分,在其他编程语言中早就广为使用,但在Java领域中发展较慢,直到java8,才开始支持Lambda。网上关于Lambda的教程很多,今天小编给大家分享一篇快速入手Lambda的教程。
Lambda简介
Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包:
包以及
- java.util.function
包。 流(stream)就如同迭代器(iterator),但附加了许多额外的功能。 总的来说,lambda表达式和 stream 是自Java语言添加泛型(Generics)和注解(annotation)以来最大的变化。
- java.util.stream
Lambda表达式本质上是匿名方法,其底层还是通过
指令来生成匿名类来实现。它提供了更为简单的语法和写作方式,允许你通过表达式来代替函数式接口。在一些人看来,Lambda就是可以让你的代码变得更简洁,完全可以不使用——这种看法当然没问题,但重要的是lambda为Java带来了闭包。得益于Lamdba对集合的支持,通过Lambda在多核处理器条件下对集合遍历时的性能提高极大,另外我们可以以数据流的方式处理集合——这是非常有吸引力的。
- invokedynamic
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()
来创建,另外这两个方法也在Collection接口中实现了。对于数组来说,可以通过Stream的静态方法
- parallelStream()
来创建,另外,Arrays也提供了有关stream的支持。
- of(T … values)
除了以上基于集合或者数组来创建Stream,也可以通过
创建空的Stream,或者利用Stream的
- Steam.empty()
来创建无穷的Stream。
- generate()
下面我们以串行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)
方法允许我们用自己的方式去计算元素或者将一个Stream中的元素以某种规律关联,例如:
- reduce
- 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的设计理念一致:大任务化小,小任务再分配到不同的机器执行。只不过这里的小任务是交给不同的处理器。
通过
创建并行Stream。为了验证并行Stream是否真的能提高性能,我们执行以下测试代码:
- parallelStream()
首先创建一个较大的集合:
- 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
变换Stream:
- map
- //递增序列
- 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
不行)都是可以的,也就是对Stream进行中间操作并生存一个新的Stream的过程并非立刻生效的(不然此例中的
- sorted
操作会永远的运行下去,被阻塞住),当遇到完结方法时stream才开始计算。通过
- map
方法,把这个无穷的Stream转为有穷的Stream。
- limit()
总结
以上就是Java Lambda快速入门详解的全部内容,看完本文后大家是不是对Java Lambda有了更深的了解,希望本文对大家学习Java Lambda能有所帮助。
来源: http://www.phperz.com/article/17/1113/360255.html