侧边栏壁纸
博主头像
孔子说JAVA博主等级

成功只是一只沦落在鸡窝里的鹰,成功永远属于自信且有毅力的人!

  • 累计撰写 292 篇文章
  • 累计创建 132 个标签
  • 累计收到 4 条评论

目 录CONTENT

文章目录

java8新特性Lambda表达式使用方法详解

孔子说JAVA
2022-07-05 / 0 评论 / 0 点赞 / 58 阅读 / 14,345 字 / 正在检测是否收录...

Java8引入的 Lambda 表达式也称为闭包,是推动Java8发布的最重要的新特性。Lambda 是一个匿名函数,主要作用就是简化部分匿名内部类的写法。我们可以把 Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用 Lambda表达式可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,它使Java的语言表达能力得到了提升。

a5fcfb1055a1bc13d3a5d171171f6379

1、Lambda新特性简介

Java8中引入了一个新的操作符,“->”,该操作符称为箭头操作符或者Lambda操作符,箭头操作符将Lambda表达式拆分成两部分;

  • 左侧: Lambda表达式的参数列表,对应的是接口中抽象方法的参数列表;
  • 右侧: Lambda表达式中所需要执行的功能(Lambda体),对应的是对抽象方法的实现;
  • Lambda表达式的实质是对接口的实现,能够使用 Lambda 表达式的一个重要依据是必须有相应的函数接口(lambda表达式必须和接口进行绑定);
  • 所谓函数式接口(function interface),是指内部有且仅有一个抽象方法的接口。
  • Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。
  • Lambda 表达式有一个类型推断机制,在上下文信息足够的情况下,编译器可以推断出参数表的类型,而不需要显式指定。

1.1 Lambda语法

lambda 表达式的语法格式如下:

(parameters) -> expression
或
(parameters) ->{ statements; }

分情况语法示范:

(1)语法格式一:无参,无返回值,Lambda 体只需一条语句
  示例:Runnable r1 = () -> System.out.println("Hello Lambda!");

(2)语法格式二:Lambda 需要一个参数 
  示例:Consumer<String> con = (x) -> System.out.println(x);

(3)语法格式三:Lambda 只需要一个参数时,参数的小括号可以省略 
  示例:Consumer<String> con = x -> System.out.println(x);

(4)语法格式四:Lambda 需要两个参数,并且有返回值 
  示例:
 Comparator<Integer> com = (x, y) -> {
   System.out.println("函数式接口");
   return Integer.compare(x, y);
 };

(5)语法格式五:当 Lambda 体只有一条语句时,return 与大括号可以省略 
  示例:Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

(6)Lambda 表达式的参数列表的数据类型可以省略不写,因为JVM编译器通过上下文推断出,数据类型,即“类型推断”
  示例:
Comparator<Integer> com = (Integer x,Integer y) -> {  //Integer 类型可以省略
   System.out.println("函数式接口");
   return Integer.compare(x, y);
 };

根据上述语法可知,组成Lambda表达式的三要素:形式参数,箭头,代码块:

  • ① 格式:(形式参数) -> {代码块}。
  • ② 形式参数:如果有多个参数,参数之间用逗号隔开;如果没有参数,留空即可。
  • ③ ->:由英文中划线和大于符号组成,固定写法。代表指向动作。
  • ④ 代码块:是我们具体要做的事情,也就是我们写的方法体内容。

语法看起来很简答,其实就是通过箭头表达式替代匿名内部类。以下是lambda表达式的重要特征:

  1. 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值 parameters。
  2. 可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。
  3. 可选的大括号:如果主体只包含一条语句,就不需要使用大括号。
  4. 可选的返回关键字:如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定表达式返回了一个数值。

1.2 Lambda的优点

使用 Lambda 表达式可以使代码变的更加简洁紧凑。以下简单列了一下它的优点:

  1. 速度更快
  2. 代码更少(增加了新的语法Lambda表达式)
  3. 强大的Stream API
  4. 便于并行
  5. 最大化减少空指针异常Optional
  6. 类型推断:Lambda 表达式中的参数类型都是由编译器推断得出的。

Lambda 表达式中无需指定类型,程序依然可以编译,这是因为 javac 根据程序的上下文,在后台推断出了参数的类型。 Lambda 表达式的类型依赖于上下文环境,是由编译器推断出来的。这就是所谓的 “类型推断”

