Java Lambda 表达式深度解析

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

// 传统匿名内部类
runnable runnable = new runnable() {
    @override
    public void run() {
        system.out.println("hello world");
    }
};
// lambda 表达式
runnable runnable = () -> system.out.println("hello world");

// 1. 无参数，无返回值
() -> system.out.println("hello");
// 2. 一个参数，无返回值
(x) -> system.out.println(x);
x -> system.out.println(x);  // 括号可选
// 3. 多个参数，有返回值
(int x, int y) -> x + y;
(x, y) -> x + y;  // 类型推断
// 4. 复杂逻辑，需要代码块
(x, y) -> {
    int result = x + y;
    system.out.println("结果: " + result);
    return result;
}

// 定义：无参无返回值
runnable r = () -> system.out.println("running");
// 使用场景：线程任务、简单的代码块执行
r.run(); // 输出 "running"
// 实际例子
new thread(() -> system.out.println("在新线程中运行")).start();
// 相当于：执行一段代码块
() -> {
    system.out.println("第一件事");
    system.out.println("第二件事");
}

// 定义：消费一个参数，无返回值
consumer<string> consumer = s -> system.out.println(s);
// 使用：接受数据并处理
consumer.accept("hello world"); // 输出 "hello world"
// 实际例子
list<string> names = arrays.aslist("alice", "bob", "charlie");
names.foreach(name -> system.out.println("你好，" + name));
// 输出：
// 你好，alice
// 你好，bob  
// 你好，charlie
// 相当于：处理接收到的数据
(数据) -> {
    // 处理这个数据
    // 但不返回任何结果
}

// 定义：无参数，返回一个值
supplier<string> supplier = () -> "hello";
// 使用：获取数据
string result = supplier.get(); // result = "hello"
// 实际例子
supplier<double> randomsupplier = () -> math.random();
supplier<localdatetime> timesupplier = () -> localdatetime.now();
system.out.println(randomsupplier.get()); // 输出随机数，如 0.12345
system.out.println(timesupplier.get());   // 输出当前时间
// 相当于：一个数据工厂
() -> {
    return 产生的数据;
}

// 定义：接受t参数，返回r结果
function<string, integer> function = s -> s.length();
// 使用：数据转换
int length = function.apply("hello"); // length = 5
// 实际例子
function<string, string> touppercase = s -> s.touppercase();
function<integer, string> inttohex = i -> integer.tohexstring(i);
system.out.println(touppercase.apply("hello")); // 输出 "hello"
system.out.println(inttohex.apply(255));        // 输出 "ff"
// 相当于：数据加工厂
(输入数据) -> {
    return 加工后的数据;
}

// 定义：接受t参数，返回boolean
predicate<string> predicate = s -> s.isempty();
// 使用：条件判断
boolean result = predicate.test("");    // result = true
boolean result2 = predicate.test("hi"); // result2 = false
// 实际例子
predicate<string> islongword = s -> s.length() > 5;
predicate<integer> iseven = n -> n % 2 == 0;
list<string> words = arrays.aslist("apple", "banana", "cat", "elephant");
words.stream()
     .filter(islongword)  // 过滤出长度>5的单词
     .foreach(system.out::println);
// 输出：banana, elephant
// 相当于：条件检查器
(数据) -> {
    return 数据是否符合条件;
}

// 1. 静态方法引用
function<string, integer> parser = integer::parseint;
// 2. 实例方法引用
string str = "hello";
supplier<integer> lengthsupplier = str::length;
// 3. 任意对象的实例方法引用
function<string, string> uppercase = string::touppercase;
// 4. 构造方法引用
supplier<list<string>> listsupplier = arraylist::new;

list<string> names = arrays.aslist("alice", "bob", "charlie");
// lambda 表达式
names.foreach(name -> system.out.println(name));
// 方法引用
names.foreach(system.out::println);
// 静态方法引用
list<integer> numbers = arrays.aslist(1, 2, 3);
numbers.stream()
       .map(string::valueof)  // 静态方法引用
       .foreach(system.out::println);

list<string> names = arrays.aslist("alice", "bob", "charlie", "david");
// 过滤
list<string> result = names.stream()
    .filter(name -> name.length() > 3)      // predicate
    .map(string::touppercase)               // function
    .sorted()                               // comparator
    .collect(collectors.tolist());          // collector

list<integer> numbers = arrays.aslist(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 过滤偶数，平方，然后求和
int sum = numbers.stream()
    .filter(n -> n % 2 == 0)           // 过滤偶数
    .map(n -> n * n)                   // 平方
    .reduce(0, integer::sum);          // 求和
// 分组操作
map<string, list<person>> peoplebycity = people.stream()
    .collect(collectors.groupingby(person::getcity));  // 方法引用

list<string> list = new arraylist<>();
list.add("apple");
list.add("banana");
list.add("cherry");
// 遍历
list.foreach(item -> system.out.println(item));
// 排序
list.sort((a, b) -> a.compareto(b));
list.sort(string::compareto);  // 方法引用
// 过滤
list<string> filtered = list.stream()
    .filter(s -> s.startswith("a"))
    .collect(collectors.tolist());

map<string, integer> map = new hashmap<>();
map.put("alice", 25);
map.put("bob", 30);
map.put("charlie", 35);
// 遍历
map.foreach((name, age) -> 
    system.out.println(name + ": " + age));
// 转换
map<string, string> namelength = map.entryset().stream()
    .collect(collectors.tomap(
        map.entry::getkey,                   // 键
        entry -> string.valueof(entry.getvalue())  // 值
    ));

// 实体类属性引用
lambdaquerywrapper<user> wrapper = new lambdaquerywrapper<>();
wrapper.eq(user::getname, "张三")           // 方法引用
      .gt(user::getage, 18)                // lambda
      .like(user::getemail, "@gmail.com");
// 等价于：where name = '张三' and age > 18 and email like '%@gmail.com%'

lambdaquerywrapper<user> wrapper = new lambdaquerywrapper<>();
// 条件分组
wrapper.and(w -> w
    .eq(user::getstatus, 1)
    .or()
    .eq(user::getstatus, 2)
).or(w -> w
    .gt(user::getage, 60)
    .lt(user::getage, 18)
);
// 等价于：where (status = 1 or status = 2) or (age > 60 or age < 18)