JDK8的新特性

最新推荐文章于 2024-11-10 08:43:33 发布

吾欲静

最新推荐文章于 2024-11-10 08:43:33 发布

阅读量69

点赞数

文章标签： java servlet jvm

本文链接：https://blog.csdn.net/m0_69715573/article/details/125967993

版权

本文深入探讨了Java中的Lambda表达式和函数式接口，展示了如何使用Lambda简化匿名内部类的代码，以及如何通过方法引用进一步减少冗余。通过示例解释了Comparator接口在排序中的应用，并介绍了常见的函数式接口如Consumer、Supplier和Function。同时，文章还提到了方法引用的概念，包括实例方法引用，强调其在避免重复代码上的作用。

摘要由CSDN通过智能技术生成

lambda表达式

概念:

语法:

注意: 函数式接口:接口中只有一个抽象方法。

(参数1，参数2): 抽象方法的参数

->: 分隔符

{}：表示抽象方法的实现

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

        //该构造方法需要传递一个线程任务对象。Runnable类型
        My task=new My();
        Thread t1=new Thread(task);
        t1.start();


        //匿名内部类
        Runnable task02=new Runnable() {
            @Override
            public void run() {
                System.out.println("这时匿名内部类方式的任务对象");
            }
        };
        Thread t2=new Thread(task02);
        t2.start();
    }
}
class My implements Runnable{

    @Override
    public void run() {
        System.out.println("自定义任务接口类");
    }
}

分析代码:

Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心

为了指定 run 的方法体，不得不需要 Runnable 接口的实现类

为了省去定义一个 Runnable 实现类的麻烦，不得不使用匿名内部类

必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错

而实际上，似乎只有方法体才是关键所在。

这时可以使用lambda表示完成上面的要求。

//lambda表达式
Runnable task03 = ()-> {
System.out.println("这是使用Lambda表达式完成的");
};

Thread t3=new Thread(task03);
t3.start();

前提:必须是函数式接口。

简化匿名内部类的使用，语法更加简单。

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

        //匿名内部类
        Swimmable swimmable=new Swimmable() {
            @Override
            public void swimming() {
                System.out.println("这时使用匿名内部类的方式");
            }
        };
        fun(swimmable);

        //lambda表达式
//        Swimmable swimmable1=()->{
//            System.out.println("使用lambda表达式");
//        };
        fun(()->{System.out.println("使用lambda表达式");});
    }

   public static void fun(Swimmable w){
        w.swimming();
   }
}
//函数式接口
interface Swimmable{
    public void swimming();
}

练习有参数有返回值的Lambda

下面举例演示 java.util.Comparator 接口的使用场景代码，其中的抽象方法定义为：

public abstract int compare(T o1, T o2);

当需要对一个对象集合进行排序时， Collections.sort 方法需要一个 Comparator 接口实例来指定排序的规则。

public class Test03 {
public static void main(String[] args) {
List<Person> personList=new ArrayList<>();
personList.add(new Person("刘德华",50,175));
personList.add(new Person("张学友",55,178));
personList.add(new Person("杨紫琼",45,170));
personList.add(new Person("闫克起",18,185));

//对集合中的元素进行排序按照年龄从大到小。
//传统做法:Comparator: 排序规则接口
// Comparator<Person> comparator = new Comparator<Person>() {
// //int: 0表示新加的元素和集合中原来的比对的相同
// //1: o2比o1小
// //-1: o2比o1大
// @Override
// public int compare(Person o1, Person o2) {
// return o2.getAge()-o1.getAge();
// }
// };
// Collections.sort(personList,comparator);
//
// for (Person p:personList){
// System.out.println(p);
// }

System.out.println("===============================lambda===========================");

Comparator<Person> comparator1 = (Person o1, Person o2)->{
return o1.getAge()-o2.getAge();
};
Collections.sort(personList,comparator1);
for (Person p : personList) {
System.out.println(p);
}
}
}
class Person {
private String name;
private int age;
private int height;

@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}

public Person(String name, int age, int height) {
this.name = name;
this.age = age;
this.height = height;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public int getHeight() {
return height;
}

public void setHeight(int height) {
this.height = height;
}
}

详细介绍lambda表达式

函数式接口

内置函数式接口的由来

public class Test03 {

public static void main(String[] args) {
Operater o=arr -> {
int sum=0;
for(int n:arr){
sum+=n;
}
System.out.println("数组的和为:"+sum);
};

fun(o);
}

public static void fun(Operater operater){
int[] arr={2,3,4,5,6,7,11};
operater.getSum(arr);
}

}
@FunctionalInterface
interface Operater{
//求数组的和
public abstract void getSum(int[] arr);
}

分析

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

常见得函数式接口

java.util.function保存

Consumer<T>

有参数，无返回值。

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

Consumer<Double> c= t->{
System.out.println("洗脚花费了:"+t);
};

fun01(c,200);
}

//调用某个方法时，该方法需要的参数为接口类型，这时就应该能想到使用lambda
public static void fun01(Consumer<Double> consumer,double money){
consumer.accept(money);
}
}

Supplier<T>供给型函数式接口

T:表示返回结果的泛型

无参，想有返回结果的函数式接口时

T get();

public class Test02 {
    public static void main(String[] args) {
        //Supplier<Integer> supplier=()->new Random().nextInt(10);

        fun(()->new Random().nextInt(10));
    }

    public static void fun(Supplier<Integer> supplier){
        Integer result = supplier.get();
        System.out.println("内容为："+result);
    }
}

Function<T,R> 函数型函数式接口

T: 参数类型的泛型

R: 函数返回结果的泛型

有参，有返回值时。

例子: 传入一个字符串把小写转换为大写。

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

fun((t)->{
return t.toUpperCase();

},"hello world");
}

//传入一个字符串，返回字符串的长度。

public static void fun(Function<String,String> function,String msg){
String s = function.apply(msg);

System.out.println("结果为:"+s);
}
}

Predicated<T>

T: 参数的泛型

boolean test(T t);

当传入一个参数时，需要对该参数进行判断时，则需要这种函数。

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

        fun(n->{
            return n.length()>3?true:false;
        },"栗毅");

    }
    public static void  fun(Predicate<String> predicate,String name ){
        boolean b = predicate.test(name);

        System.out.println("该名称的长度是否长啊:"+b);
    }
}

方法引用。

1 lambda表达式的冗余

public class Test01 {

    public static void main(String[] args) {
        Consumer<Integer[]> c=arr->{
             int sum=0;
             for(int b:arr){
                 sum+=b;
             }
            System.out.println("数组的和为:"+sum);
        };
        fun(c);
    }


    public static void fun(Consumer<Integer[]>  consumer){
          Integer[] arr={1,2,3,4,5};
          consumer.accept(arr);
    }

    public static void sum(Integer[] arr){
          int sum=0;
          for (int a:arr){
              sum+=a;
          }
        System.out.println("数组的和为:"+sum);
    }

}

分析:

如果我们在Lambda中所指定的功能，已经有其他方法存在相同方案，那是否还有必要再写重复逻辑？可以直接“引用”过去就好了：---方法引用。

public class Test01 {

public static void main(String[] args) {

Consumer<Integer[]> c=Test01::sum;

fun(c);
}

public static void fun(Consumer<Integer[]> consumer){
Integer[] arr={1,2,3,4,5};
consumer.accept(arr);
}

public static void sum(Integer[] arr){
int sum=0;
for (int a:arr){
sum+=a;
}
System.out.println("数组的和为:"+sum);
}

}

请注意其中的双冒号 :: 写法，这被称为“方法引用”，是一种新的语法。