1.3 Lambda简单实例

为了更直观的看到Lambda的写法,我们列出几个Lambda 表达式的简单示例:

// 1. 不需要参数,返回值为 5。
// 无参数时不可省略参数的括号
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值。
// 一个参数,可省略参数外的括号
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值
// 多个参数,不可省略参数的括号
// 如果只有一个语句,也可省略return关键字
// 参数类型可省略,根据要实现的接口的方法能推导出来
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和
// 单条语句,可省略语句的大括号
// 如果只有一个语句,也可省略return关键字
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
// 单条语句,可省略语句的大括号
(String s) -> System.out.print(s)
  
// 6. 多条语句,语句需要加大括号
() -> {
        System.out.println("lambda1");
        System.out.println("lambda2");
     };

根据示例可以得出如下结论:

  • 无参数或多个参数时不可省略参数的括号。
  • 一个参数,可省略参数外的括号。
  • 参数类型可省略,可以根据要实现的接口的方法推导出来。
  • 如果只有一个语句,也可省略return关键字。
  • 参数体为单条语句时,可省略语句的大括号。多条语句时需要参数体需要加大括号。

2、实现类、匿名类到Lambda的转换实例

以下是分别使用实现类,匿名类,Lambda实现一个多线程的例子,它们的表示方式虽然不同,但最终效果是相同的。

2.1 方式1:实现类

定义一个类MyRunnable实现Runnable接口,重写run()方法。

//创建MyRunnable类的对象
class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("多线程程序启动了...");
    }
}

public class LambdaDemo {
    public static void main(String[] args) {
        //实现类的方式实现需求
        MyRunnable my = new MyRunnable();
        //创建Thread类的对象,把MyRunnable的对象作为构造参数传递
        Thread t = new Thread(my);
        //启动线程
        t.start();
    }
}

2.2 方式2:匿名内部类

以下是使用匿名内部类对上述实现类的方式进行了改进,可以看到代码简洁了很多。我们只需要关注接口的run方法实现。

public class LambdaDemo {
    public static void main(String[] args) {
        //匿名内部类的方式改进
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程程序启动了...");
            }
        }).start();
    }
}

2.3 方式3:Lambda表达式

本例中对匿名内部类的方式进行了改进,使用了Lambda表达式,代码结构更加清晰,关注点进一步明确,我们甚至都不需要知道接口的方法申明,只需要关注方法体的实现,即我们的业务逻辑代码。

public class LambdaDemo {
    public static void main(String[] args) {
        //Lambda表达式方式改进
        new Thread(() -> {
            System.out.println("多线程程序启动了...");
        }).start();
    }
}

Lambda表达式中的代码解析:

  1. ():里面没有内容,可以看成是方法形式参数为空
  2. ->:用箭头指向后面要做的事情
  3. { }:包含一段代码,我们称之为代码块,可以看成是方法体中的内容

3、自定义接口使用Lambda的实例

Lambda表达式的使用前提:

  • ① 有一个接口。
  • ② 接口中有且仅有一个抽象方法。

根据上述约束,我们自定义一个仅有一个抽象方法的接口。

public interface Eatable {
    void eat();
}

3.1 方式1:实现类

class EatableImpl implements Eatable{
    @Override
    public void eat() {
        System.out.println("一天一苹果,医生远离我");
    }
}

public class EatableDemo {
    public static void main(String[] args) {
        // 调用useEatable方法
        Eatable e = new EatableImpl();
        useEatable(e);
	}
    private static void useEatable(Eatable e){
        e.eat();
    }
}

3.2 方式2:匿名内部类

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

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果,医生远离我");
            }
        });
    }

    private static void useEatable(Eatable e){
        e.eat();
    }
}

3.3 方式3:Lambda表达式

public class EatableDemo {
    public static void main(String[] args) {
        //用Lambda表达式
        useEatable(() -> {
            System.out.println("一天一苹果,医生远离我");
        });
    }

    private static void useEatable(Eatable e){
        e.eat();
    }
}

4、函数式接口

只包含一个抽象方法的接口,称为函数式接口。可以通过 Lambda 表达式来创建该接口的对象。

4.1 自定义函数接口

我们可以在任意函数式接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口,同时 javadoc 也会包含一条声明,说明这个接口是一个函数式接口。

