jdk8新特性

2023-09-24 20:42:15

Lambda表达式。

概念

Lambda表达式: 特殊的匿名内部类，语法更加简洁
Lambda表达式允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递

需求

1、开启一个线程。并执行一个Runnable类型的任务。

public class Test01 {
    public static void main(String[] args) {
        //匿名内部类
        Runnable tast1=new Runnable() {
            public void run() {
                System.out.println("这是使用匿名内部类"+Thread.currentThread().getName());
            }
        };
        new Thread(tast1).start();

        System.out.println("主线程的内容:"+Thread.currentThread().getName());
    }
}

分析代码:

1. Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
2. 为了指定run方法体，不得不需要Runnable的实现类
3. 为了省去定义一个Runnable 的实现类，不得不使用匿名内部类
4. 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错，
5. 而实际上，我们只在乎方法体中的代码

使用Lambda表达式来解决这个问题.

初体验Lambda表达式

https://blog.csdn.net/wo541075754/article/details/82119860

lambda就是匿名内部类的一种简写版，语法更加简洁。

Runnable tast2=()->{
    System.out.println("这是使用lambda表达式:"+Thread.currentThread().getName());
};
new Thread(tast2).start();

lambda的语法

lambda表达式它由三部分组成

(数据类型 变量名,数据类型 变量名)->{方法体}

格式说明：

 (参数类型 参数名称):参数列表
 {代码体;} :方法体
 -> : 箭头，分割参数列表和方法体

Lambda练习1

练习无参无返回值的Lambda

public class Test02 {
    public static void goShow(UserService userService){
         userService.show();
    }

  public static void main(String[] args) {
        //1.自己创建一个UserService接口的实现类。并创建该类的对象。
        UserService userService=new UserServiceImpl();
        goShow(userService);
        //2.使用匿名内部类
        UserService userService1=new UserService() {
            @Override
            public void show() {
                System.out.println("这是UserService的匿名实现类");
            }
        };
        goShow(userService1);

        //3.使用lambda表达式
        UserService userService2=()->{
            System.out.println("这是lambda表达式");
        };
        goShow(userService2);
    }
}
interface UserService{
     public void show();
}
class UserServiceImpl implements UserService{

    @Override
    public void show() {
        System.out.println("这是UserService实现方法");
    }
}

Lambda练习2

完成一个有参且有返回值得Lambda表达式案例.

创建一个People对象

@Data
@NoArgsConstructor
@AllArgsConstructor
class People{
     private String name;
     private int age;
}
测试
public class Test03 {
     public static void main(String[] args) {
          List<People> list=new ArrayList<People>();
          list.add(new People("程",15));
          list.add(new People("张",17));
          list.add(new People("赵",16));
          list.add(new People("王",26));

          //按照年龄进行排序。第二个参数需要传递排序规则
//          Comparator<People> comparator=new Comparator<People>() {
//               public int compare(People o1, People o2) {
//                    return o1.getAge()-o2.getAge();
//               }
//          };
//          Collections.sort(list,comparator);
//          System.out.println(list);

          System.out.println("=============================================");
          Comparator<People> comparator1=(People o1,People o2)->{return o2.getAge()-o1.getAge();};
          Collections.sort(list,comparator1);
          System.out.println(list);
     }
}
结果
[People(name=王, age=26), People(name=张, age=17), People(name=赵, age=16), People(name=程, age=15)]

lambda表达式的缩写版

在lambda表达式的标准写法基础上，可以使用省略写法的规则为：

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

public class Test03 {
    public static void main(String[] args) {
//        UserService userService=(String name,int age)->{return name+"~~~~~"+age;};
        UserService userService=(name, age)-> name+"~~~~~"+age       ;//可以省略lambda表达式参数的类型,以及{}和return 和分号；
        goUserService(userService);

//        StudentService studentService=(name)->{ System.out.println("我叫:"+name);};
//        StudentService studentService= name->{ System.out.println("我叫:"+name);}; //int a=15;
        goStudentService(name->{ System.out.println("我叫:"+name);});
    }
    public static void goStudentService(StudentService studentService){
        studentService.print("罗");
    }
    public static void goUserService(UserService userService){//1.方法的参数必须是一个接口类型。 2.该接口有且只有一个抽象方法。
        String s = userService.show("褚", 15);
        System.out.println(s);
    }
}
@FunctionalInterface
interface UserService{ //为了防止别人往该接口中添加新的抽象方法，可以使用一个注解FunctionInterface。
    public String show(String name,int age);
    default void fun(){};
}
interface  StudentService{
    public void print(String name);
}

