文章目录

  1. 1. 为什么要使用lambda表达式
  2. 2. 从函数式接口说起
  3. 3. lambda表达式的语法糖
    1. 3.1. 语法糖
    2. 3.2. 注意点
  4. 4. 方法引用
    1. 4.1. 对象::实例对象
    2. 4.2. 类::实例对象
    3. 4.3. 对象::静态方法
    4. 4.4. 构造器引用
  5. 5. 变量作用域
  6. 6. 接口的静态方法

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

为什么要使用lambda表达式

从函数式接口说起

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

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

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

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

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

lambda表达式的语法糖

语法糖

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

public static List<String> compareTest1(){
    List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");
    wordList.sort(new Comparator<String>() {
        @Override
        public int compare(String w1, String w2) {
            return Integer.compare(w1.length(), w2.length());
        }
    });
    return wordList;        
}

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

public static List<String> compareTest2(){
    List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");
    wordList.sort((String w1, String w2) -> {
        return Integer.compare(w1.length(), w2.length());
    });
    return wordList;        
}

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

public static List<String> compareTest3(){
    List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");
    wordList.sort((w1, w2) -> {
        return Integer.compare(w1.length(), w2.length()); 
    });
    return wordList;        
}

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

public static List<String> compareTest4(){
    List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");
    wordList.sort((w1, w2) ->  Integer.compare(w1.length(), w2.length()));
    return wordList;        
}

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

public static List<String> compareTest5(){
    List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");
    wordList.forEach(word ->  System.out.println(word));
    return wordList;        
}

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

public static void runnableTest1(){
    Executors.newSingleThreadExecutor().execute(new Runnable() {    
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
            }
        }
    });    
}

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

public static void runnableTest2(){
    Executors.newSingleThreadExecutor().execute(() -> {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    });    
}

注意点

  • lambda表达式执行返回类型,会根据上下文推到出来,我们不需要设置它的返回类型。
  • lambda表达式中,只有某些分支中返回值,这样是错误的。

方法引用

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

对象::实例对象

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

public static void print1(){
    List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");
    wordList.forEach(new Consumer<String>() {
        @Override
        public void accept(String word) {
            System.out.println(word);
        }
    });    
}

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

public static void print2(){
    List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");
    wordList.forEach(word -> System.out.println(word));        
}

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

public static void print3(){
    List<String> wordList = Arrays.asList("lianggzone", "spring", "summer", "autumn", "winter");
    wordList.forEach(System.out::println);    
}

类::实例对象

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

public static String[] sort1(){
    String[] words = new String[]{"lianggzone", "spring", "summer", "autumn", "winter"};
    Arrays.sort(words, (x, y) -> x.compareToIgnoreCase(y));
    return words;
}

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

public static String[] sort2(){
    String[] words = new String[]{"lianggzone", "spring", "summer", "autumn", "winter"};
    Arrays.sort(words, String::compareToIgnoreCase);
    return words;
}

对象::静态方法

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

public static List<Integer> sortList1(){
    List<Integer> wordList = Arrays.asList(21, 53);
    wordList.sort((w1, w2) -> Integer.compare(w1, w2));
    return wordList;
}

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

public static List<Integer> sortList2(){
    List<Integer> wordList = Arrays.asList(21, 53);
    wordList.sort(Integer::compare);
    return wordList;
}

构造器引用

// lambda
words.stream().map(word -> {
    return new StringBuilder(word);
});
// constructor reference
words.stream().map(StringBuilder::new);

变量作用域

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

public static void effectivelyFinal(){
    int a = 100;
    Executors.newSingleThreadExecutor().execute(() -> {
        System.out.println(a);
    });    
}

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

接口的静态方法

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

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

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

public interface Function<T, R> {
  static <T> Function<T, T> identity() {
      return t -> t;
  }
}

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

public interface Path {
  public static Path get(String first, String... more) {
      return FileSystems.getDefault().getPath(first, more);
  }
}

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

(完)

微信公众号

文章目录

  1. 1. 为什么要使用lambda表达式
  2. 2. 从函数式接口说起
  3. 3. lambda表达式的语法糖
    1. 3.1. 语法糖
    2. 3.2. 注意点
  4. 4. 方法引用
    1. 4.1. 对象::实例对象
    2. 4.2. 类::实例对象
    3. 4.3. 对象::静态方法
    4. 4.4. 构造器引用
  5. 5. 变量作用域
  6. 6. 接口的静态方法