首页 / JAVA / Java 8 Lambda

Java 8 Lambda

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java 8 Lambda，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7435字，纯文字阅读大概需要11分钟。

内容图文

最近查找资料学习时，发现例子中有好多地方用到了lambda表达式，所以今天学习记录一下。

推荐一个youtube的视频，讲解的非常不错。国内的伙伴有可能需要fan qiang才能看到。Good luck！！！

https://www.youtube.com/watch?v=gpIUfj3KaOc&list=PLqq-6Pq4lTTa9YGfyhyW2CqdtW9RtY-I3&index=1

 

Lambda表达式

它可以看做是函数型编程，那么java中函数定义就用接口来担当，所以，用到Lambda的时候需要使用一个接口。Lambda相关的语法规则也在下面代码中补充。

技术分享 技术分享 
                 1
                public
                class
                 LamdbaDemo01 {

                 2
                 3
                public
                static
                void
                 main(String[] args) {

                 4
                 5
                //
                 new Thread( () -> System.out.println("--")).start();
                 6         MyLambda greet = () -> System.out.println("Hello World!");
 7        greet.foo();
 8// MyAdd myAdd = (int i, int j) -> i + j; 
 9// 因为参数的变量名称一致，所以参数的变量类型可以省略10         MyAdd myAdd = (i, j) -> i + j; 
11         System.out.println(myAdd.add(2, 3));
1213// 当参数只有一个的时候可以省略（） ， 此外当箭头右侧的代码只用一行的时候，可以省略{}14         MyLength myLength = s -> s.length();
15         System.out.println(myLength.leng("Hello world!"));
16    }
17}
1819// 接口中只能有一个方法，这是使用Lambda表达式的要求20interface MyLambda {
21void foo();
22}
2324interface MyAdd {
25int add(int i, int b);
26}
2728interface MyLength {
29int leng(String s);
30 }
View Code

 

接下来看一个例子：

技术分享 技术分享 
                1
                public
                interface
                 Condition {

                2
                boolean
                 test (Person p);

                3 }
View Code
技术分享 技术分享 
                 1
                import
                 java.util.Arrays;

                 2
                import
                 java.util.Collections;

                 3
                import
                 java.util.Comparator;

                 4
                import
                 java.util.List;

                 5
                 6
                public
                class
                 Unit1ExercistWithJava7 {

                 7
                 8
                public
                static
                void
                 main(String args[]) {

                 9
                10     List<Person> list = Arrays.asList(
11new Person ("Charles", "Dickens", 60),
12new Person ("Lewis", "Carrol", 42),
13new Person ("Thamos", "Cayloe", 51),
14new Person ("Charlotte", "Brote", 45),
15new Person ("Matthew", "Aroid", 39)
16            );
1718// step 1: sort list by lastName19     Collections.sort(list, new Comparator<Person>(){
20        @Override
21publicint compare(Person o1, Person o2) {
22return o1.getLastName().compareTo(o2.getLastName());
23        }
24    } );
2526// step 2: Create a method that print all elements in the list27     printConditionally (list, new Condition(){
28        @Override
29publicboolean test(Person p) {
30returntrue;
31        }
32    });
3334     System.out.println("-------------------------");
35// step 3: Create a method that prints all people whose lastName beginning whie C36     printConditionally(list, new Condition(){
37        @Override
38publicboolean test(Person p) {
39return p.getLastName().startsWith("C");
40        }
41    });
42    }
4344privatestaticvoid printConditionally (List<Person> list, Condition condition) {
45for (Person p : list) {
46if (condition.test(p)) {
47                System.out.println(p);
48            }
49        }
50    }
51 }
View Code

上面的例子很简单，就是创建一个接口，里面有test方法，之后创建了一个List，根据自己的需要将list中满足一定条件的值取出。这里例子是用Java7写的。

接下来看Lambda表达式的例子：

技术分享 技术分享 
                 1
                import
                 java.util.Arrays;

                 2
                import
                 java.util.Collections;

                 3
                import
                 java.util.List;

                 4
                 5
                public
                class
                 Unit1ExercistWithLambda {

                 6
                 7
                public
                static
                void
                 main(String args[]) {

                 8
                 9     List<Person> list = Arrays.asList(
10new Person ("Charles", "Dickens", 60),
11new Person ("Lewis", "Carrol", 42),
12new Person ("Thamos", "Cayloe", 51),
13new Person ("Charlotte", "Brote", 45),
14new Person ("Matthew", "Aroid", 39)
15            );
1617// step 1: sort list by lastName
18// 使用Lambda表达式时，刚开始写不出，可以先写出匿名类的形式，之后在这个基础上再进行修改，慢慢的就会写了
19// 为什么括号里直接省略掉参数类型，你尅看用Java8实现的例子20     Collections.sort(list, (p1, p2) -> p1.getLastName().compareTo(p2.getLastName()));
2122// step 2: Create a method that print all elements in the list23     printConditionally (list, (p) -> true);
2425     System.out.println("-------------------------");
26// step 3: Create a method that prints all people whose lastName beginning whie C27     printConditionally(list, (p) -> p.getLastName().startsWith("C"));
28    }
2930privatestaticvoid printConditionally (List<Person> list, Condition condition) {
31for (Person p : list) {
32if (condition.test(p)) {
33                System.out.println(p);
34            }
35        }
36    }
37 }
View Code

在这个例子中，条件判断的实现，通过Lambda表达式来实现，可以看到代码量的减少，这是它的一个好处。

