JDK8漫谈——代码更优雅

发布日期:2019-09-27

简介

lambda表达式,又称闭包(Closure)或称匿名方法(anonymous method)。将Lambda表达式引入JAVA中的动机源于一个叫“行为参数”的模式。这种模式能够解决需求变化带来的问题,使代码变得更加灵活。在JAVA8之前,参数模式十分啰嗦。Lambda表达式通过精简的方式使用行为模式克服了这个缺点

解决什么问题

传递行为。它允许我们将函数当成参数传递给某个方法,或者把代码本身当作数据处理,变成了一等公民。解决重复的代码片段代码包裹问题。内置抽象行为。把常见的行为定义成接口,可以直接使用,减少重复思考和代码。都在java.util.function包里更少的代码。通过类型推断,方法引用,可以让代码更优雅。

背后思想

函数式编程

内容说明

作用域

this

在内部类中,this指向当前内部类对象自己,而在lambda表达式中,this指向的是表达式外部的类对象。

public class ScopeTest { @Test public void test_scope(){ Runnable runnable = () -> { this.print(); }; runnable.run(); } private void print(){ System.out.println("I can print"); }}

final

labmda表达式使用外部的变量时,不可修改,默认定义成final

函数式接口

只有一个抽象方法的接口我们就称之为功能性接口,又简称 SAM 类型,即 Simple Abstract Method。会写上注释

@FunctionalInterface //用这个注解来表示功能性接口public interface Consumer<T> { /** * Performs this operation on the given argument. * * @param t the input argument */ void accept(T t);}

常见的内置函数如下:

namefunction
java.lang.Runnable执行动作
java.util.function.Predicate <T>接收T对象并返回boolean
java.util.function.Consumer<T>接收T对象,不返回值
java.util.function.Function<T,R>接收T对象,返回R对象
java.util.function.Supplier<T>提供T对象(例如工厂),不接收值

方法引用

方法引用有很多种,它们的语法如下:

静态方法引用:ClassName::methodName实例上的实例方法引用:instanceReference::methodName超类上的实例方法引用:super::methodName类型上的实例方法引用:ClassName::methodName构造方法引用:Class::new数组构造方法引用:TypeName[]::new

