【日积月累】Java Lambda 表达式

在这里插入图片描述

【日积月累】Java Lambda 表达式

1.前言
2.语法
3.应用场景
- 3.1简化匿名内部类的编写
- 3.1简化匿名内部类的编写
- 3.2简化集合类中的操作
- 3.3实现函数式接口
- 3.4简化多个方法的调用
- 3.5简化异步编程
4.总结
5.参考

文章所属专区日积月累

1.前言

Lambda表达式是一个匿名函数，也称闭包，允许把函数作为一个方法的参数，使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时，也会随之被编译成一个函数式接口。

2.语法

Lambda表达式是用箭头（->）定义的，后面跟着一个或多个参数列表和方法体。

(parameters) -> expression

或

(parameters) ->{ statements; }

parameters是一个或多个参数列表，它们是用圆括号括起来的。参数列表是用逗号分隔的参数名称和类型的列表。方法体是在箭头后面的花括号内定义的代码块。
示例：

int x = 10;
int y = 20;
int sum = (a, b) -> a + b;
System.out.println(sum(x, y)); // 输出30

3.应用场景

3.1简化匿名内部类的编写

未使用前：

// 未使用Lambda表达式简化匿名内部类
public class MyClass {
 public static void main(String[] args) {
    new Thread() {
      @Override
      public void run() {
        System.out.println("Hello, world!");
      }
    }.start();
 }
}

使用之后：

在这里插入代码片

3.1简化匿名内部类的编写

未使用前：

import java.util.ArrayList;
import java.util.List;

public class AnonymousInnerClassExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        for (Integer i : list) {
            System.out.println(i);
        }
    }
}

使用之后：

import java.util.ArrayList;
import java.util.List;

public class AnonymousInnerClassExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

     list.forEach(System.out::println);
    }
}

Lambda表达式中的System.out::println是一个静态方法引用，它表示println()方法的调用。在Lambda表达式中，它被用于打印每个元素。

3.2简化集合类中的操作

public class AnonymousInnerClassExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

     list.forEach(System.out::println);
    }
}

3.3实现函数式接口

只包含一个抽象方法的接口，就称为函数式接口。
我们可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以用于检测它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。
定义函数式接口：

@FunctionalInterface
public interface MyFuncInterf<T> {
   public T getValue(String origin);
}

使用函数式接口作为方法参数：

  public String toLowerString(MyFuncInterf<String> mf,String origin){
    return mf.getValue(origin);
  }

使用Lambda表达式实现的接口作为参数传递：

 public void test(){
 	String result = toLowerString((str)->{
		return str.toLowerCase();
	},"ABC")；
		
    System.out.println(result);//结果abc
  }

3.4简化多个方法的调用

使用之后：

public static void main(String[] args) {
    String result = filter(list -> list.contains("apple"), "banana", "orange");
    System.out.println(result); // output: ["apple"]
}
public static <T> List<T> filter(Predicate<T> predicate, T... values) {
    return Arrays.stream(values)
        .filter(predicate)
        .collect(Collectors.toList());
}

3.5简化异步编程

使用之后：

// 使用Lambda表达式简化匿名内部类
public class MyClass {
 public static void main(String[] args) {
    Runnable runnable = new Runnable() {
      @Override
      public void run() {
        System.out.println("Hello, world!");
      }
    };
    runnable.run();
 }
}

// 使用Lambda表达式简化集合类中的操作
List<Integer> list = Arrays.asList(1, 2, 3);
list.forEach(i -> System.out.println(i * 2));

// 使用Lambda表达式实现函数式接口
Supplier<String> greetingSupplier = () -> "Hello, ";
String greeting = greetingSupplier.get();

// 使用Lambda表达式简化多个方法的调用
public void process(List<String> strings) {
 strings.forEach(string -> process(string));
}

// 使用Lambda表达式简化异步编程
ExecutorService executorService = Executors.newFixedThreadPool(3);
Future<String> future1 = executorService.submit(() -> {
 try {
    Thread.sleep(1000);
 } catch (InterruptedException e) {
    e.printStackTrace();
 }
 return "Task 1 completed";
});
Future<String> future2 = executorService.submit(() -> {
 try {
    Thread.sleep(2000);
 } catch (InterruptedException e) {
    e.printStackTrace();
 }
 return "Task 2 completed";
});

String result1 = future1.get();
String result2 = future2.get();
System.out.println(result1 + result2);