Java8 特性详解（一） Lambda-JobPlus

函数式编程是Java8最值得学习的新特性。

为什么要使用lambda表达式

从函数式接口说起

理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在。

函数式接口的定义其实很简单：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

为了让编译器帮助我们确保一个接口满足函数式接口的要求，也就是说有且仅有一个抽象方法。Java8提供了@FunctionalInterface注解。举个简单的例子，Runnable接口就是一个FI，下面是它的源代码：

1. @FunctionalInterface

2. public interface Runnable {

3. public abstract void run();

4. }

使用@FunctionalInterface注解并不强制要求。但是使用注解会让代码看上去更清楚。

lambda表达式的语法糖

语法糖

Java中lambda表达式的格式：参数、箭头->、一个表达式。
为了演示lambda表达式的语法糖，我们通过Comparator作为例子。在Java8之前，可以借助匿名内部类来实现。

1. public static List<String> compareTest1(){

2. List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");

3. wordList.sort(new Comparator<String>() {

4. @Override

5. public int compare(String w1, String w2) {

6. return Integer.compare(w1.length(), w2.length());

7. }

8. });

9. return wordList;

10. }

Comparator是个函数式接口，我们可以用Lambda表达式来实现。Lambda表达式，很像一个匿名的方法，只是小括号内的参数列表和花括号内的代码被->分隔开了。

1. public static List<String> compareTest2(){

2. List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");

3. wordList.sort((String w1, String w2) -> {

4. return Integer.compare(w1.length(), w2.length());

5. });

6. return wordList;

7. }

如果一个lambda表达式的参数类型是可以被推导的，那么就可以省略它们的类型。

1. public static List<String> compareTest3(){

2. List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");

3. wordList.sort((w1, w2) -> {

4. return Integer.compare(w1.length(), w2.length());

5. });

6. return wordList;

7. }

如果一个lambda表达式的代码块只是return后面跟一个表达式，那么还可以进一步简化。

1. public static List<String> compareTest4(){

2. List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");

3. wordList.sort((w1, w2) -> Integer.compare(w1.length(), w2.length()));

4. return wordList;

5. }

如果某个方法只含有一个参数，并且该参数的类型可以被推导出来，你甚至可以省略小括号。

1. public static List<String> compareTest5(){

2. List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");

3. wordList.forEach(word -> System.out.println(word));

4. return wordList;

5. }

当我们要在另外一个独立线程中执行一些逻辑时，通常会将代码放在一个实现Runable接口的类的run方法中。

1. public static void runnableTest1(){

2. Executors.newSingleThreadExecutor().execute(new Runnable() {

3. @Override

4. public void run() {

5. for (int i = 0; i < 10; i++) {

6. System.out.println(i);

7. }

8. }

9. });

10. }

如果lambda表达式没有参数，你仍可以提供一对空的小括号，如同不含参数的方法。

1. public static void runnableTest2(){

2. Executors.newSingleThreadExecutor().execute(() -> {

3. for (int i = 0; i < 10; i++) {

4. System.out.println(i);

5. }

6. });

7. }

注意点

· lambda表达式执行返回类型，会根据上下文推到出来，我们不需要设置它的返回类型。

· lambda表达式中，只有某些分支中返回值，这样是错误的。

方法引用

有些时候，lambda表达式的代码就只是一个简单的方法调用而已，遇到这种情况，lambda表达式还可以进一步简化为方法引用。
：：操作符将方法名和对象或类的名字分隔开来。

对象：：实例对象

在Java8之前，我们打印List内容，正常是这样做的。

1. public static void print1(){

2. List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");

3. wordList.forEach(new Consumer<String>() {

4. @Override

5. public void accept(String word) {

6. System.out.println(word);

7. }

8. });

9. }

因为Consumer是函数式接口，我们通过lambda表达式改造下。

1. public static void print2(){

2. List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");

3. wordList.forEach(word -> System.out.println(word));

4. }

如果改造成方法引用，表达式 System.out::println, 等价于word -> System.out.println(word)。

1. public static void print3(){

2. List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");

3. wordList.forEach(System.out::println);

4. }

类：：实例对象

例如，我们不区分大小写对字符串进行排序。

1. public static String[] sort1(){

2. String[] words = new String[]{"lianggzone", "spring", "summer", "autumn", "winter"};

3. Arrays.sort(words, (x, y) -> x.compareToIgnoreCase(y));

4. return words;

5. }

如果改造成方法引用，表达式: String::compareToIgnoreCase,等价于(x, y) -> x.compareToIgnoreCase(y),第一参数会成为执行方法的对象。

