优雅解析民族代码java_JDK8漫谈——代码更优雅

简介

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 {

/**

* Performs this operation on the given argument.

*

* @param t the input argument

*/

void accept(T t);

}

常见的内置函数如下：

name

function

java.lang.Runnable

执行动作

java.util.function.Predicate

接收T对象并返回boolean

java.util.function.Consumer

接收T对象，不返回值

java.util.function.Function

接收T对象，返回R对象

java.util.function.Supplier

提供T对象(例如工厂)，不接收值

方法引用

方法引用有很多种，它们的语法如下：

静态方法引用：ClassName::methodName

实例上的实例方法引用：instanceReference::methodName

超类上的实例方法引用：super::methodName

类型上的实例方法引用：ClassName::methodName

构造方法引用：Class::new

数组构造方法引用：TypeName[]::new

@Test

public void test_instance(){

Set girls = new HashSet<>();

Set names = new HashSet<>();

names.stream()

//实例::methodName

.filter(girls::contains)

.collect(Collectors.toList());

}

@Test

public void test_this(){

Set names = new HashSet<>();

names.stream()

//this::methodName

.filter(this::hasAuth)

.collect(Collectors.toList());

}

private boolean hasAuth(String authKey){

return true;

}

类型推断

Map 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 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 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 = WapperUtils.wapper(this::getPerson);

Assert.assertNotNull(person);

CnResult animal = WapperUtils.wapper(this::getAnimal);

Assert.assertNotNull(animal);

}

public class WapperUtils {

private static final Logger logger = LoggerFactory.getLogger(WapperUtils.class);

/**

* 包裹

*

* @param supplier

* @param

* @return

*/

public static CnResult wapper(Supplier supplier){

try {

T entity = supplier.get();

CnResult 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 persons = new ArrayList<>();

persons.stream()

/**

* 没有明确的语义。需要根据过程计算推理得出结果，也不清楚背后的业务和场景

*

*/

.filter(person -> person.getAge() >= 18)

.collect(Collectors.toList());

}

@Test

public void test_second() {

List 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 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 persons = new ArrayList<>();

persons.stream()

/**

* 随着业务变更需要不断添加filter

*/

.filter(Person::isAdult)

.filter(Person::belongToZhuang)

.collect(Collectors.toList());

}

@Test

public void test_final() {

List persons = new ArrayList<>();

/**

* 有明确的语义，不用再面向细节加工一下，而且也方便后面的扩展

*/

persons.stream()

.filter(Person::hasAuth)

.collect(Collectors.toList());

}

最佳反例

随意取名

@Test

public void test_name_bad(){

List 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 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 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 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的区别