@FunctionalInterface
Public interface MyNumber{
    public double getValue();
}

// 函数式接口中使用泛型
@FunctionalInterface
Public interface MyFun<T>{
    public T getValue(T t);
}

4.2 作为参数传递的Lambda表达式

作为参数传递 Lambda 表达式:为了将 Lambda 表达式作为参数传递,接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。

public String toUpperString(MyFun<String> mf, String str){
    return mf.getValue(str);
}
  
// 作为参数传递Lambda表达式:
String newStr = toUpperString(
(str) - > str.toUpperCase(), “abcdef”);
System.out.println(newStr);

4.3 Java 内置四大核心函数式接口

Java8中的java.util.function包中提供了一些常用的函数式功能接口。

4.3.1 消费型接口 Consumer<T>

对类型为T的对象应用操作,包含方法 void accept(T t),参数类型为T,返回类型为void,示例如下:

// Consumer<T> 消费型接口 :
@Test
public void test1(){
  happy(10000, (m) -> System.out.println("每次消费:" + m + "元"));
}

public void happy(double money, Consumer<Double> con){
  con.accept(money);
}

4.3.2 供给型接口 Supplier<T>

返回类型为T的对象,包含方法 T get(),无参数,返回类型为T,示例如下:

//Supplier<T> 供给型接口 :
@Test
public void test2(){
  List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
  for (Integer num : numList) {
   System.out.println(num);
  }
}

//需求:产生指定个数的整数,并放入集合中
public List<Integer> getNumList(int num, Supplier<Integer> sup){
  List<Integer> list = new ArrayList<>();
  for (int i = 0; i < num; i++) {
   Integer n = sup.get();
   list.add(n);
  }   
  return list;
}

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

对类型为T的对象应用操作并返回结果。结果是R类型的对象。包含方法 R apply(T t),参数类型为T,返回类型为R,示例如下:

//Function<T, R> 函数型接口:
@Test
public void test3(){
  String newStr = strHandler("\t\t\t 我大尚硅谷威武 ", (str) -> str.trim());
  System.out.println(newStr);
  String subStr = strHandler("我大尚硅谷威武", (str) -> str.substring(2, 5));
  System.out.println(subStr);
}

//需求:用于处理字符串
public String strHandler(String str, Function<String, String> fun){
  return fun.apply(str);
}

4.3.4 断言型接口 Predicate<T>

确定类型为T的对象是否满足某约束,并返回boolean值。包含方法 boolean test(T t),参数类型为T,返回类型为布尔值,示例如下:

//Predicate<T> 断言型接口:
@Test
public void test4(){
  List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
  List<String> strList = filterStr(list, (s) -> s.length() > 3);
  for (String str : strList) {
   System.out.println(str);
  }
}

//需求:将满足条件的字符串,放入集合中
public List<String> filterStr(List<String> list, Predicate<String> pre){
  List<String> strList = new ArrayList<>();
  for (String str : list) {
   if(pre.test(str)){
    strList.add(str);
   }
  }
  return strList;
}

4.3.5 其他接口

image-1656987758713

5、Lambda表达式和匿名内部类的区别

5.1 所需类型不同

  • ① 匿名内部类:可以是接口,也可以是抽象类,还可以是具体类
  • ② Lambda表达式:只能是接口
abstract class Animal {
    public abstract void method();
}
class Student {
    public void study(){
        System.out.println("爱生活,爱java");
    }
}

public class LambdaDemo{
    public static void main(String[] args) {
        /*//匿名内部类
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("接口");
            }
        });

        useAnimal(new Animal() {
            @Override
            public void method() {
                System.out.println("抽象类");
            }
        });

        useStudent(new Student(){
            @Override
            public void study(){
                System.out.println("具体类");
            }
        });*/

        //Lambda
        useInter(() -> System.out.println("接口"));
        //useAnimal(() -> System.out.println("抽象类"));//不可以
        //useStudent(() -> System.out.println("具体类"));//不可以
    }
    private static void useStudent(Student s){
        s.study();
    }
    private static void useAnimal(Animal a){
        a.method();
    }
    private static void useInter(Inter i){
        i.show();
    }
}

