java8 lambda常用整理(1)

1.map遍历

可以使用Map接口提供的新方法forEach来遍历Map的键值对。这个方法接受一个BiConsumer函数式接口作为参数，该接口定义了一个操作，接收键和对应的值作为输入。

下面是一个示例代码，展示如何在Java 8中使用forEach方法遍历Map：

import java.util.HashMap;
import java.util.Map;

public class MapTraversalExample {
    public static void main(String[] args) {
        // 创建一个Map对象
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 10);
        map.put("Banana", 20);
        map.put("Orange", 30);

        // 使用forEach方法遍历Map
        map.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));
    }
}

输出结果为：

Key: Apple, Value: 10
Key: Banana, Value: 20
Key: Orange, Value: 30

在forEach方法中，我们传递了一个Lambda表达式(key, value) -> System.out.println("Key: " + key + ", Value: " + value)作为参数。Lambda表达式接受键和对应的值，并打印它们的内容。

2.集合过滤

下面是使用Java 8中的Stream API对集合进行过滤的示例：

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

public class CollectionFilteringExample {
    public static void main(String[] args) {
        // 创建一个包含整数的List
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用Stream API过滤偶数
        List<Integer> evenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());

        System.out.println(evenNumbers); // 输出: [2, 4, 6, 8, 10]
    }
}

在上面的示例中，我们创建了一个包含整数的List对象numbers。然后，我们使用stream()方法将numbers转换为Stream对象。接下来，我们使用filter操作来指定一个谓词（即一个返回boolean值的Lambda表达式），过滤出偶数。最后，我们使用collect方法将过滤后的结果收集到一个新的List对象evenNumbers中。

3.list转map

在Java 8中，你可以使用Stream API的Collectors.toMap()方法将List转换为Map。toMap()方法接受两个函数式接口作为参数，用于提取List元素的键和值。

下面是使用Java 8中的Collectors.toMap()方法将List转换为Map的示例：

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

public class ListToMapExample {
    public static void main(String[] args) {
        // 创建一个包含学生信息的List
        List<Student> students = List.of(
                new Student(1, "Alice"),
                new Student(2, "Bob"),
                new Student(3, "Charlie")
        );

        // 将List转换为Map，以学生ID作为键，学生对象作为值
        Map<Integer, Student> studentMap = students.stream()
                .collect(Collectors.toMap(Student::getId, student -> student));

        // 打印Map中的键值对
        studentMap.forEach((id, student) -> System.out.println("ID: " + id + ", Student: " + student));
    }
}

class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

在上面的示例中，我们创建了一个包含学生信息的List对象students。然后，我们使用stream()方法将students转换为Stream对象。接下来，我们使用Collectors.toMap()方法将学生ID作为键，学生对象作为值，生成一个Map对象studentMap。最后，我们使用forEach()方法打印studentMap中的键值对。

4.list转set

在Java 8中，你可以使用Stream API的Collectors.toSet()方法将List转换为Set。toSet()方法会创建一个新的Set对象，并将List中的元素添加到Set中，去除重复元素。

以下是使用Java 8中的Collectors.toSet()方法将List转换为Set的示例：

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

public class ListToSetExample {
    public static void main(String[] args) {
        // 创建一个包含整数的List
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 4, 3, 2, 1);

        // 将List转换为Set
        Set<Integer> numberSet = numbers.stream()
                .collect(Collectors.toSet());

        // 打印Set中的元素
        numberSet.forEach(System.out::println);
    }
}

在上面的示例中，我们创建了一个包含整数的List对象numbers，其中包含了重复的元素。然后，我们使用stream()方法将numbers转换为Stream对象。接下来，我们使用Collectors.toSet()方法将Stream中的元素收集到一个新的Set对象numberSet中。

最后，我们使用forEach()方法遍历numberSet，并使用方法引用System.out::println打印集合中的每个元素。

以下是一个示例，演示如何将List中的对象属性转换为Set：

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