lambda表达式使用的前提

Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意

方法的参数或局部变量类型必须为接口才能使用Lambda
接口中有且仅有一个抽象方法(@FunctionalInterface)

jdk1.8后接口中新增了那些成员

jdk1.8以前

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

jdk1.8以后

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

默认方法

格式:

修饰符 default 返回类型 方法名(){}

为什么接口中新增默认方法。

在JDK8以前接口中只能有抽象方法和静态常量，会存在以下的问题：

如果接口中新增抽象方法，那么实现类都必须重写这个抽象方法，非常不利于接口的扩展的

public interface Usb {
    public static final String n="";
    public abstract void fun();
    //如果接口中新增一个方法，那么它的所有实现类都必须重写该方法，不利于接口的扩展。
    public abstract  void print();

}
class Upan implements  Usb{

    @Override
    public void fun() {
        System.out.println("upan重写了fun方法");
    }

    @Override
    public void print() {

    }
}
class Mouse implements  Usb{

    @Override
    public void fun() {
        System.out.println("鼠标重写了fun方法");
    }

    @Override
    public void print() {

    }
}

静态方法

为了接口的扩展。

格式:

修饰符 static 返回类型 方法名(){}

public interface Usb {
    public static final String n="";
    public abstract void fun();
    //如果接口中新增一个方法，那么它的所有实现类都必须重写该方法，不利于接口的扩展。
    public abstract  void print();

    public default void haha(){ //默认方法可以被重写。只可以通过对象调用
        System.out.println("我是哈哈");
    }

    public static void hehe(){ //静态的方法不能被重写 只可以通过接口名调用。
        System.out.println("这是接口中的静态方法hehe");
    }

}

## 静态方法的使用

接口中的静态方法在实现类中是不能被重写的，调用的话只能通过接口类型来实现: 接口名.静态方法名();

## 两者的区别介绍
1. 默认方法通过实例调用，静态方法通过接口名调用
2. 默认方法可以被继承，实现类可以直接调用接口默认方法，也可以重写接口默认方法
3. 静态方法不能被继承，实现类不能重写接口的静态方法，只能使用接口名调用

#  函数式接口

 我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加的方便，在JDK中提供了大量常用的函数式接口。