5.2 使用限制不同

  • ① 如果接口中有且仅有一个抽象方法,可以使用Lambda表达式,也可以使用匿名内部类
  • ② 如果接口中多于一个抽象方法,只能使用匿名内部类,而不能使用Lambda表达式
public interface Inter{
    void show();
    void show1();
}

public class LambdaDemo{
    public static void main(String[] args) {
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("show"); // 只打印这一个show
            }
            @Override
            public void show1() {
                System.out.println("show");
            }
        });
    }

    private static void useInter(Inter i){
        i.show();
    }
}

5.3 实现原理不同

  • ① 匿名内部类:编译之后,产生一个单独的.class字节码文件
  • ② Lambda表达式:编译之后,没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

6、方法引用和构造器引用

6.1 方法引用

当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用!

  • (实现抽象方法的参数列表,必须与方法引用方法的参数列表保持一致! )
  • 方法引用:使用操作符 “::” 将方法名和对象或类的名字分隔开来。
  • 方法引用格式: ClassName::MethodName

注意:

  • 方法引用所引用的方法的参数列表与返回值类型,需要与函数式接口中抽象方法的参数列表和返回值类型保持一致!
  • 若Lambda 的参数列表的第一个参数,是实例方法的调用者,第二个参数(或无参)是实例方法的参数时,格式: ClassName::MethodName

如下三种主要使用情况:

(1)对象::实例方法

@Test
public void test1(){
  PrintStream ps = System.out;
  Consumer<String> con = (str) -> ps.println(str);
  con.accept("Hello World!");
 
  System.out.println("--------------------------------");
 
  Consumer<String> con2 = ps::println;
  con2.accept("Hello Java8!");
 
  Consumer<String> con3 = System.out::println;
}
 
@Test
public void test2(){
  Employee emp = new Employee(101, "张三", 18, 9999.99);
 
  Supplier<String> sup = () -> emp.getName();
  System.out.println(sup.get());
 
  System.out.println("----------------------------------");
 
  Supplier<String> sup2 = emp::getName;
  System.out.println(sup2.get());
}

(2)类::静态方法

@Test
public void test3(){
  BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);
  System.out.println(fun.apply(1.5, 22.2));
 
  System.out.println("--------------------------------------------------");
  BiFunction<Double, Double, Double> fun2 = Math::max;
  System.out.println(fun2.apply(1.2, 1.5));
}

@Test
public void test4(){
  Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
 
  System.out.println("-------------------------------------");  
  Comparator<Integer> com2 = Integer::compare;
}

(3)类::实例方法

@Test
public void test5(){
  BiPredicate<String, String> bp = (x, y) -> x.equals(y);
  System.out.println(bp.test("abcde", "abcde"));
 
  System.out.println("-----------------------------------------");
  BiPredicate<String, String> bp2 = String::equals;
  System.out.println(bp2.test("abc", "abc"));
 
  System.out.println("-----------------------------------------");
  Function<Employee, String> fun = (e) -> e.show();
  System.out.println(fun.apply(new Employee()));
 
  System.out.println("-----------------------------------------");
  Function<Employee, String> fun2 = Employee::show;
  System.out.println(fun2.apply(new Employee()));   
}

6.2 构造器引用

构造器引用:构造器的参数列表,需要与函数式接口中参数列表保持一致!

  • 构造器引用格式: ClassName::new
  • 与函数式接口相结合,自动与函数式接口中方法兼容。
  • 可以把构造器引用赋值给定义的方法,与构造器参数
  • 列表要与接口中抽象方法的参数列表一致!
  • 和方法引用一样,构造器本质上也是一个 <init> 方法
Function<Integer, MyClass> fun = (n) -> new MyClass(n);

等同于:

Function<Integer, MyClass> fun = MyClass::new;

示例:

@Test
public void test1() {
  Function<Integer, Person> f1 = new Function<Integer, Person>() {
    @Override
    public Person apply(Integer t) {
      return new Person(t);
    }
  };
  // ----------------------------lambda表达式------------------------------
  Function<Integer, Person> f2 = t -> new Person(t);
  // -----------------------------构造器的引用-----------------------------
  Function<Integer, Person> f3 = Person::new;
}

示例解释:

  • Apply()方法中第一个泛型是形参类型,第二个泛型是返回值返回值类型,所以构造器引用时,将返回类型的对象new,将第一个参数作为形参

6.3 数组引用

