lambda函数表达

lambda函数表达：

package com.msb;

public class LambdaTest {
    public static void main(String[] args) {
        //接口对象指向实现类，多态
        Factory factory = new Sub();
        User user =(User) factory.getObject();
        System.out.println(user);
        //接口的对象new 接口类生成匿名内部类
        factory = new Factory() {
            @Override
            public Object getObject() {
                 return new User(1,"小明");
            }

        };
        User user1 =(User) factory.getObject();
        System.out.println(user1);
        //lambda是依托匿名内部类的实现
        factory = ()->{
                return new User(2,"大明白");
            };
        User user2 = (User) factory.getObject();
        System.out.println(user2);
    }
}

使用lambda的规则（comparator内部比较器的使用）

import java.awt.event.ContainerAdapter;
import java.nio.channels.GatheringByteChannel;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Locale;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class ImathOperationImpl implements ImathOperation{

    public static void main(String[] args) {

        //方法一，Lambda常规表达试--对实现类的改写
        ImathOperation operation = (Integer a, Integer b)->{
            return a+b;
        };
        System.out.println("a+b："+operation.operation(2, 5));
        //方法二，省略大括号，当返回值简单时
        ImathOperation operation1 = (a,b)-> a*b;
        System.out.println("a*b："+operation1.operation(2,4));

        //使用Supplier返回最大值
        int arr[] ={1,3,4,5,6,78,99};
        int max= getMax(()-> {
            int temp = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (temp < arr[i]) {
                    temp = arr[i];
                }
            }
            return temp;
        });
        System.out.println(max);

        //使用consumer输出字符串
        consumerString(s ->
            System.out.println(s));
        //使用两个消费者的方法
        consumerAccept(
                s-> System.out.println(s.toUpperCase(Locale.ROOT)),
                s -> System.out.println(s.toLowerCase(Locale.ROOT))
                );
        //内部比较器--new对象的接口生成匿名内部类
        //方法一
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        };
        String arrs []={"app","so","develop","summary"};
        Arrays.sort(arrs,comparator);
        System.out.println(Arrays.toString(arrs));
        //方法二
        /*使用lambda表达式*/
        String arrays []= {"1","11","111","1111","1111"};
        Arrays.sort(arrays,(o1, o2)->o1.length()-o2.length());
        System.out.println(Arrays.toString(arrays));

    }

    //void accept(T t);
    static void consumerString(Consumer<String> function){
        function.accept("Welcome");
    }
    //return (T t) -> { accept(t); after.accept(t); };
    static void consumerAccept(Consumer<String>first,Consumer<String>second){
        first.andThen(second).accept("hello");
    }

    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
    @Override
    public Integer operation(Integer a, Integer b) {
        return null;
    }
}

Function的具体返回写入介绍

import java.awt.*;
import java.sql.SQLOutput;
import java.util.function.Function;

public class LambdaDemo1 {
    public static void main(String[] args) {

       method(

                s -> Integer.parseInt(s)+10,

                s -> s*=10
        );
       //传入3个方法函数的lambda
        String str = "周全,27";
       int age =  getAgeNumber(str,
                s ->s.split(",")[1],
                s ->Integer.parseInt(s),
                s ->s-=10
               );
        System.out.println(age);
    }
    /**
     *
     * @param one <String,Integer>传入的是String类型，得到的是Integer
     * @param two <Integer,Integer>传入的是Integer类型，得到的是Integer
     */
    public static void method(Function<String,Integer>one,Function<Integer,Integer>two){
        //传入字符串，返回整形，将one的值给到two
        int num = one.andThen(two).apply("10");

        System.out.println(num+20);
    };

    public static int getAgeNumber(String str, Function<String,String>one,
    Function<String,Integer>two,Function<Integer,Integer>three){
        return one.andThen(two).andThen(three).apply(str);
    }
}

对方法的调用

接口

import com.msb.Persion;

@FunctionalInterface
public interface persion {
    Persion buliderPersion(String name);
}

实现

import com.msb.Persion;

import javax.print.attribute.standard.PrinterName;

public class PersionImpl {
    public static void printName(String name,persion bp){
        Persion persion = bp.buliderPersion(name);
        System.out.println(persion.getName());
    }

    public static void main(String[] args) {
        printName("花花",name->new Persion(name));

        printName("古力",Persion::new);
    }

}