1. public static String[] sort2(){

2. String[] words = new String[]{"lianggzone", "spring", "summer", "autumn", "winter"};

3. Arrays.sort(words, String::compareToIgnoreCase);

4. return words;

5. }

对象：：静态方法

例如，我们对集合进行排序。

1. public static List<Integer> sortList1(){

2. List<Integer> wordList = Arrays.asList(21, 53);

3. wordList.sort((w1, w2) -> Integer.compare(w1, w2));

4. return wordList;

5. }

如果改造成方法引用，表达式: Integer::compare,等价于(w1, w2) -> Integer.compare(w1, w2),第一参数会成为执行方法的对象。

1. public static List<Integer> sortList2(){

2. List<Integer> wordList = Arrays.asList(21, 53);

3. wordList.sort(Integer::compare);

4. return wordList;

5. }

构造器引用

1. // lambda

2. words.stream().map(word -> {

3. return new StringBuilder(word);

4. });

5. // constructor reference

6. words.stream().map(StringBuilder::new);

变量作用域

在Java8之前，内部类只能访问final的局部变量，为了适应lambda表达式，Java8放宽了这种限制，只要变量实际上不可变（effectively final）就可以。

1. public static void effectivelyFinal(){

2. int a = 100;

3. Executors.newSingleThreadExecutor().execute(() -> {

4. System.out.println(a);

5. });

6. }

在lambda表达式中，被引用的变量的值不能被修改。做出这个约束的是有原因的，因为lambda表达式中的变量不是线程安全的。

接口的静态方法

从Java8开始，接口也可以有静态方法了。有了这个语法，我们就可以把和接口相关的帮助方法直接定义在接口里。

比如Function接口就定义了一个工厂方法indentity()。表示，一个功能接口，可以作为赋值的目标一个lambda表达式或方法参考。

T -函数输入的类型
R -函数的结果的类型

1. public interface Function<T, R> {

2. static <T> Function<T, T> identity() {

3. return t -> t;

4. }

5. }

事实上，Java8中，很多接口已经添加了静态方法，例如，Java8中的一个使用案例

1. public interface Path {

2. public static Path get(String first, String... more) {

3. return FileSystems.getDefault().getPath(first, more);

4. }

5. }

所以，重要的事情，再说一遍哟，从Java8开始，接口也可以有静态方法了。

