JDK新特性01-Lambda表达式、常用函数式接口

1、Lambda表达式

1.1、格式组成：

（参数类型 参数名称）->{
代码体;
}

说明：

• （参数类型 参数名称）：参数列表
• {代码体；}：方法体
• ->:箭头，分割参数列表和方法体

1.2、使用：

1.2.1、无参无返回：

定义接口：

public interface UserService {
    void show();
}

主线程：

public static void main(String[] args) {
        getShow(new UserService() {
            @Override
            public void show() {
                System.out.println("show方法执行了。。。");
            }
        });
        getShow(()->{
            System.out.println("lambda表达式执行show方法");
        });
    }
    public static void getShow(UserService userService){
        userService.show();
    }

1.2.2 有参有返回

public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("张三",33,175));
        users.add(new User("李四",30,170));
        users.add(new User("王五",23,168));
        users.add(new User("六六",26,198));
//       Collections.sort(users, new Comparator<User>() {
//            @Override
//            public int compare(User o1, User o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        });
//        for (User user : users) {
//            System.out.println(user);
//        }

        System.out.println("---------lambda表达式");
        Collections.sort(users,(User o1,User o2)->{
            return o1.getAge()-o2.getAge();
        });
        for (User user : users) {
            System.out.println(user);
        }
    }

1.3 省略写法：

规则：

• 小括号内的参数类型可以省略
• 如果小括号内有且仅有一个参数，则小括号可以省略
• 如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号

eg:

public static void main(String[] args) {
        goStudent((String name, Integer age) -> {
            return name + "ppp" + age;
        });
        System.out.println("----省略格式");
        goStudent((name, age) -> name + "ppp" + age);
        System.out.println("-------------");
        goOrder((String name)->{
            System.out.println("李四6666");
            return 666;
        });
        System.out.println("省略写法");
        goOrder((name)->666);
    }
    public static void goStudent(StudentService service){
        service.show("张三",22);
    }
    public static void goOrder(OrderService service){
        service.show("李四");
    }

1.4 原理：

Lambda表达式在程序运行的时候会形成一个类，这个类中新增了一个方法，该方法的方法体就是Lambda表达式中的代码，同时还会形成一个匿名内部类，实现接口，重写抽象方法，在接口中重写方法会调用新生成的方法。

1.5 与匿名函数的区别

1、所需类型不一样

• 匿名内部类的类型可以是类，抽象类,接口.
• Lambda表达式需要的类型必须是接口

2、抽象方法的数量不一样

• 匿名内部类所需的接口中的抽象方法的数量是随意的
• Lambda表达式所需的接口中只能有一个抽象方法

3、实现原理不一样

• 匿名内部类是在编译后形成一个class
• Lambda表达式是在程序运行的时候动态生成class

2、新增接口方法

2.1、新增前后区别:

jdk8之前：

interface 接口名{
静态常量;
抽象方法;
}

jdk8之后

interface 接口名{
静态常量;
抽象方法;
默认方法;
静态方法;
}

2.2 默认方法的增加

1 、 增加原因：

jdk8之前的接口只有抽象方法和静态常量，会存在一些问题，当想要增加新的抽象方法的时候，实现类需要实现这个接口的所有方法，不利于接口的拓展。

2、接口默认的语法格式：

interface 接口名{
修饰符 default 返回值类型 方法名{
方法体;
}
}

3、接口中默认方法的使用

两种方式：
1、实现类直接调用接口的默认方法

2、实现类重写接口 的默认方法

2.3、静态方法

语法规则：

interface 接口名{
修饰符 static 返回值类型 方法名{
方法体;
}
}

2.4、两者区别

1、默认方法可以通过实例调用，静态方法通过接口名调用

2、默认方法可以被继承，实现类可以直接调用接口默认方法，也可以重写接口默认方法‘’‘

3、静态方法不能被继承，实现类不能重写接口的静态方法 ，只能使用接口名调用

3、四大常用函数式接口

1、Supplier接口：

Supplier函数式接口是Java 8中的一个内置接口，它表示一个供应商，用于提供一个结果。Supplier函数式接口没有任何入参，只负责返回一个结果。Supplier接口只包含一个方法get()，该方法不接收任何参数，返回一个泛型T的结果。

源代码：

public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

Supplier函数式接口可以被用于许多场景，例如在需要创建一个对象时，可以使用Supplier来提供一个工厂方法，以便在需要时生成对象。另外，当需要延迟计算某个结果时，也可以使用Supplier来实现懒加载。eg：

public class SupplierTest {
    public static void main(String[] args) {
        fun(()->{
            int [] arr = {1,2,32,43,12,4,3,89};
            Arrays.sort(arr);
            return arr[arr.length-1];
        });
    }
    public static void fun(Supplier<Integer> supplier){
        // get()是一个无参有返回值的抽象方法
        Integer max = supplier.get();
        System.out.println("最大值是"+max);
    }
}

