Stream流的常见用法：
1.利用stream流特性把数组转list集合
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//打印结果
System.out.println(list);
输出结果为：
2.利用stream流特性取出list集合中的最大值
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性获取集合中的最大值
Integer max = list.stream().max(Comparator.comparing(Integer::new)).get();
//打印结果
System.out.println(max);
输出结果为：
3.利用stream流特性取出list集合中的最小值
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性获取集合中的最小值
Integer min= list.stream().min(Comparator.comparing(Integer::new)).get();
//打印结果
System.out.println(min);
输出结果为：
4.利用stream流特性取出list集合中大于3的值
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性获取集合中大于3的所有值
List<Integer> conditions =
list.stream().filter(value -> value > 3).collect(Collectors.toList());
//打印结果
System.out.println(conditions);
输出结果：
5.利用stream流特性取出list集合中小于3的值
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性获取集合中小于3的所有值
List<Integer> conditions = list.stream().filter(value -> value < 3).collect(Collectors.toList());
//打印结果
System.out.println(conditions);
输出结果：
6.利用stream流特性取出list集合中不等于3的值
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性获取集合中不等于3的值
List<Integer> conditions = list.stream().filter(value -> value != 3).collect(Collectors.toList());
//打印结果
System.out.println(conditions);
输出结果：
7.利用stream流特性计算list集合中大于1的数量
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性获取集合中大于1的数量
long count = list.stream().filter(value -> value > 1).count();
//打印结果
System.out.println(count);
输出结果：
8.利用stream流特性计算list集合中等于2的数量
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性获取集合中等于2的数量
long count = list.stream().filter(value -> value == 2).count();
//打印结果
System.out.println(count);
输出结果：
9.利用stream流特性去除list集合中重复的数据
//定义一个数组
Integer[] array = {5,5,2,2,1,1,6,6,4,4,3,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性去除集合中重复的数据
List<Integer> collects = list.stream().distinct().collect(Collectors.toList());
//打印结果
System.out.println("去除前的数据：" + list + "\n去重后的数据：" + collects);
输出结果：
10.利用stream流特性截取list集合中前两个的数据
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性截取集合中前两个数值
List<Integer> collects = list.stream().limit(2).collect(Collectors.toList());
//打印结果
System.out.println("截取到的数据：" + collects);
输出结果：
11.利用stream流特性跳过list集合中前两个数据
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性跳过集合中前两个数值
List<Integer> collects = list.stream().skip(2).collect(Collectors.toList());
//打印结果
System.out.println("跳过前两个值后的数据：" + collects);
输出结果：
12.利用stream流特性遍历list集合中每一个元素
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性遍历集合中每一个元素
list.stream().forEach(System.out::println);
输出结果：
13.利用stream流特性计算list集合中数值的平均值
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性计算集合中数值的平均值
double average = list.stream().mapToInt(Integer::new).average().orElse(0);
//打印结果
System.out.println("计算后的平均值：" + average);
输出结果：
14.利用stream流特性计算list集合中数值的总和
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性计算集合中数值的总和
int sum = list.stream().mapToInt(Integer::new).sum();
//打印结果
System.out.println("计算后的总和：" + sum);
输出结果：
15.利用stream流特性升序排列list集合中所有元素
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性升序排列集合中的所有元素
List<Integer> collects = list.stream().sorted().collect(Collectors.toList());
//打印结果
System.out.println("升序排列后的集合：" + collects);
输出结果：
16.利用stream流特性降序排列list集合中所有元素
//定义一个数组
Integer[] array = {5,2,1,6,4,3};
//通过stream特性把数组转list集合
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
//通过stream特性降序排列集合中的所有元素
List<Integer> collects = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
//打印结果
System.out.println("降序排列后的集合：" + collects);
输出结果：
结合实际拓展使用：
1、处理Person对象列表，及一些常见的数据操作
创建一个Person类，它具有姓名、年龄和性别属性。我们要处理一个包含多个Person对象的列表，并进行一些常见的数据操作。以下是使用Java 8的Stream常用用法处理这个复杂数据的示例代码：
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Stream {
public static void main(String[] args) {
//在集合中添加几组数据
List<Person> persons = Arrays.asList(
new Person("John", 25, Gender.MALE),
new Person("Jane", 30, Gender.FEMALE),
new Person("Tom", 20, Gender.MALE),
new Person("Susan", 28, Gender.FEMALE),
new Person("Mike", 35, Gender.MALE)
);
// 使用Stream的常用用法
// 1. 按年龄升序排列，并获取姓名列表
List<String> sortedNames = persons.stream()
.sorted((p1, p2) -> p1.getAge() - p2.getAge())
.map(Person::getName)
.collect(Collectors.toList());
System.out.println(sortedNames);
// 2. 获取所有年龄大于25岁的人的姓名列表
List<String> namesAbove25 = persons.stream()
.filter(p -> p.getAge() > 25)
.map(Person::getName)
.collect(Collectors.toList());
System.out.println(namesAbove25);
// 3. 统计男性和女性的人数
long maleCount = persons.stream()
.filter(p -> p.getGender() == Gender.MALE)
.count();
long femaleCount = persons.stream()
.filter(p -> p.getGender() == Gender.FEMALE)
.count();
System.out.println("Male count: " + maleCount);
System.out.println("Female count: " + femaleCount);
// 4. 按性别分组
Map<Gender, List<Person>> personsByGender = persons.stream()
.collect(Collectors.groupingBy(Person::getGender));
System.out.println(personsByGender);
// 5. 计算年龄的平均值
double averageAge = persons.stream()
.mapToInt(Person::getAge)
.average()
.orElse(0);
System.out.println("Average age: " + averageAge);
}
}
//定义一个人物类
class Person {
private String name;
private int age;
private Gender gender;
public Person(String name, int age, Gender gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public Gender getGender() {
return gender;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", gender=" + gender +
'}';
}
}
//定义一个枚举类
enum Gender {
MALE, FEMALE
}
这段代码使用了Stream的排序、映射、过滤、计数、分组和统计等常用操作，展示了如何在处理复杂数据时利用Stream提供的功能。根据实际需要，可以组合使用这些操作来完成更复杂的数据处理任务。
2、学生老师和课程，及一些常见的数据操作
创建一个包含学生、老师和课程的复杂数据结构。学生和老师都有姓名和年龄属性，课程有名称和标签属性。我们要处理这个复杂数据结构，并进行一些常见的数据操作。以下是使用Java 8的Stream常用用法处理这个复杂数据的示例代码：
import java.util.*;
import java.util.stream.Collectors;
public class Stream {
public static void main(String[] args) {
// 创建学生
Student student1 = new Student("John", 20);
Student student2 = new Student("Jane", 22);
Student student3 = new Student("Tom", 23);
List<Student> students = Arrays.asList(student1, student2, student3);
// 创建老师
Teacher teacher1 = new Teacher("Amy", 35);
Teacher teacher2 = new Teacher("Bob", 40);
List<Teacher> teachers = Arrays.asList(teacher1, teacher2);
// 创建课程
Course course1 = new Course("Math", "science");
Course course2 = new Course("English", "language");
Course course3 = new Course("Physics", "science");
List<Course> courses = Arrays.asList(course1, course2, course3);
// 学生选课
student1.selectCourse(course1);
student1.selectCourse(course2);
student2.selectCourse(course2);
student2.selectCourse(course3);
student3.selectCourse(course1);
student3.selectCourse(course3);
// 按照年龄升序排列学生
List<Student> sortedStudents = students.stream()
.sorted((s1, s2) -> s1.getAge() - s2.getAge())
.collect(Collectors.toList());
System.out.println(sortedStudents);
// 获取学生姓名列表
List<String> studentNames = students.stream()
.map(Student::getName)
.collect(Collectors.toList());
System.out.println(studentNames);
// 获取学生所选的课程名列表
List<String> studentCourseNames = students.stream()
.flatMap(student -> student.getCourses().stream())
.map(Course::getName)
.collect(Collectors.toList());
System.out.println(studentCourseNames);
// 获取选择了"science"标签的课程
List<Course> scienceCourses = courses.stream()
.filter(course -> course.getLabel().equals("science"))
.collect(Collectors.toList());
System.out.println(scienceCourses);
// 根据老师的年龄分组学生
Map<Teacher, List<Student>> studentsByTeacher = students.stream()
.collect(Collectors.groupingBy(Student::getTeacher));
System.out.println(studentsByTeacher);
}
}
class Student {
public Teacher teacher;
private String name;
private int age;
private List<Course> courses;
public Student(String name, int age) {
this.name = name;
this.age = age;
this.courses = new ArrayList<>();
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public List<Course> getCourses() {
return courses;
}
public Teacher getTeacher() {
return teacher;
}
public void selectCourse(Course course) {
courses.add(course);
course.addStudent(this);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
class Teacher {
private String name;
private int age;
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
class Course {
private String name;
private String label;
private List<Student> students;
public Course(String name, String label) {
this.name = name;
this.label = label;
this.students = new ArrayList<>();
}
public String getName() {
return name;
}
public String getLabel() {
return label;
}
public List<Student> getStudents() {
return students;
}
public void addStudent(Student student) {
students.add(student);
student.teacher = student.getTeacher();
}
@Override
public String toString() {
return "Course{" +
"name='" + name + '\'' +
", label='" + label + '\'' +
'}';
}
}
这段代码演示了如何使用Stream对包含学生、老师和课程的复杂数据进行处理。它展示了在使用Stream时常见的一些操作，如排序、映射、过滤、分组等。根据实际需求，你可以在此基础上进一步扩展和优化数据操作。
3、公司部门用户和商品订单，及一些常见的数据操作
import java.util.*;
import java.util.stream.Collectors;
public class Stream {
public static void main(String[] args) {
List<User> users = Arrays.asList(
new User("John", "Company A", "Department A"),
new User("Tom", "Company B", "Department B"),
new User("Alice", "Company A", "Department B")
);
List<Order> orders = Arrays.asList(
new Order("Product A", 5),
new Order("Product B", 3),
new Order("Product A", 2)
);
// 1. 根据公司分组用户
Map<String, List<User>> usersByCompany = users.stream()
.collect(Collectors.groupingBy(User::getCompany));
System.out.println("Users grouped by company: " + usersByCompany);
// 2. 过滤用户，只保留来自公司 A 的用户
List<User> usersFromCompanyA = users.stream()
.filter(u -> u.getCompany().equals("Company A"))
.collect(Collectors.toList());
System.out.println("Users from Company A: " + usersFromCompanyA);
// 3. 获取部门为 Department B 的用户数量
long departmentBUserCount = users.stream()
.filter(u -> u.getDepartment().equals("Department B"))
.count();
System.out.println("Department B user count: " + departmentBUserCount);
// 4. 获取每个用户的订单总数
Map<User, Integer> orderCountByUser = users.stream()
.collect(Collectors.toMap(
u -> u,
u -> orders.stream()
.filter(o -> o.getProduct().equals("Product A"))
.mapToInt(Order::getQuantity)
.sum()
));
System.out.println("Order count by user: " + orderCountByUser);
// 5. 获取所有订单的总数量
int totalOrderCount = orders.stream()
.mapToInt(Order::getQuantity)
.sum();
System.out.println("Total order count: " + totalOrderCount);
}
}
class User {
private String name;
private String company;
private String department;
public User(String name, String company, String department) {
this.name = name;
this.company = company;
this.department = department;
}
public String getName() {
return name;
}
public String getCompany() {
return company;
}
public String getDepartment() {
return department;
}
}
class Order {
private String product;
private int quantity;
public Order(String product, int quantity) {
this.product = product;
this.quantity = quantity;
}
public String getProduct() {
return product;
}
public int getQuantity() {
return quantity;
}
}
这个示例代码展示了使用 JDK 8 Stream API 进行一些常见的数据处理操作，包括分组、过滤、计数和求和等操作。你可以根据实际的复杂数据结构和需求来进行相应的修改和扩展。
4、公司部门用户和商品订单，n个示例
过滤过程：
假设有一个用户列表List<User> users，过滤出年龄大于18岁的用户：
List<User> filteredUsers = users.stream()
.filter(user -> user.getAge() > 18)
.collect(Collectors.toList());
映射过程：
假设有一个用户列表List<User> users，提取所有用户的用户名：
List<String> usernames = users.stream()
.map(user -> user.getUsername())
.collect(Collectors.toList());
排序过程：
假设有一个用户列表List<User> users，按照年龄从小到大排序：
List<User> sortedUsers = users.stream()
.sorted(Comparator.comparingInt(User::getAge))
.collect(Collectors.toList());
分组过程：
假设有一个订单列表List<Order> orders，根据公司进行分组：
Map<Company, List<Order>> ordersByCompany = orders.stream()
.collect(Collectors.groupingBy(Order::getCompany));
聚合操作：
假设有一个订单列表List<Order> orders，计算所有订单的总金额：
double totalAmount = orders.stream()
.mapToDouble(Order::getAmount)
.sum();
扁平化处理：
假设有一个公司列表List<Company> companies，获取所有公司的部门列表：
List<Department> departments = companies.stream()
.flatMap(company -> company.getDepartments().stream())
.collect(Collectors.toList());
匹配元素：
假设有一个用户列表List<User> users，检查是否存在年龄大于等于30岁的用户：
boolean anyMatch = users.stream()
.anyMatch(user -> user.getAge() >= 30);
查找元素：
假设有一个用户列表List<User> users，查找年龄最大的用户：
Optional<User> maxAgeUser = users.stream()
.max(Comparator.comparingInt(User::getAge));
限制结果集：
假设有一个订单列表List<Order> orders，获取前5个订单：
List<Order> limitedOrders = orders.stream()
.limit(5)
.collect(Collectors.toList());
跳过元素：
假设有一个商品列表List<Product> products，跳过前3个商品，获取剩下的商品：
List<Product> skippedProducts = products.stream()
.skip(3)
.collect(Collectors.toList());
去重处理：
假设有一个整数列表List<Integer> numbers，去除重复的数字：
List<Integer> distinctNumbers = numbers.stream()
.distinct()
.collect(Collectors.toList());
并行处理：
假设有一个订单列表List<Order> orders，使用并行流计算订单的总金额：
double totalAmount = orders.parallelStream()
.mapToDouble(Order::getAmount)
.sum();
使用reduce聚合操作：
假设有一个订单列表List<Order> orders，计算所有订单的总金额，使用reduce操作：
double totalAmount = orders.stream()
.map(Order::getAmount)
.reduce(0.0, Double::sum);
使用findFirst查找第一个元素：
假设有一个订单列表List<Order> orders，查找第一个购买商品为“手机”的订单：
Optional<Order> firstMobileOrder = orders.stream()
.filter(order -> order.getProduct().equals("手机"))
.findFirst();
对集合元素进行批量操作：
假设有一个用户列表List<User> users，将所有用户的年龄加5并更新：
List<User> updatedUsers = users.stream()
.peek(user -> user.setAge(user.getAge() + 5))
.collect(Collectors.toList());
多级分组：
假设有一个商品列表List<Product> products，按照公司和部门进行多级分组：
Map<Company, Map<Department, List<Product>>> productsByCompanyAndDepartment = products.stream()
.collect(Collectors.groupingBy(Product::getCompany,
Collectors.groupingBy(Product::getDepartment)));
使用flatMap进行嵌套处理：
假设有一个公司列表List<Company> companies，获取所有公司的所有部门的所有员工姓名：
List<String> employeeNames = companies.stream()
.flatMap(company -> company.getDepartments().stream())
.flatMap(department -> department.getEmployees().stream())
.map(Employee::getName)
.collect(Collectors.toList());
查找满足条件的任意元素：
假设有一个商品列表List<Product> products，查找任意一件库存大于0的商品：
Optional<Product> anyProduct = products.stream()
.filter(product -> product.getStock() > 0)
.findAny();
统计元素个数：
假设有一个用户列表List<User> users，统计用户的数量：
long userCount = users.stream()
.count();
使用forEach进行迭代操作：
假设有一个订单列表List<Order> orders，打印所有订单的信息：
orders.stream()
.
forEach(System.out::println);
并行处理处理大数据量：
假设有一个非常大的用户列表List<User> users，使用并行流进行处理：
users.parallelStream()
.
filter(user ->user.getAge()>18)
.
forEach(System.out::println);
使用collect进行自定义的聚合操作：
假设有一个商品列表List<Product> products，将所有商品的名称用逗号连接起来：
String names = products.stream()
.map(Product::getName)
.collect(Collectors.joining(", "));
使用Optional处理可能为空的值：
假设有一个List<Optional<User>> userList，筛选出非空的用户列表：
List<User> nonEmptyUserList = userList.stream()
.filter(Optional::isPresent)
.map(Optional::get)
.collect(Collectors.toList());
连接字符串：
假设有一个商品列表List<Product> products，将所有商品的名称以逗号分隔连接成一个字符串：
String joinedNames = products.stream()
.map(Product::getName)
.collect(Collectors.joining(", "));
对元素进行分页处理：
假设有一个订单列表List<Order> orders，将订单按照每页10个进行分页：
int pageSize = 10;
int totalPages = (int) Math.ceil((double) orders.size() / pageSize);
List<List<Order>> paginatedOrders = IntStream.range(0, totalPages)
.mapToObj(page -> orders.stream()
.skip(page * pageSize)
.limit(pageSize)
.collect(Collectors.toList()))
.collect(Collectors.toList());
使用IntStream进行数值操作：
假设有一个整数列表List<Integer> numbers，计算列表中所有偶数的平方和：
int sumOfEvenSquares = numbers.stream()
.filter(number -> number % 2 == 0)
.mapToInt(number -> number * number)
.sum();
使用max和min获取最大值和最小值：
假设有一个整数列表List<Integer> numbers，找到列表中的最大值和最小值：
Optional<Integer> maxNumber = numbers.stream()
.max(Integer::compareTo);
Optional<Integer> minNumber = numbers.stream()
.min(Integer::compareTo);
使用toMap将集合转换为Map：
假设有一个用户列表List<User> users，将用户按照ID作为键转换为Map：
Map<Integer, User> userMap = users.stream()
.collect(Collectors.toMap(User::getId, Function.identity()));
使用anyMatch和allMatch进行条件判断：
假设有一个用户列表List<User> users，检查是否所有用户的年龄都大于18岁：
boolean allAdults = users.stream()
.allMatch(user -> user.getAge() > 18);
boolean anyAdult = users.stream()
.anyMatch(user -> user.getAge() > 18);
使用distinct和sorted进行去重和排序：
假设有一个整数列表List<Integer> numbers，去除重复值并对值进行排序：
List<Integer> distinctSortedNumbers = numbers.stream()
.distinct()
.sorted()
.collect(Collectors.toList());
使用flatMap将多个列表合并为一个列表：
假设有一个公司列表List<Company> companies，将每个公司的部门列表合并成一个部门列表：
List<Department> allDepartments = companies.stream()
.flatMap(company -> company.getDepartments().stream())
.collect(Collectors.toList());
使用reduce进行自定义聚合操作：
假设有一个订单列表List<Order> orders，计算所有订单的总金额：
double totalAmount = orders.stream()
.map(Order::getAmount)
.reduce(0.0, Double::sum);
使用partitioningBy进行分区操作：
假设有一个商品列表List<Product> products，按照库存是否大于0进行分区：
Map<Boolean, List<Product>> partitionedProducts = products.stream()
.collect(Collectors.partitioningBy(product -> product.getStock() > 0));
使用zip操作将两个流合并为一个流：
假设有一个用户列表List<User> users和一个商品列表List<Product>products，将两个列表合并为一个交替的流：
Stream<Object> interleavedStream = StreamUtils.zip(users.stream(), products.stream());
使用iterate生成一个无限流：
假设需要生成一个自增的整数序列：
Stream<Integer> sequentialNumberStream = Stream.iterate(0, i -> i + 1);
使用toList将流转换为列表：
假设有一个用户流Stream<User> userStream，将其转换为用户列表：
List<User> userList = userStream.collect(Collectors.toList());
使用toSet将流转换为集合：
假设有一个商品流Stream<Product> productStream，将其转换为商品集合：
Set<Product> productSet = productStream.collect(Collectors.toSet());
使用joining将流转换为字符串：
假设有一个部门流Stream<Department> departmentStream，将其转换为部门名称的逗号分隔字符串：
String departmentNames = departmentStream.map(Department::getName)
.collect(Collectors.joining(", "));
使用summarizingInt计算流中的统计数据：
假设有一个订单流Stream<Order> orderStream，计算订单金额的统计数据：
DoubleSummaryStatistics orderStatistics = orderStream
.collect(Collectors.summarizingDouble(Order::getAmount));
System.out.println("Total Orders: "+orderStatistics.getCount());
System.out.println("Total Amount: "+orderStatistics.getSum());
System.out.println("Average Amount: "+orderStatistics.getAverage());
System.out.println("Max Amount: "+orderStatistics.getMax());
System.out.println("Min Amount: "+orderStatistics.getMin());
使用toMap将流转换为自定义的Map：
假设有一个用户流Stream<User> userStream，将其转换为以ID为键、用户对象为值的Map：
Map<Integer, User> userMap = userStream.collect(Collectors.toMap(User::getId, Function.identity()));
使用groupingByConcurrent进行并发分组操作：
假设有一个订单列表List<Order> orders，按照公司进行并发分组：
ConcurrentMap<Company, List<Order>> ordersByCompany = orders.stream()
.collect(Collectors.groupingByConcurrent(Order::getCompany));
使用flatMapToInt计算流中元素的数值总和：
假设有一个整数列表List<Integer> numbers，计算列表中所有元素的数值总和：
int sum = numbers.stream()
.flatMapToInt(IntStream::of)
.sum();
使用peek进行调试操作：
假设有一个商品列表List<Product> products，在对每个商品进行其他操作之前，在控制台打印商品信息：
List<Product> modifiedProducts = products.stream()
.peek(product -> System.out.println("Processing product: " + product.getName()))
.map(product -> /* 进行其他操作 */)
.collect(Collectors.toList());
五、
常用总结
根据map的key进行排序
升序排列
Map<LocalDateTime, List<ExerciseReport>> twelveReportMap = twelveReportDataList.stream()
.collect(Collectors.groupingBy(ExerciseReport::getCreateDate));
System.out.println("twelveReportMap"+twelveReportMap);
//根据时间进行升序排序
Map<LocalDateTime, List<ExerciseReport>> result = new LinkedHashMap<>();
twelveReportMap.entrySet().
stream().
sorted(Map.Entry.comparingByKey()).
forEachOrdered(x ->result.put(x.getKey(),x.getValue()));
降序排列
Map<LocalDateTime, List<ExerciseReport>> twelveReportMap = twelveReportDataList.stream()
.collect(Collectors.groupingBy(ExerciseReport::getCreateDate));
//根据时间进行升序排序
Map<LocalDateTime, List<ExerciseReport>> result = new LinkedHashMap<>();
twelveReportMap.entrySet().
stream().
sorted(Collections.reverseOrder(Map.Entry.comparingByKey())).
forEachOrdered(x ->result.put(x.getKey(),x.getValue()));
String[] idStr转化为
List<Long> ids
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
String[] idStr = {"1", "2", "3", "4", "5"};
List<Long> ids = Arrays.stream(idStr)
.map(Long::parseLong)
.collect(Collectors.toList());
System.out.println(ids);
}
}
感谢大家的阅读，觉得有用的朋友可以收藏点赞，有问题的朋友可以留下你的问题一起交流讨论。