@Test public void test_instance(){ Set<String> girls = new HashSet<>(); Set<String> names = new HashSet<>(); names.stream() //实例::methodName .filter(girls::contains) .collect(Collectors.toList()); } @Test public void test_this(){ Set<String> names = new HashSet<>(); names.stream() //this::methodName .filter(this::hasAuth) .collect(Collectors.toList()); } private boolean hasAuth(String authKey){ return true; }

类型推断

Map<String,Person> map = new HashMap<>(); map.forEach((String name,Person person)->{ person.fly(); System.out.println(name+":"+person); }); map.forEach((name,person)->{ // 无须判断类型,自动根据上下文推断 person.fly(); System.out.println(name+":"+person); });

实践

最佳实践

消灭代码片段

/** * 正常的代码 */ @Test public void test_person(){ CnResult<Person> result = null; try { // 只有这里取值是不同的,其他的处理是一样的,包括try,catch,打日志,定义异常等 Person entity = this.getPerson(); result = CnResult.success(entity); }catch (CnException e){ logger.error(e.getMessage(),e); result = CnResult.error(e.getErrorCode(),e.getMessage()); } catch (Exception e) { logger.error(e.getMessage(),e); result = CnResult.error("1-1-1-1",e.getMessage()); } Assert.assertNotNull(result); } @Test public void test_animal(){ CnResult<Animal> result = null; try { // 只有这里取值是不同的,其他的处理是一样的,包括try,catch,打日志,定义异常等 Animal entity = this.getAnimal(); result = CnResult.success(entity); }catch (CnException e){ logger.error(e.getMessage(),e); result = CnResult.error(e.getErrorCode(),e.getMessage()); } catch (Exception e) { logger.error(e.getMessage(),e); result = CnResult.error("1-1-1-1",e.getMessage()); } Assert.assertNotNull(result); }

/** * lambda代码 */ @Test public void test_lambda(){ //屏蔽所有细节,只把获取对象的逻辑传递进去 CnResult<Person> person = WapperUtils.wapper(this::getPerson); Assert.assertNotNull(person); CnResult<Animal> animal = WapperUtils.wapper(this::getAnimal); Assert.assertNotNull(animal); } public class WapperUtils { private static final Logger logger = LoggerFactory.getLogger(WapperUtils.class); /** * 包裹 * * @param supplier * @param <T> * @return */ public static <T> CnResult<T> wapper(Supplier<T> supplier){ try { T entity = supplier.get(); CnResult<T> cnResult = CnResult.success(entity); return cnResult; }catch (CnException e){ logger.error(e.getMessage(),e); return CnResult.error(e.getErrorCode(),e.getMessage()); } catch (Exception e) { logger.error(e.getMessage(),e); return CnResult.error("1-1-1-1",e.getMessage()); } } }只要是代码片段,找到变点化,抽象成lambda,把固定的代码统一封装,就可以使用行为的复用,减少代码片段和代码包裹。

明确语义

@Test public void test_first() { List<Person> persons = new ArrayList<>(); persons.stream() /** * 没有明确的语义。需要根据过程计算推理得出结果,也不清楚背后的业务和场景 * */ .filter(person -> person.getAge() >= 18) .collect(Collectors.toList()); } @Test public void test_second() { List<Person> persons = new ArrayList<>(); persons.stream() .filter(person -> { /** * 如果职责变更,得修改代码结构,而且代码越来越难理解 */ if (person.getAge() >= 18) { return true; } if (person.getName().startsWith("庄")) { return true; } return false; }) .collect(Collectors.toList()); } @Test public void test_third() { List<Person> persons = new ArrayList<>(); persons.stream() /** * 随着业务变更需要不断添加filter */ .filter(person -> person.getAge() >= 18) .filter(person -> person.getName().startsWith("庄")) .collect(Collectors.toList()); } @Test public void test_fourth() { List<Person> persons = new ArrayList<>(); persons.stream() /** * 随着业务变更需要不断添加filter */ .filter(Person::isAdult) .filter(Person::belongToZhuang) .collect(Collectors.toList()); } @Test public void test_final() { List<Person> persons = new ArrayList<>(); /** * 有明确的语义,不用再面向细节加工一下,而且也方便后面的扩展 */ persons.stream() .filter(Person::hasAuth) .collect(Collectors.toList()); }

最佳反例

随意取名

@Test public void test_name_bad(){ List<Person> persons = new ArrayList<>(); /** * lambda一多的时候,没有明确的参数,计算和理解起来非常吃力。 */ persons.stream() .filter(e->e.getAge()>18) .map(e->e.getName()) .filter(e->e.startsWith("庄")) .collect(Collectors.toList()); } @Test public void test_name(){ List<Person> persons = new ArrayList<>(); persons.stream() .filter(person->person.getAge()>18) .map(person->person.getName()) .filter(name->name.startsWith("庄")) .collect(Collectors.toList()); }参数需要有明确语义

逻辑复杂

@Test public void test_bad() { List<Integer> values = new ArrayList<>(); int result = values.stream().mapToInt(e -> { int sum = 0; for (int i = 0; i < e; i++) { if (e % i == 0) { sum += i; } } return sum; }).sum(); System.out.println(result); } @Test public void test_() { List<Integer> values = new ArrayList<>(); int result = values.stream().mapToInt(this::toInt).sum(); System.out.println(result); } private Integer toInt(int e) { int sum = 0; for (int i = 0; i < e; i++) { if (e % i == 0) { sum += i; } } return sum; }难以读懂用途不明难以测试难以复用

建议把多行lambda表达式主体转移到一个命名函数中,然后使用方法引用

思考

和内部类的区别和AOP的区别