构造器引用的特例

  • 数组引用格式:type[]::new
Function<Integer, Integer[]> fun = (n) -> new Integer[n];

等同于:

Function<Integer, Integer[]> fun = Integer[]::new;

示例:

/**
 * 数组引用
 */
@Test
public void test2() {
  Function<Integer, Person[]> f1 = new Function<Integer, Person[]>() {
    @Override
    public Person[] apply(Integer t) {
      return new Person[t];
    }
  };
  // ---------------------------------lambda表达式------------------------------
  Function<Integer, Person[]> f2 = t -> new Person[t];
  // ---------------------------------数组的引用------------------------------
  Function<Integer, Person[]> f3 = Person[]::new;
  // 调用
  Person[] apply = f3.apply(10);
}

示例解释:

  • Apply()方法中第一个泛型是形参类型,第二个泛型是返回值返回值的数组类型,所以构造器引用时,将返回类型的对象new,将第一个参数作为返回数组的长度

使用案例:

List<String> newStrList = Arrays.asList(1,2,3,4,5).stream().map(String::new).collect(Collectors.toList());

7、Lambda表达式应用实战

7.1 示例1

// 1、匿名内部类
Comparator<Integer>com = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {  //降序排列
        return Integer.compare(o2,o1);
        // return o2 - o1;
    }
};

// 2、Lambda 表达式
Comparator<Integer> com = (x, y) -> Integer.compare(y, x);

7.2 数组排序

List<Integer> list = Arrays.asList(33,44,55,33,22);

// 1、匿名内部类的方式
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
 
        return o1 - o2;
 
    }
 
});
 
// 2、lambda 表达式的方式
Collections.sort(list, (p1, p2) -> p1 - p2); 

// 3、静态方法的引用
Collections.sort(list, LambdbTest::compar);
 
public static int compar(Integer p1, Integer p2) {
    return p1-p2;
 
}

7.3 获取stream对象

// 1、批量数据,stream对象
 
Stream stream = Stream.of("admin", "ossuser");
 
// 2、数组
 
int[] array = new int[]{1,3,4};
 
IntStream stream1 = Arrays.stream(array);
 
// 2、集合
 
List<String> list = Arrays.asList("admin", "ossuser");
 
Stream<String> stream2 = list.stream();
 
// 3、Map
 
Map<String, String> map = new HashMap<>();
 
map.put("name", "admin");
 
Stream<Map.Entry<String, String>> stream3 = map.entrySet().stream();
 
// 3、stream对基类型类型的功能封装
 
IntStream intStream = IntStream.of(3);
 
IntStream.range(1, 5).forEach(System.out::println); // 左闭右开
 
IntStream.rangeClosed(1, 5).forEach(System.out::println); // 左闭又闭

7.4 Stream对象转为指定数据

// 1、数组
Object[] ints = stream.toArray(String[]::new);

// 2、字符串
String collect1 = stream.collect(Collectors.joining()).toString();
 
// 3、集合
List<String> list1 = (List<String>) stream.collect(Collectors.toList());
 
// 4、map
Map<String, String> map1 = (Map<String, String>) stream.collect(Collectors.toMap(x -> x, y -> "value" + y));

7.5 其他API操作

List<String> list2 = Arrays.asList("admin", "user", "ossuser");
 
// 1、map() 中间操作,map()方法接收一个Function接口
List<String> strings = list2.stream().map(x -> x + "test").collect(Collectors.toList());
 
// 2、filter() 添加过滤条件,过滤满足条件的用户
List<String> collect = list2.stream().filter(x -> x.length() > 2).collect(Collectors.toList());
 
// 3、forEach 增强型循环
list2.forEach(System.out::print);
 
// 4、peek() 中间操作,迭代数据依次处理过程,实现数据的多次迭代
list2.stream()
        .peek(x -> System.out.println(x + "1"))
        .peek(x -> System.out.println(x + "2"))
        .forEach(System.out::println);
 
// 5、skip()  中间操作,有状态,跳过部分数据
list2.stream().skip(1).forEach(System.out::println);
 
// 6、limit() 中间操作,有状态,限制输出数据量
list2.stream().limit(2).forEach(System.out::println);
 
// 7、distinct() 中间操作,有状态,去重
list2.stream().distinct().forEach(System.out::println);
0

评论区