使用Lambda可以简化开发，提高效率，先通过案例1入门Lambda，案例1还有策略设计模式的介绍
案例1:
相关JavaBean,熟悉一下之后直接看单元测试快速入门
实体:Emp.java
package cn.wcj.jdk8.lambda.test;
//实体
public class Emp {
private String empno ;
private String ename ;
private Double salary ;
private Integer age ;
public Emp() {}
public Emp(String empno, String ename, Double salary, Integer age) {
this.empno = empno;
this.ename = ename;
this.salary = salary;
this.age = age;
}
public String getEmpno() {
return empno;
}
public void setEmpno(String empno) {
this.empno = empno;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Emp [empno=" + empno + ", ename=" + ename + ", salary=" + salary + ", age=" + age + "]";
}
}
策略设计模式的接口:MyPredicate.java
package cn.wcj.jdk8.lambda.test;
//策略设计模式
public interface MyPredicate<T> {
boolean filter(T entity) ; //过滤方法
}
MyPredicate接口的实现类,按照年龄过滤：FilterEmpByAge .java
package cn.wcj.jdk8.lambda.test;
public class FilterEmpByAge implements MyPredicate<Emp> {
@Override
public boolean filter(Emp entity) {
return entity.getAge()<35;
}
}
MyPredicate接口的实现类,按照工资过滤：FilterEmpBySalary .java
package cn.wcj.jdk8.lambda.test;
public class FilterEmpBySalary implements MyPredicate<Emp> {
@Override
public boolean filter(Emp entity) {
return entity.getSalary()>5000 ;
}
}单元测试，使用以上JavaBean来完成JDK8语法讲解
package cn.wcj.jdk8.lambda.test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
import org.junit.Test;
import static org.junit.Assert.* ;
/**
*
* <p>Title:LambdaTest1 </p>
* <p>Description: Lambda表达式学习</p>
* <p>Company:Software College </p>
* @author SuccessKey(WangCJ)
* @date 2017年6月17日 上午10:37:38
*/
@SuppressWarnings("unused")
public class LambdaTest1 {
@Test
public void test1() {
Comparator<String> comparator = new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return Integer.compare(o1.length(), o2.length()) ;
}
};
TreeSet<String> treeSet = new TreeSet<String>(comparator) ;
TreeSet<String> treeSet2 = new TreeSet<String>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return Integer.compare(o1.length(), o2.length()) ;
}
}) ;
}
//现在使用Lambda表达式
@Test
public void test2() {
Comparator<String> comparator=(x,y)->Integer.compare(x.length(), y.length()) ;
TreeSet<String> treeSet = new TreeSet<String>(comparator) ;
}
List<Emp> emps=new ArrayList<Emp>(
Arrays.asList(
new Emp("3333", "张三", 3333.33, 31),
new Emp("4444", "李四", 4444.44, 41),
new Emp("5555", "王五", 5555.55, 51),
new Emp("6666", "赵六", 6666.66, 61),
new Emp("7777", "田七", 7777.77, 71)
)
);
//需求：获取公司中年龄小于 35 的员工信息
public List<Emp> filterEmpByAge(List<Emp> emps){
List<Emp> result=new ArrayList<Emp>() ;
for (Emp emp : emps)
if(emp.getAge()<35) result.add(emp) ;
return result ;
}
@Test
public void test3() {
List<Emp> result=filterEmpByAge(emps) ;
for (Emp emp : result) {
System.out.println(emp);
}
}
//需求：获取公司中工资大于 5000 的员工信息
public List<Emp> filterEmpBySalary(List<Emp> emps){
List<Emp> result=new ArrayList<Emp>() ;
for (Emp emp : emps)
if(emp.getSalary()>5000) result.add(emp) ;
return result ;
}
@Test
public void test4() {
List<Emp> result=filterEmpBySalary(emps) ;
for (Emp emp : result) {
System.out.println(emp);
}
}
//优化1:策略设计模式
public List<Emp> filterEmp(List<Emp> emps,MyPredicate<Emp> myPredicate){
List<Emp> result=new ArrayList<Emp>() ;
for (Emp emp : emps)
if(myPredicate.filter(emp)) result.add(emp) ;
return result ;
}
@Test
public void test5() {
List<Emp> result=filterEmp(emps,new FilterEmpByAge()) ;
for (Emp emp : result) {
System.out.println(emp);
}
System.out.println("-----------------------------------");
List<Emp> result2=filterEmp(emps,new FilterEmpBySalary()) ;
for (Emp emp : result2) {
System.out.println(emp);
}
}
//优化2：匿名内部类
@Test
public void test6() {
List<Emp> result=filterEmp(emps,new MyPredicate<Emp>() {
@Override
public boolean filter(Emp entity) {
return entity.getAge()>50 && entity.getSalary()>6000;
}
}) ;
for (Emp emp : result) {
System.out.println(emp);
}
}
//优化3：Lambda 表达式
@Test
public void test7() {
List<Emp> result=filterEmp(emps,(e)->e.getAge()<35) ;
result.forEach(System.out::println);
System.out.println("----------------------------");
List<Emp> result2=filterEmp(emps,(e)->e.getSalary()>5000) ;
result2.forEach(System.out::println);
}
//优化4:Stream API
@Test
public void test8() {
emps.stream()
.filter((e)->e.getAge()<35)
.forEach(System.out::println) ;
System.out.println("---------------------------------------") ;
emps.stream()
.filter((e)->e.getSalary()>5000)
.limit(2)
.map(Emp::getSalary)
.sorted()
.forEach(System.out::println);
}
}
案例2:介绍Lambda表达式的基础语法，所有总结在单元测试上
函数式接口，看后面单元测试的注释和方法就会明白，暂时不明白没关系
package cn.wcj.jdk8.lambda.test;
/**
*
* <p>Title:MyFun </p>
* <p>Description: 函数式接口</p>
* <p>Company:Software College </p>
* @author SuccessKey(WangCJ)
* @date 2017年6月17日 下午9:10:21
*/
@FunctionalInterface
public interface MyFun<T> {
T getVal(T target) ;
}package cn.wcj.jdk8.lambda.test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import org.junit.Test;
/*
* 一、Lambda 表达式的基础语法：Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符或 Lambda 操作符
* 箭头操作符将 Lambda 表达式拆分成两部分：
*
* 左侧：Lambda 表达式的参数列表
* 右侧：Lambda 表达式中所需执行的功能， 即 Lambda 体
*
* 语法格式一：无参数，无返回值
* () -> System.out.println("Hello Lambda!");
*
* 语法格式二：有一个参数，并且无返回值
* (x) -> System.out.println(x)
*
* 语法格式三：若只有一个参数，小括号可以省略不写
* x -> System.out.println(x)
*
* 语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句
* Comparator<Integer> com = (x, y) -> {
* System.out.println("函数式接口");
* return Integer.compare(x, y);
* };
*
* 语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写
* Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
*
* 语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
* (Integer x, Integer y) -> Integer.compare(x, y);
*
* 上联：左右遇一括号省
* 下联：左侧推断类型省
* 横批：能省则省
*
* 二、Lambda 表达式需要“函数式接口”的支持
* 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。 可以使用注解 @FunctionalInterface 修饰
* 可以检查是否是函数式接口
*/
public class LambdaTest2 {
@Test
public void test1() {
int num =1 ; //jdk7必须加final
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("HelloWorld!!! "+num);
}
};
new Thread(runnable).start();
Runnable runnable2=()->System.out.println("HelloLambda!!! "+num);
new Thread(runnable2).start() ;
}
@Test
public void test2() {
//Consumer<String> consumer=(msg)->System.out.println("msg:"+msg);
Consumer<String> consumer=msg->System.out.println("msg:"+msg);
consumer.accept("我大软院威武！！！");
}
@Test
public void test3() {
Comparator<Integer> comparator=(x,y)->{
System.out.println("函数式接口") ;
return Integer.compare(x, y) ;
} ;
}
@Test
public void test4() {
Comparator<Integer> comparator=(x,y)->Integer.compare(x, y) ;
}
@Test
public void test5() {
//String[] strs= {"a","b","c"} ;
// String[] strs ;
// strs= new String[]{"a","b","c"} ;
List<String> list=new ArrayList<>() ;
show(new HashMap<>()); //jdk7不支持
}
public void show(Map<String, Integer> map){}
public Integer operator(Integer num,MyFun<Integer> myFun) {
return myFun.getVal(num) ;
}
@Test
public void test6() {
Integer result = operator(100,(x)->x*x) ;
System.out.println("result:"+result) ;
System.out.println("------------------------------") ;
System.out.println("result:"+operator(1000, x->x+888));
}
}