```java
public class Test {
    public static void main(String[] args) {
        //求数组种所有数据的和。
        int[] a1={1,2,3,4};
        My my=arr -> {
             int sum=0;
            for (int i = 0; i <arr.length ; i++) {
                 sum+=arr[i];
            }
            return sum;
        };
        fun(my,a1);
    }
    public static void fun(My my,int[] a1){

         int b=my.sum(a1);
         System.out.println("数组a1种所有元素的和:"+b);
    }
}
//因为每个人定义函数式接口的名字不统一，而且方法名也不统一。
interface My{
     public int sum(int[] arr);
}

jdk提供的函数式接口 java.util.function包下。

Consumer 消费型函数式接口有参无返回值

void accept(T t);

Function 函数型函数式接口有参有返回值

R apply(T t);

Supplier 供给型函数式接口无参有返回值

T get();

Predicate 断言型函数式接口有参返回值为boolean.

boolean test(T t);

Supplier

无参有返回值的接口，对于的Lambda表达式需要提供一个返回数据的类型。

@FunctionalInterface
public interface Supplier<T> {

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

使用：

/**
 * Supplier 函数式接口的使用
 */
public class SupplierTest {

    public static void main(String[] args) {
        fun1(()->{
            int arr[] = {22,33,55,66,44,99,10};
            // 计算出数组中的最大值
            Arrays.sort(arr);
            return arr[arr.length-1];
        });
    }

    private static void fun1(Supplier<Integer> supplier){
        // get() 是一个无参的有返回值的 抽象方法
        Integer max = supplier.get();
        System.out.println("max = " + max);

    }
}

Consumer

有参无返回值得接口,前面介绍的Supplier接口是用来生产数据的，而Consumer接口是用来消费数据的，使用的时候需要指定一个泛型来定义参数类型

@FunctionalInterface
public interface Consumer<T> {

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

使用：将输入的数据统一转换为小写输出

public class ConsumerTest {

    public static void main(String[] args) {
        test(msg -> {
            System.out.println(msg + "-> 转换为小写：" + msg.toLowerCase());
        });
    }

    public static void test(Consumer<String> consumer){
        consumer.accept("Hello World");
    }
}

默认方法:andThen

如果一个方法的参数和返回值全部是Consumer类型，那么就可以实现效果，消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口中的default方法 andThen方法

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }

具体的操作

public class ConsumerAndThenTest {

    public static void main(String[] args) {
        test2(msg1->{
            System.out.println(msg1 + "-> 转换为小写：" + msg1.toLowerCase());
        },msg2->{
            System.out.println(msg2 + "-> 转换为大写：" + msg2.toUpperCase());
        });
    }


    public static void test2(Consumer<String> c1,Consumer<String> c2){
        String str = "Hello World";
        //c1.accept(str); // 转小写
        //c2.accept(str); // 转大写
        //c1.andThen(c2).accept(str);
        c2.andThen(c1).accept(str);
    }
}

Function

有参有返回值的接口，Function接口是根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。

@FunctionalInterface
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);
}

使用：传递进入一个字符串返回一个数字

public class FunctionTest {

    public static void main(String[] args) {
        test(msg ->{
            return Integer.parseInt(msg);
        });
    }

    public static void test(Function<String,Integer> function){
        Integer apply = function.apply("666");
        System.out.println("apply = " + apply);
    }
}

默认方法：andThen，也是用来进行组合操作，

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

public class FunctionAndThenTest {

    public static void main(String[] args) {
        test(msg ->{
            return Integer.parseInt(msg);
        },msg2->{
            return msg2 * 10;
        });
    }

    public static void test(Function<String,Integer> f1,Function<Integer,Integer> f2){
        /*Integer i1 = f1.apply("666");
        Integer i2 = f2.apply(i1);*/
        Integer i2 = f1.andThen(f2).apply("666");
        System.out.println("i2:" + i2);

    }
}

默认的compose方法的作用顺序和andThen方法刚好相反

而静态方法identity则是，输入什么参数就返回什么参数

Predicate

有参且返回值为Boolean的接口

@FunctionalInterface
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);
}

使用

public class PredicateTest {

    public static void main(String[] args) {
        test(msg -> {
            return msg.length() > 3;
        },"HelloWorld");
    }

    private static void test(Predicate<String> predicate,String msg){
        boolean b = predicate.test(msg);
        System.out.println("b:" + b);
    }
}

在Predicate中的默认方法提供了逻辑关系操作 and or negate isEquals方法


import java.util.function.Predicate;

public class PredicateDefaultTest {

    public static void main(String[] args) {
        test(msg1 -> {
            return msg1.contains("H");
        },msg2 -> {
            return msg2.contains("W");
        });
    }

    private static void test(Predicate<String> p1,Predicate<String> p2){
        /*boolean b1 = predicate.test(msg);
        boolean b2 = predicate.test("Hello");*/
        // b1 包含H b2 包含W
        // p1 包含H 同时 p2 包含W
        boolean bb1 = p1.and(p2).test("Hello");
        // p1 包含H 或者 p2 包含W
        boolean bb2 = p1.or(p2).test("Hello");
        // p1 不包含H
        boolean bb3 = p1.negate().test("Hello");
        System.out.println(bb1); // FALSE
        System.out.println(bb2); // TRUE
        System.out.println(bb3); // FALSE
    }
}

https://www.cnblogs.com/JunkingBoy/p/15050206.html

码农公寓