我们现在思考一下使用Lambda表达式的步骤。首先需要有个接口，接口中，必须有且只有一个方法，这是使用Lambda的前提条件。

之后，你就可以编写接口的实现部分。

其实我们也可以不自己创建接口，使用java.util.function 包 里面存在的接口。

比如上面Lambda表达式的例子可以修改成如下：

技术分享 技术分享 
                1
                private
                static
                void printConditionally (List<Person> list, Predicate<Person> predict) {
2for (Person p : list) {
3if (predict.test(p)) {
4                System.out.println(p);
5            }
6        }
7     }
View Code

这样的话，接口虽然修改了，但是Lambda实现的部分，完全不用任何修改，这是Lambda的另一个优势。

我们还在可以在printConditionally方法中再添加一个功能接口,例子如下：

技术分享 技术分享 
                 1
                //
                 step 2: Create a method that print all elements in the list
                 2     printConditionally (list, (p) -> true, (p) -> System.out.println(p));
 3 4     System.out.println("-------------------------");
 5// step 3: Create a method that prints all people whose lastName beginning whie C 6     printConditionally(list, (p) -> p.getLastName().startsWith("C"), (p) -> System.out.println(p));
 7    }
 8 9privatestaticvoid printConditionally (List<Person> list, Predicate<Person> predict, Consumer<Person> consumer) {
10for (Person p : list) {
11if (predict.test(p)) {
12                consumer.accept(p);
13            }
14        }
15     }
View Code

个人感受是，Lambda表达式使代码解耦，提高结构的灵活性。

 

Exception的捕获

无例子不说话：

技术分享 技术分享 
                 1
                import
                 java.util.function.BiConsumer;

                 2
                 3
                public
                class
                 Unit1ExercistWithLambdaWithException {

                 4
                 5
                public
                static
                void
                 main(String args[]) {

                 6
                int [] someNumbers = {1,2,3,4};
 7int key = 0;
 8/*第二种设想是在 process 方法中的第三个参数外侧添加try catch
 9        但是那样的话，跟java 7的匿名类有些相似，而且，又会增加耦合度。
10        最后，使用现在的，第三种方式来捕获异常。可能会觉得麻烦，跟之前的两种方法没什么区别，
11        但是第三种方式，我觉得有些像AOP，而且这样对结构的入侵要少*/12         process (someNumbers, key, wrapperLambda((k ,v) -> System.out.println(k/v)));
13    }
1415privatestatic BiConsumer<Integer, Integer> wrapperLambda(BiConsumer<Integer, Integer> wrapper) {
16return (k ,v) -> {
17try {
18                wrapper.accept(k, v);
19             } catch (ArithmeticException e) {
20                 System.out.println("Exception caught in wrapper lambda");
21            }
22        };
23    }
2425privatestaticvoid process(int[] someNumbers, int key, BiConsumer<Integer, Integer> consumer) {
26// Exception的捕捉的第一种设想是在下面代码块的外侧追加try catch 来捕捉异常
27// 但是，这只是个抽象的process的方法，不能确定实现类中出现的异常，所以在这里捕捉，不合理28for (int i : someNumbers) {
29            consumer.accept(i, key);
30        }
31    }
32 }
View Code

不知道怎么该如何讲述这个部分，例子有注释，大家不懂的地方，再留言谈论。

 

方法的引用

例子如下：

技术分享 技术分享 
                 1
                public
                class
                 MethodReference {

                 2
                 3
                public
                static
                void
                 main(String[] args) {

                 4
                 5
                //
                 下面两行的代码是等价的

                 6
                //
                 Thread thread = new Thread(() -> printMessage());
                 7         Thread thread = new Thread(MethodReference::printMessage);
 8        thread.start();
 9    }
1011privatestaticvoid printMessage() {
12         System.out.println("Hello World!");
13    }
1415 }
View Code

 Unit1ExercistWithLambda3.java 中的例子中的部分代码：

技术分享 技术分享 
                1
                //
                 printConditionally(list, (p) -> p.getLastName().startsWith("C"), (p) -> System.out.println(p));
                2
                3     printConditionally(list, (p) -> p.getLastName().startsWith("C"), System.out::println);
View Code

 

foreach

技术分享 技术分享 
                 1
                import
                 java.util.Arrays;

                 2
                import
                 java.util.List;

                 3
                 4
                public
                class
                 CollectionIterationExample {

                 5
                 6
                public
                static
                void
                 main(String[] args) {

                 7         List<Person> list = Arrays.asList(
 8new Person ("Charles", "Dickens", 60),
 9new Person ("Lewis", "Carrol", 42),
10new Person ("Thamos", "Cayloe", 51),
11new Person ("Charlotte", "Brote", 45),
12new Person ("Matthew", "Aroid", 39)
13                );
1415         System.out.println("Using for loop");
16for (int i=0; i<list.size();i++) {
17            System.out.println(list.get(i));
18        }
1920         System.out.println("Using for each loop");
21for (Person person : list) {
22            System.out.println(person);
23        }
2425// Java8 Lambda26         System.out.println("Using for loop");
27         list.forEach(p -> System.out.println(p));
28         System.out.println("--------------");
29        list.forEach(System.out::println);
30    }
3132 }
View Code

 

觉得Lambda的表达式非常便捷。

原文：http://www.cnblogs.com/lihao007/p/7545140.html

内容总结

以上是互联网集市为您收集整理的Java 8 Lambda全部内容，希望文章能够帮你解决Java 8 Lambda所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1226003.html

来源：【匿名】