public class ListPropertyToSetExample {
    public static void main(String[] args) {
        // 创建一个包含学生对象的List
        List<Student> students = List.of(
                new Student(1, "Alice"),
                new Student(2, "Bob"),
                new Student(3, "Charlie")
        );

        // 将学生对象的名称属性转换为Set
        Set<String> studentNames = students.stream()
                .map(Student::getName)
                .collect(Collectors.toSet());

        // 打印Set中的学生名称
        studentNames.forEach(System.out::println);
    }
}

class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

在上述示例中，我们创建了一个包含学生对象的List对象students。然后，我们使用stream()方法将students转换为Stream对象。接下来，我们使用map()操作将学生对象的名称属性提取出来，并生成一个新的Stream<String>。最后，我们使用Collectors.toSet()方法将这些学生名称收集到一个独特的Set对象studentNames中。

5.set转map

在Java 8中，你可以使用Stream API的Collectors.toMap()方法将Set转换为Map。toMap()方法接受两个函数式接口作为参数，用于提取Set元素的键和值。

以下是使用Java 8中的Collectors.toMap()方法将Set转换为Map的示例：

import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class SetToMapExample {
    public static void main(String[] args) {
        // 创建一个包含学生对象的Set
        Set<Student> students = new HashSet<>();
        students.add(new Student(1, "Alice"));
        students.add(new Student(2, "Bob"));
        students.add(new Student(3, "Charlie"));

        // 将Set转换为Map，以学生ID作为键，学生对象作为值
        Map<Integer, Student> studentMap = students.stream()
                .collect(Collectors.toMap(Student::getId, student -> student));

        // 打印Map中的键值对
        studentMap.forEach((id, student) -> System.out.println("ID: " + id + ", Student: " + student));
    }
}

class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

在上述示例中，我们创建了一个包含学生对象的Set对象students。然后，我们使用stream()方法将students转换为Stream对象。接下来，我们使用Collectors.toMap()方法将学生ID作为键，学生对象作为值，生成一个Map对象studentMap。最后，我们使用forEach()方法打印studentMap中的键值对。

6.集合foreach

使用forEach方法来遍历List。以下是一个简单的例子，演示如何使用forEach方法遍历一个包含字符串的List：

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

public class ListForEachExample {
    public static void main(String[] args) {
        // 创建一个包含字符串的List
        List<String> fruits = new ArrayList<>();
        fruits.add("苹果");
        fruits.add("香蕉");
        fruits.add("橙子");

        // 使用forEach方法遍历List
        fruits.forEach(fruit -> System.out.println(fruit));
    }
}

在这个例子中，我们首先创建了一个包含字符串的List对象fruits，然后使用forEach方法遍历该List。在forEach方法中，我们使用Lambda表达式指定对每个元素的操作，这里是将元素打印到控制台。

运行该程序，输出将是：

苹果
香蕉
橙子

7.集合对象转集合对象

当你需要从一个User对象集合转换为另一个Person对象集合时，你可以使用 Java 8 的 Stream API 和
map 操作。以下是一个简单的例子：

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

public class ObjectTransformationExample {
    public static void main(String[] args) {
        // 创建一个包含User对象的List
        List<User> users = Arrays.asList(
                new User("Alice", 25),
                new User("Bob", 30),
                new User("Charlie", 22)
        );

        // 使用Stream API和map操作将List中的User对象转换为Person对象
        List<Person> persons = users.stream()
                .map(user ->{ Person person=new Person(user.getName(), user.getAge())
                            return person;
                            })
        
                .collect(Collectors.toList());

        // 打印转换后的List
        persons.forEach(System.out::println);
    }
}

class User {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

class Person {
    private String name;
    private int age;

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

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

在这个例子中，我们有一个包含User对象的List，然后使用 stream() 方法将其转换为 Stream<User>。接着，我们使用 map 操作将每个 User 对象映射为一个新的 Person 对象。最后，使用 collect(Collectors.toList()) 将结果收集为一个新的 List<Person> 对象。