重生之我在deepseek中学习java 第十五天之Lambda表达式与函数式编程-Java-E先生的博客

Java学习指南-第十五天：Lambda表达式与函数式编程

　　1.Lambda表达式简介

　　Lambda表达式是Java 8引入的一种新特性，用于简化匿名内部类的写法。Lambda表达式允许将函数作为参数传递，从而使代码更加简洁和易读。

　　2.Lambda表达式语法

　　Lambda表达式的语法如下：

(parameters) -> expression

　　或

(parameters) -> { statements; }

　　2.1示例

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // 使用Lambda表达式遍历列表
        names.forEach(name -> System.out.println(name));

        // 使用Lambda表达式排序
        names.sort((name1, name2) -> name1.compareTo(name2));
        System.out.println("Sorted names: " + names);
    }
}

　　3.函数式接口

　　函数式接口是只包含一个抽象方法的接口。Lambda表达式可以用于实现函数式接口。Java提供了java.util.function包，其中包含一些常用的函数式接口。

　　3.1常用函数式接口

Consumer<T>：接受一个输入参数并返回无结果的操作。
Supplier<T>：无输入参数，返回一个结果。
Function<T, R>：接受一个输入参数并返回一个结果。
Predicate<T>：接受一个输入参数并返回一个布尔值。

　　3.2示例

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        // Consumer示例
        Consumer<String> print = s -> System.out.println(s);
        print.accept("Hello, World!");

        // Supplier示例
        Supplier<Double> random = () -> Math.random();
        System.out.println("Random number: " + random.get());

        // Function示例
        Function<String, Integer> length = s -> s.length();
        System.out.println("Length of 'Hello': " + length.apply("Hello"));

        // Predicate示例
        Predicate<String> isLong = s -> s.length() > 5;
        System.out.println("Is 'Hello' long? " + isLong.test("Hello"));
    }
}

　　4.方法引用

　　方法引用是Lambda表达式的一种简化写法，用于直接引用已有的方法。方法引用有以下几种形式：

静态方法引用：类名::静态方法
实例方法引用：对象::实例方法
构造方法引用：类名::new

　　4.1示例

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // 静态方法引用
        names.forEach(System.out::println);

        // 实例方法引用
        names.sort(String::compareTo);
        System.out.println("Sorted names: " + names);

        // 构造方法引用
        Supplier<List<String>> listSupplier = Arrays::<String>asList;
        List<String> newList = listSupplier.get();
        newList.add("David");
        System.out.println("New list: " + newList);
    }
}

　　5.Stream API

　　Stream API是Java 8引入的用于处理集合数据的API。Stream API提供了丰富的操作，如过滤、映射、排序、聚合等。

　　5.1常用Stream操作

filter：过滤元素。
map：映射元素。
sorted：排序元素。
forEach：遍历元素。
collect：收集元素。

　　5.2示例

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 过滤
        List<String> filteredNames = names.stream()
                                          .filter(name -> name.length() > 4)
                                          .collect(Collectors.toList());
        System.out.println("Filtered names: " + filteredNames);

        // 映射
        List<Integer> nameLengths = names.stream()
                                         .map(String::length)
                                         .collect(Collectors.toList());
        System.out.println("Name lengths: " + nameLengths);

        // 排序
        List<String> sortedNames = names.stream()
                                        .sorted()
                                        .collect(Collectors.toList());
        System.out.println("Sorted names: " + sortedNames);

        // 遍历
        names.stream()
             .forEach(System.out::println);
    }
}

　　6.今日任务

　　使用Lambda表达式实现一个Runnable接口，并启动线程。

　　使用Function接口将一个字符串列表转换为整数列表（字符串长度）。

　　使用Stream API对一个整数列表进行过滤、映射和排序操作。

　　7.示例代码

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        // 任务1：使用Lambda表达式实现Runnable接口
        Runnable task = () -> System.out.println("Running in a thread");
        new Thread(task).start();

        // 任务2：使用Function接口转换字符串列表
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        Function<String, Integer> length = String::length;
        List<Integer> nameLengths = names.stream()
                                         .map(length)
                                         .collect(Collectors.toList());
        System.out.println("Name lengths: " + nameLengths);

        // 任务3：使用Stream API处理整数列表
        List<Integer> numbers = Arrays.asList(5, 3, 8, 1, 9, 2);
        List<Integer> processedNumbers = numbers.stream()
                                               .filter(n -> n > 3)
                                               .map(n -> n * 2)
                                               .sorted()
                                               .collect(Collectors.toList());
        System.out.println("Processed numbers: " + processedNumbers);
    }
}