Java8新特性（一）Lambda表达式
Java8新特性（一）Lambda表达式
-
lambda出现的原因
-
减少代码量
-
避免匿名内部类参数之间的混淆
-
降低内存消耗，使用lambda表达式比使用匿名内部类或者子类的方式更加节省空间，主要原因还是因为java8后jvm结构发生了变化
-
举个栗子：过滤指定特征的苹果
//苹果实体类
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class Apple {
private String color;
private long weight;
}
//过滤苹果类
public class FilterApple {
//需求一：删选出指定颜色的苹果
public static List<Apple> findGreenApple(List<Apple> apples){
List<Apple> list = new ArrayList<>();
for (Apple apple : apples) {
if("green".equals(apple.getColor())){
list.add(apple);
}
}
return list;
}
//需求二：筛选出颜色为红色的苹果，更改策略，采用条件进行过滤
public static List findApple(List<Apple> apples,String color){
List<Apple> list = new ArrayList<>();
for (Apple apple : apples) {
if(color.equals(apple.getColor())){
list.add(apple);
}
}
return list;
}
//需求三：根据苹果的各种条件筛选，如颜色和重量，利用策略模式
public interface AppleFilter{
boolean filter(Apple apple);
}
public static List<Apple> findApple(List<Apple> apples,AppleFilter appleFilter){
List<Apple> list = new ArrayList<>();
for (Apple apple : apples) {
if(appleFilter.filter(apple)){
list.add(apple);
}
}
return list;
}
//利用各种各样的过滤器去过滤
public static class GreenAnd150Filter implements AppleFilter {
@Override
public boolean filter(Apple apple) {
return "green".equals(apple.getColor())&&apple.getWeight()>=160;
}
}
public static void main(String[] args) throws InterruptedException {
List<Apple> list = Arrays.asList(
Apple.builder().color("green").weight(150).build(),
Apple.builder().color("yellow").weight(120).build(),
Apple.builder().color("green").weight(180).build());
/**
//寻找绿色的苹果
List greenApple = findGreenApple(list);
assert greenApple.size() == 2 : "不符合预期"; //断言
for (Apple apple : greenApple) {
System.out.println(apple);
}
**/
/**
//传入一个条件
List greenApples = findApple(list,"green");
System.out.println(greenApples);
**/
/**
//传入一个过滤器
List result = findApple(list,new GreenAnd150Filter());
System.out.println(result);
**/
/**
//采用匿名内部类的方式
List yellowList = findApple(list, new AppleFilter() {
@Override
public boolean filter(Apple apple) {
return "yellow".equals(apple.getColor());
}
});
System.out.println(yellowList);
**/
}
}
//为什么匿名内部类参数容易混淆...
public class AnonymousInnerClass {
public final int value = 4;
public void doIt(){
int value = 6;
Runnable r = new Runnable() {
public final int value = 7;
@Override
public void run() {
int value = 8;
System.out.println(this.value);
}
};
r.run();
}
public static void main(String[] args) {
AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass();
anonymousInnerClass.doIt();
}
}
-
lambda表达式的简单使用
-
什么情况使用lambda表达式？
- 接口且接口中只含有一个方法
- default或静态方法除外
-
基于lambda表达式对以上栗子进行改进
-
java8中，如果一个接口只有一个方法，可视为一个FunctionInterface,表示它可以使用lambda进行操作。
List<Apple> lambdaResult = findApple(list, (Apple apple) -> { return apple.getColor().equals("green"); }); //上式可以简写，因为只有一个参数，它会推导它是apple类型的，只有一个参数，也可以把括号去掉 List<Apple> lambdaResult2 = findApple(list, (apple) -> { return apple.getColor().equals("green"); }); //扩展--lambda表达式需要满足的条件： //有且只有一个方法，default和static方法除外，它会在编译的时候判断，可以不标注它为FunctionalInterface,类似的有Runner
-
-
lambda表达式语法
-
语法：以(o1,o2) -> o1.getColor().compareTo(o2.getColor());为例，其中拆解为三部分：参数列表，箭头，lambda体，可泛化为以下格式
- （(parameters) -> expression
- (parameters) -> {statments;}
- ()->{}
-
where、how(如何使用，以及在哪里使用)
-
什么样的接口是FunctionalInterface?
- 只有一个抽象的方法，default和static方法除外（1.8新特性）
-
常见的可使用lambda的方法
//传入一个参数，判断其是否满足条件或其他 Predicate boolean test(T t); //消费，处理 Consumer void accept(T t); //传入一个T类型参数，返回一个R类型的，两者可以相同 Function<T,R> R apply(T t); //提供一个参数，只是get一个东西 Supplier<T> T get();
-
-
几个简单的lambda栗子
public class LambdaExpression { public interface Test{ public String fun(); } public static void main(String[] args) { //1.定义比较器，传入比较器进行比较 Comparator<Apple> byColor = new Comparator<Apple>() { @Override public int compare(Apple o1, Apple o2) { return o1.getColor().compareTo(o2.getColor()); } }; List<Apple> list = Collections.emptyList(); list.sort(byColor); //引入lambda表达式优化 //类型推导，可以不用写return Comparator<Apple> byColor2 = (o1,o2)->o1.getColor().compareTo(o2.getColor()); list.sort(byColor2); //可以写return, =(o1,o2) -> {return o1.getColor().compareTo(o2.getColor());}; //2.lambda表达式举例：(String s) -> s.length();返回类型：Function Function<String, Integer> flambda = s -> s.length(); System.out.println(flambda.apply("hello")); //5 //3.Predicate使用示例：(Apple a) -> a.getColor().equals("green");返回类型：Predicate Predicate<Apple> appleFilter = a -> a.getColor().equals("green"); } } -
lambda表达式的详细使用
-
通过栗子了解lambda表达式的使用
public class LambdaUsage { @FunctionalInterface public interface Adder{ int add(int a,int b); }; //@FunctionalInterface,不是，处理有父类的add抽象方法外，还有自己的重载的add方法实现 public interface SmartAdder extends Adder{ int add(long a,long b); }; @FunctionalInterface public interface Empty extends Adder{ } @FunctionalInterface public interface DefaultAddr extends Adder{ default int otherAddr(int a,int b){ return a+b; } } public static void main(String[] args) { //1.lambda表达式替代匿名内部类 WhereToUsage(); //通过栗子了解Predicate的用法：过滤指定颜色和重量的苹果 List<Apple> greenList = filter(list, apple -> apple.getColor().equals("green")); System.out.println(greenList); //2.除Predicate之外，还有细化的Predicate，如 // BiPredicate(void accept(T t);) //BiConsumer -
lambda表达式之类型推导、方法引用、方法推导、组合lambda表达式
public class MethodReference { public static void main(String[] args) { //以下三种效果相同 Consumer<String> consumer = (s) -> System.out.println(s); useConsumber(consumer,"Hello World !"); useConsumber(s -> System.out.println(s),"Hello World"); useConsumber(System.out::println,"Hello World"); //排序，通过color的ascii码 List<Apple> list = Arrays.asList(new Apple("Green",110), new Apple("Red",123), new Apple("Yellow",180)); System.out.println(list); //sort方法底层：@FunctionalInterface public interface Comparator{ boolean equals(Object obj);} list.sort((a1,a2) ->{ return a1.getColor().compareTo(a2.getColor());}); list.sort((a1,a2)->a1.getColor().compareTo(a2.getColor())); list.stream().forEach(a->System.out.println(a)); list.stream().forEach(System.out::println); //什么时候需要函数推导 list.stream().forEach(a -> System.out.println(a)); //循环遍历，将list中数据比遍历出来 list.stream().forEach(System.out::println); //循环遍历，将list中数据比遍历出来 //双冒号运算操作符是类方法的句柄,是lambda表达式的一种简写 /** * x -> System.out.println(x) 简化为 System.out::println 的过程称之为 eta-conversion * System.out::println 简化为 x -> System.out.println(x) 的过程称之为 eta-expansion * 举例： * person -> person.getAge();可以替换为Person::getAge * x -> System.out.println(x)可以替换成System.out::println * */ /*BiFunction: T get(); one parameter Supplier<String> supplier = String::new; String s = supplier.get(); System.out.println(s); //two parameters BiFunction<String,Long,Apple> appleBiFunction = Apple::new; Apple apple = appleBiFunction.apply("Red", 120l); System.out.println(apple); //three parameters ThreeFunction<String,String,Long,ComplexApple> appleThreeFunction = ComplexApple::new; ComplexApple complexApple = appleThreeFunction.apply("Red", "苹果", 120L); System.out.println(complexApple); List<Apple> list2 = Arrays.asList(new Apple("Green",110), new Apple("Red",123), new Apple("Yellow",180)); list2.sort(Comparator.comparing(Apple::getColor)); } private class test{ public int getNumber(int n){ return n+1; } } private static void testFunction(String str,Function<String,Integer> function){ function.apply(str); } private static <T> void useConsumber(Consumer<T> consumer,T t){ consumer.accept(t); consumer.accept(t); } } @FunctionalInterface public interface ThreeFunction<T,U,K,R>{ R apply(T t,U u,K k); } -
源码放在这儿