Lambda表达式方法推导

╰半夏微凉° 2022-12-22 08:42 164阅读 0赞

## 1.在学习之前，让我们了解推导是什么？ ##

//定义一个map
    Map<String,Integer> map = new HashMap<String,Integer>(); 
    
    //通过推导的方式，定义一个map
    Map<String,Integer> map = new HashMap<>();

编译器会根据变量声明时的泛型类型**自动推导**出实例化HashMap时的泛型类型。

## 2.Lambda表达式方法推导 ##

通过举几个小例子，了解下Lambda表达式方法几种推导方式。

public class LambdaExpression { 
        public static void main(String[] args) { 
    		
    		//1.打印小明
    		//1.1定义consumer方式
            Consumer<String> consumer = s -> System.out.println( s);
            myConsumer(consumer, "XiaoMing");
            
            //1.2直接Lambda
            myConsumer(s -> System.out.println(s), "XiaoMing");
    		
    		//1.3推导的方式
            myConsumer(System.out::println, "XiaoMing");
    
            //2.静态方法的推导
            Function<String, Integer> f = Integer::parseInt;
            Integer result = f.apply("123");
    
            BiFunction<String, Integer, Character> biF = String::charAt;
            Character c = biF.apply("hello", 2);
    
            //3.对象方法的推导
            String str = new String("hello");
            Function<Integer, Character> f3 = str::charAt;
            Character c2 = f3.apply(4);
    
            //4.构造函数的推导
            Supplier<String> supplier = String::new;
            String s = supplier.get();
            System.out.println(s);
    
            BiFunction<Long, String, Apple> appleBiFunction = Apple::new;
            Apple apple = appleBiFunction.apply(1000L,"read");
            //如果要求new要求传入三个参数怎么办？BiFunction满足不了，我们可以自定义一个
            @FunctionalInterface
    		public interface BiFunction<T, U, S, R> { 
    		    R apply(T var1, U var2, S var3);
    		
    	    //5.匿名内部内，Lambda及Lambda推导方式比较
    	    List<Apple> apples = Arrays.asList(new Apple(120, "green"),
                    new Apple(110, "yellow"),
                    new Apple(160, "green"),
                    new Apple(140, "red"));
    
            apples.stream().forEach(System.out::println);
            
            apples.sort(new Comparator<Apple>() { 
                @Override
                public int compare(Apple a1, Apple a2) { 
                    return a1.getColor().compareTo(a2.getColor());
                }
            });
            apples.sort((a1, a2) -> a1.getColor().compareTo(a2.getColor()));
            apples.sort(Comparator.comparing(Apple::getColor));
        }
    
    
        private static <T> void myConsumer(Consumer<T> consumer, T t){ 
            consumer.accept(t);
        }
    }