这里定义了一个fun()方法，这个方法接收了一个Supplier类型的参数，然后输出该参数提供的最大值，其实我们也可以直接使用Lambda表达式或者方法来创建。如下：

int[] arr = {1,2,32,43,12,4,3,89};
Supplier<Integer> supplier = () -> Arrays.stream(arr).max().orElse(0);
int max = supplier.get();
System.out.println("数组最大值是：" + max);

其中的orElse（0）的意思是如果数组为空就返回0

2、Consumer接口

Consumer接口是Java 8中的一个函数式接口，它定义了一个接受一个参数并且不返回任何结果的函数。。它有一个抽象方法void accept(T t)，表示对给定的参数执行操作。

源代码：

public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}

Consumer接口通常用于需要对某些对象执行操作而不需要返回值的场合，比如对集合中的元素进行遍历并执行某些操作。eg：将所定义的字符串转换为小写

public class ConsumerTest {
    public static void main(String[] args) {
        fun((msg)->{
            System.out.println(msg.toLowerCase(Locale.ROOT));
        });
    }

    public static void fun(Consumer<String> consumer){
        consumer.accept("HELLO WORLD!!!");
    }
}

直接使用lambda表达式：（遍历数组）

List<String> names = Arrays.asList("Tom", "Jerry", "Mickey");
Consumer<String> printName = name -> System.out.println(name);
names.forEach(printName);

Consumer接口中还有一个默认方法andThen（），该方法接受一个Consumer类型的参数，返回一个新的Consumer类型对象，该对象将当前Consumer对象的操作和传入的Consumer对象的操作连续执行。简单的来说就是先做一个操作，再做一个操作，实现组合。

Consumer<String> printUpperCase = str -> 
				System.out.println(str.toUpperCase());
Consumer<String> printLowerCase = str ->
			    System.out.println(str.toLowerCase());

Consumer<String> printBoth = printUpperCase.andThen(printLowerCase);

printBoth.accept("Hello World"); // 输出 "HELLO WORLD" 和 "hello world"

这里定义了两个Consumer对象，一个用于打印大写的字符串，一个用于打印小写的字符串，用andThen连接起来，得到一个新的Consumer对象，然后先执行大写的，在执行小写的。

3、Funtion

有参有返回值，这个接口是根据一个类型的数据再得到另外一个类型的数据，前者称为前置条件，后者称为后置条件 ，源代码：

public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

其中，T表示函数的输入参数类型，R表示函数的返回值类型。apply()方法接收一个T类型的参数并返回一个R类型的值，表示该函数的行为或功能。eg:

ist<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Function<Integer, Integer> square = x -> x * x;
List<Integer> squares = numbers.stream().map(square).collect(Collectors.toList());

这里是把一个数组集合里面 的每个对象映射为平方，然后将所有得到的数据收集成一个数组。

该接口还有两个默认方法和一个静态方法 ：

静态方法：
identify():返回一个恒等函数，即接收一个参数并返回该参数本身。
默认方法：
andThen():与Consumer里面的使用方法一样
compose():与andThen()一样，只是顺序相反

4、Predicate

有参返回布尔值，源代码：

public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
 }

Predicate接口可以用于函数式编程中的过滤器、映射等场景，可以用于对集合中的元素进行筛选、过滤或转换操作。例如，可以使用Predicate接口的实现来过滤出符合某些条件的元素，或者将一个集合中的元素进行转换后再进行某些操作。eg: 这里是对数据做了一个筛选，只留下了以字母a开头的元素。

 List<String> list = Arrays.asList("apple", "banana", "orange", "pear");
Predicate<String> startsWithA = str -> str.startsWith("a");
List<String> filteredList=list.stream()
							.filter(startsWithA)
							.collect(Collectors.toList());

该接口有着三个默认方法和一个静态方法：
默认方法是and()、nagate()、or(),举个简单的例子：

public class PredicateTest2 {
    public static void main(String[] args) {
        fun(msg->{
            return msg.contains("h");
        },msg2->{
            return msg2.contains("w");
        });
    }
    public static void fun(Predicate<String> p1,Predicate<String> p2){

            // p1 包含H 同时 p2包含w
        System.out.println(p1.and(p2).test("hello w"));
        // p1 包含H 或者 p2包含w
        System.out.println(p1.or(p2).test("hello"));
        // p1不包含H
        System.out.println(p1.negate().test("hello"));
    }
}

静态方法是isEqual()，它的作用是根据对象的equals方法比较两个对象是否相等。如果两个对象相等，则返回true，否则返回false。