Java8流式API将实体类列表转换为视图对象列表的示例

public List<V> listVO(List<E> list) {
    return (List) list.stream()             // 1. 将输入的实体列表转换成流
            .map(this::entityVO)           // 2. 对每个实体元素应用 entityVO 方法进行转换
            .collect(Collectors.toList()); // 3. 将转换后的流收集成一个新的列表
}

// 实体类
class Employee {
    private String name;
    private int age;
    private double salary;

    // 构造函数和 Getter/Setter
    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public double getSalary() {
        return salary;
    }
}

// 视图对象类
class EmployeeVO {
    private String name;
    private int age;

    // 构造函数和 Getter/Setter
    public EmployeeVO(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

// 转换方法所在的类
class EmployeeService {

    // 将 Employee 实体转换为 EmployeeVO 视图对象
    private EmployeeVO entityVO(Employee employee) {
        return new EmployeeVO(employee.getName(), employee.getAge());
    }

    // 将 Employee 列表转换为 EmployeeVO 列表
    public List<EmployeeVO> listVO(List<Employee> list) {
        return (List<EmployeeVO>) list.stream()  // 将 Employee 列表转为流
                .map(this::entityVO)            // 调用 entityVO 方法转换为 EmployeeVO
                .collect(Collectors.toList());  // 收集结果到一个 List
    }
}

// 使用示例
public class Demo {
    public static void main(String[] args) {
        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee("Alice", 30, 50000));
        employees.add(new Employee("Bob", 25, 40000));

        EmployeeService service = new EmployeeService();
        List<EmployeeVO> employeeVOList = service.listVO(employees);

        // 输出 EmployeeVO 列表
        employeeVOList.forEach(vo -> System.out.println("Name: " + vo.getName() + ", Age: " + vo.getAge()));
    }
}

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import java.util.List;
import java.util.stream.Collectors;

public abstract class BaseEntityWrapper<E, V> {
    public BaseEntityWrapper() {
    }

    public abstract V entityVO(E entity);

    public List<V> listVO(List<E> list) {
        return (List)list.stream().map(this::entityVO).collect(Collectors.toList());
    }

    public IPage<V> pageVO(IPage<E> pages) {
	    // 1. 获取分页数据中的记录列表，并通过 listVO 方法将其从实体类转换为视图对象
	    List<V> records = this.listVO(pages.getRecords());
	    
	    // 2. 创建新的分页对象，用于存储视图对象
	    IPage<V> pageVo = new Page<>(pages.getCurrent(), pages.getSize(), pages.getTotal());
	    
	    // 3. 将转换后的视图对象列表设置到新的分页对象中
	    pageVo.setRecords(records);
	    
	    // 4. 返回包含视图对象的分页结果
	    return pageVo;
	}

}

// 实体类
class Employee {
    private Long id;
    private String name;
    private double salary;

    // 构造函数、Getter、Setter
    public Employee(Long id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }
    public Long getId() { return id; }
    public String getName() { return name; }
    public double getSalary() { return salary; }
}

// 视图对象类
class EmployeeVO {
    private Long id;
    private String name;

    // 构造函数、Getter、Setter
    public EmployeeVO(Long id, String name) {
        this.id = id;
        this.name = name;
    }
    public Long getId() { return id; }
    public String getName() { return name; }
}

public class EmployeeWrapper extends BaseEntityWrapper<Employee, EmployeeVO> {

    // 实现抽象方法：将 Employee 转换为 EmployeeVO
    @Override
    public EmployeeVO entityVO(Employee employee) {
        return new EmployeeVO(employee.getId(), employee.getName());
    }
}

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

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

public class Demo {
    public static void main(String[] args) {
        // 1. 创建模拟分页数据
        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee(1L, "Alice", 50000));
        employees.add(new Employee(2L, "Bob", 40000));
        IPage<Employee> employeePage = new Page<>(1, 10, 20); // 当前第1页，每页10条，总共20条
        employeePage.setRecords(employees);

        // 2. 使用 EmployeeWrapper 进行转换
        EmployeeWrapper wrapper = new EmployeeWrapper();
        IPage<EmployeeVO> employeeVOPage = wrapper.pageVO(employeePage);

        // 3. 输出转换后的分页结果
        System.out.println("分页元信息：");
        System.out.println("当前页：" + employeeVOPage.getCurrent());
        System.out.println("每页大小：" + employeeVOPage.getSize());
        System.out.println("总记录数：" + employeeVOPage.getTotal());

        System.out.println("\n分页记录：");
        employeeVOPage.getRecords().forEach(vo -> 
            System.out.println("ID: " + vo.getId() + ", Name: " + vo.getName())
        );
    }
}