JAVA8 Lambda表达式到底优不优雅？
今天看到一个关注很久的公众号，作者是一个10年+的程序员，现在自主创业，他原文中是这么说的：多去看看外面的世界，不要把自己封闭在技术的圈子内，这对自己不管是创业还是挣钱，都有莫大的帮助；
个人虽然很同意他的说法，但是带来的问题就是你如何跻身于高端的，创业大佬的，技术大牛的圈子，人家张嘴就是技术潮流，闭嘴就是互联网一线信息，个人还是觉得踏实提升自己，对于投资自己的脑袋这件事深表认同。
目前JAVA版本每半年更新已到JAVA12了，虽然工作中用的是JDK1.8，但不用他的特性是不是有点浪费？针对各个版本的新特性，应该1.8是相当稳定，适用性最多，使用率最高的版本，毕竟新版本还有待市场考察。
那么JAVA8到底有多优雅呢？首先看下都有神马新特性
我们从代码角度体会下JAVA8的好处；
需求：设计接口实现对对象属性的过滤。
方案：除去SQL编写方式外，一般我们都会针对接口编程
公共属性：Employee
public class Employee {
private Integer id;
private Integer age;
private Integer salary;
private String name;
public Employee(Integer id, Integer age, Integer salary, String name) {
this.id = id;
this.age = age;
this.salary = salary;
this.name = name;
}
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", age=" + age +
", salary=" + salary +
", name='" + name + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Employee() {
}
public Employee(Integer id, Integer age, Integer salary) {
this.id = id;
this.age = age;
this.salary = salary;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Integer getSalary() {
return salary;
}
public void setSalary(Integer salary) {
this.salary = salary;
}
}
方案一：针对接口编程，定义接口，逻辑放在实现类
public interface MyProduce<T> {
boolean bySalary(Employee employee);
}public class MyProduceImpl implements MyProduce<Employee> {
@Override
public boolean bySalary(Employee employee) {
return employee.getSalary()>5000;
}
}public class TestJava8 {
List<Employee> employees= Arrays.asList(
new Employee(1,20,2000,"张三"),
new Employee(2,30,28000,"李四"),
new Employee(3,40,1000,"王五"),
new Employee(4,50,5000,"赵六")
);
}实现过滤工资小于5000的员工
public List<Employee> filterEmployee(List<Employee> list,MyProduce<Employee> mp) {
List<Employee> emps = new ArrayList<>();
for (Employee employee : list) {
if (employee.getSalary() < 5000) {
emps.add(employee);
}
}
return emps;
}@Test
public void test1(){
List<Employee> employees = filterEmployee(this.employees, new MyProduce<Employee>() {
@Override
public boolean bySalary(Employee employee) {
return employee.getSalary() <5000;
}
});
for (Employee employee : employees) {
System.out.println(employee);
}
}方案二：匿名内部类
@Test
public void test2(){
List<Employee> employee = filterEmployee(employees, new MyProduce<Employee>() {
@Override
public boolean bySalary(Employee employee) {
return employee.getSalary() < 5000;
}
});
for (Employee emp : employee) {
System.out.println(emp);
}
}方案三：Lambda表达式
@Test
public void test3(){
List<Employee> employees = filterEmployee(this.employees,(e)->e.getSalary()>5000);
employees.forEach(System.out::println);
}
方案四：Stream流，工资大于5000的前2位员工，打印出员工的名称，不需要任何接口
@Test
public void test4(){
employees.stream()
.filter((e)->e.getSalary()>=5000)
.limit(2)
.forEach(System.out::println);
employees.stream()
.map(Employee::getName)
.forEach(System.out::println);
}
省掉了各种过滤的接口，各种实现方法的调用，且流式调用，要多方便有多方便，要多简洁有多简洁。代码量更少，功能更强大
Lambda表达式
为什么使用 Lambda 表达式
Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
Lambda表达式的语法
Lambda 表达式在Java 8 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：
左侧：指定了 Lambda 表达式需要的参数列表
右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。
函数式接口：接口中只有一个抽象方法的接口，SAM类型的接口（Single Abstract Method）。定义了这种类型的接口，使得以其为参数的方法，可以在调用时，使用一个lambda表达式作为参数
语法格式：
1.0:无参数无返回值
() ->System.out.println("Hello")；
2.0：有一个参数无返回值
Consumer<String> con=(x)->System.out.println("x")；
3.0: 只一个参数无返回值，小括号可以省略不写
习惯上写小括号
4.0：多个参数，有返回值，Lambda体中有多条语句
Comparator<Integer> com=(x,y)->{
System.out.println("多条语句");
return Integer.compare(1,2);
};
5.0:多个参数，有返回值，Lambda体中有一条语句，return 和大括号都可以不写
6.0：Lambda参数列表的类型可以省略不写，JVM可通过向上下文推断数据类型
总结：左右遇一括号省，
左侧推断类型省，
@FunctionalInterface检查是否是函数式接口
1. 默认方法与静态方法并不影响函数式接口的契约，可以任意使用
2. 可以有 Object 中覆盖的方法，也就是 equals，toString，hashcode等方法。
JDK 8之前已有的函数式接口：
java.lang.Runnable
java.util.concurrent.Callable
java.util.Comparator
java.io.FileFilter
java.lang.reflect.InvocationHandler
import java.util.Objects;
/**
* Represents an operation that accepts a single input argument and returns no
* result. Unlike most other functional interfaces, {@code Consumer} is expected
* to operate via side-effects.
*
* <p>This is a <a href="package-summary.html">functional interface</a>
* whose functional method is {@link #accept(Object)}.
*
* @param <T> the type of the input to the operation
*
* @since 1.8
*/*表示接受单个输入参数，并返回无返回值。与大多数其他功能接口不同，需要@code consumer*通过副作用操作@FunctionalInterface
public interface Consumer<T> {}注意事项：
@Test
public void test5(){
int num=8;//????
Runnable r=new Runnable(){
@Override
public void run() {
System.out.println("Hello:"+"\t"+num);
}
};
r.run();
Runnable r1= ()-> System.out.println("HELLO:"+"\t"+num);
r1.run();
}在1.8以前局部内部类中应用了一个同级别的局部变量，他应该是final的
但是为什么java8不需要也能编译通过呢？其实底层他还是final的，我们验证一下
变量num是来自内部类，需要final或者实际上是final的，说明1.8进行了底层加final；
然后说下网上的关于java8 Lambda表达式的性能问题。搜索结果验证说用了Lambda反而性能下降了，执行foreach时间长了，特别是大数据遍历。还拿了并行代码对比，我觉得要看实际的用途，看看Lambda解决问题的侧重点，lambda写的好可以极大的减少代码冗余，同时可读性也好过冗长的内部类，匿名类。
本身就是侧重于减少代码冗余的，你非得谈性能？
6月最后一天啊，针对于年初计划，执行情况做一下小总结，年初定了年度计划目标，年中，年末做一个检查，5年后回味自己的今天，希望有质的提升
2019年6月30日：
1.今天是听得到APP历史记录1242条的一天。
2.今天是百词斩APP背单词累计的第394天，背单词数4866个
3.今天是一年写40篇文章计划的第26篇
好的今天记录就到这里。