函数式编程是Java8最值得学习的新特性。为什么要使用lambda表达式从函数式接口说起理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在。函数式接口的定义其实很简单：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。为了让编译器帮助我们确保一个接口满足函数式接口的要求，也就是说有且仅有一个抽象方法。Java8提供了@FunctionalInterface注解。举个简单的例子，Runnable接口就是一个FI，下面是它的源代码：1.       @FunctionalInterface2.       public interface Runnable {3.           public abstract void run();4.       }使用@FunctionalInterface注解并不强制要求。但是使用注解会让代码看上去更清楚。lambda表达式的语法糖语法糖Java中lambda表达式的格式：参数、箭头->、一个表达式。 为了演示lambda表达式的语法糖，我们通过Comparator作为例子。在Java8之前，可以借助匿名内部类来实现。1.       public static List<String> compareTest1(){2.           List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");3.           wordList.sort(new Comparator<String>() {4.               @Override5.               public int compare(String w1, String w2) {6.                   return Integer.compare(w1.length(), w2.length());7.               }8.           });9.           return wordList;       10.    }Comparator是个函数式接口，我们可以用Lambda表达式来实现。Lambda表达式，很像一个匿名的方法，只是小括号内的参数列表和花括号内的代码被->分隔开了。1.       public static List<String> compareTest2(){2.           List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");3.           wordList.sort((String w1, String w2) -> {4.               return Integer.compare(w1.length(), w2.length());5.           });6.           return wordList;       7.       }如果一个lambda表达式的参数类型是可以被推导的，那么就可以省略它们的类型。1.       public static List<String> compareTest3(){2.           List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");3.           wordList.sort((w1, w2) -> {4.               return Integer.compare(w1.length(), w2.length());5.           });6.           return wordList;       7.       }如果一个lambda表达式的代码块只是return后面跟一个表达式，那么还可以进一步简化。1.       public static List<String> compareTest4(){2.           List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");3.           wordList.sort((w1, w2) ->  Integer.compare(w1.length(), w2.length()));4.           return wordList;       5.       }如果某个方法只含有一个参数，并且该参数的类型可以被推导出来，你甚至可以省略小括号。1.       public static List<String> compareTest5(){2.           List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");3.           wordList.forEach(word ->  System.out.println(word));4.           return wordList;       5.       }当我们要在另外一个独立线程中执行一些逻辑时，通常会将代码放在一个实现Runable接口的类的run方法中。1.       public static void runnableTest1(){2.           Executors.newSingleThreadExecutor().execute(new Runnable() {   3.               @Override4.               public void run() {5.                   for (int i = 0; i < 10; i++) {6.                       System.out.println(i);7.                   }8.               }9.           });   10.    }如果lambda表达式没有参数，你仍可以提供一对空的小括号，如同不含参数的方法。1.       public static void runnableTest2(){2.           Executors.newSingleThreadExecutor().execute(() -> {3.               for (int i = 0; i < 10; i++) {4.                   System.out.println(i);5.               }6.           });   7.       }注意点·         lambda表达式执行返回类型，会根据上下文推到出来，我们不需要设置它的返回类型。·         lambda表达式中，只有某些分支中返回值，这样是错误的。方法引用有些时候，lambda表达式的代码就只是一个简单的方法调用而已，遇到这种情况，lambda表达式还可以进一步简化为方法引用。 ：：操作符将方法名和对象或类的名字分隔开来。对象：：实例对象在Java8之前，我们打印List内容，正常是这样做的。1.       public static void print1(){2.           List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");3.           wordList.forEach(new Consumer<String>() {4.               @Override5.               public void accept(String word) {6.                   System.out.println(word);7.               }8.           });   9.       }因为Consumer是函数式接口，我们通过lambda表达式改造下。1.       public static void print2(){2.           List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");3.           wordList.forEach(word -> System.out.println(word));       4.       }如果改造成方法引用，表达式 System.out::println, 等价于word -> System.out.println(word)。1.       public static void print3(){2.           List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");3.           wordList.forEach(System.out::println);   4.       }类：：实例对象例如，我们不区分大小写对字符串进行排序。1.       public static String[] sort1(){2.           String[] words = new String[]{"lianggzone", "spring", "summer", "autumn", "winter"};3.           Arrays.sort(words, (x, y) -> x.compareToIgnoreCase(y));4.           return words;5.       }如果改造成方法引用，表达式: String::compareToIgnoreCase,等价于(x, y) -> x.compareToIgnoreCase(y),第一参数会成为执行方法的对象。1.       public static String[] sort2(){2.           String[] words = new String[]{"lianggzone", "spring", "summer", "autumn", "winter"};3.           Arrays.sort(words, String::compareToIgnoreCase);4.           return words;5.       }对象：：静态方法例如，我们对集合进行排序。1.       public static List<Integer> sortList1(){2.           List<Integer> wordList = Arrays.asList(21, 53);3.           wordList.sort((w1, w2) -> Integer.compare(w1, w2));4.           return wordList;5.       }如果改造成方法引用，表达式: Integer::compare,等价于(w1, w2) -> Integer.compare(w1, w2),第一参数会成为执行方法的对象。1.       public static List<Integer> sortList2(){2.           List<Integer> wordList = Arrays.asList(21, 53);3.           wordList.sort(Integer::compare);4.           return wordList;5.       }构造器引用1.       // lambda2.       words.stream().map(word -> {3.           return new StringBuilder(word);4.       });5.       // constructor reference6.       words.stream().map(StringBuilder::new);变量作用域在Java8之前， 内部类只能访问final的局部变量 ，为了适应lambda表达式，Java8放宽了这种限制，只要变量实际上不可变（effectively final）就可以。1.       public static void effectivelyFinal(){2.           int a = 100;3.           Executors.newSingleThreadExecutor().execute(() -> {4.               System.out.println(a);5.           });   6.       }在lambda表达式中，被引用的变量的值不能被修改。做出这个约束的是有原因的，因为lambda表达式中的变量不是线程安全的。接口的静态方法从Java8开始，接口也可以有静态方法了。有了这个语法，我们就可以把和接口相关的帮助方法直接定义在接口里。比如Function接口就定义了一个工厂方法indentity()。表示， 一个功能接口，可以作为赋值的目标一个lambda表达式或方法参考。T -函数输入的类型 R -函数的结果的类型1.       public interface Function<T, R> {2.         static <T> Function<T, T> identity() {3.             return t -> t;4.         }5.       }事实上，Java8中，很多接口已经添加了静态方法，例如，Java8中的一个使用案例1.       public interface Path {2.         public static Path get(String first, String... more) {3.             return FileSystems.getDefault().getPath(first, more);4.         }5.       }所以，重要的事情，再说一遍哟，从Java8开始，接口也可以有静态方法了。

关于我们

法律声明

帮助中心

商务合作

相关文章

关于我们

法律声明

帮助中心

商务合作