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

从实战demo进行学习：

1. 基本知识

这段代码是一个 java 方法，将一个实体类列表 (list<e>) 转换为一个视图对象列表 (list<v>)

这里使用了 java 8 的流 (stream) api 来实现转换

public list<v> listvo(list<e> list) {
    return (list) list.stream()             // 1. 将输入的实体列表转换成流
            .map(this::entityvo)           // 2. 对每个实体元素应用 entityvo 方法进行转换
            .collect(collectors.tolist()); // 3. 将转换后的流收集成一个新的列表
}

2. demo

使用了 java 8 的流式处理 api，通过 map 方法将实体对象列表转换为视图对象列表。
这种方式常用于将数据库实体类转换为前端展示需要的简化视图对象，避免暴露敏感数据或不必要的字段

为更好的展示具体的使用逻辑，以测试demo为例

基本目录如下：

完整demo如下：

// 实体类
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()));
    }
}

截图如下：

如果还看不懂，基本的代码解读如下：

employee 类是实体类，包含了 name、age 和 salary 等字段，表示员工的详细信息
employeevo 类是视图对象类，只包含 name 和 age 字段，适合用来展示在 ui 中，不包含敏感数据如 salary
entityvo 方法负责将 employee 实体对象转换为 employeevo 视图对象
在这个例子中，entityvo 方法只提取了 name 和 age 字段
listvo 方法接受一个 list<employee> 参数，使用 stream() 方法将其转化为流，然后通过 map(this::entityvo) 将每个 employee 对象转换为 employeevo 对象，最后使用 collect(collectors.tolist()) 将结果收集成一个新的 list<employeevo>

3. 拓展

还有一种分页的转换实现：

通过java 泛型实体类与视图对象分页转换的封装实现

pagevo 方法的目的是将分页的实体类对象 (ipage<e>) 转换为分页的视图对象 (ipage<v>)，并保留分页的元信息（如当前页、每页大小、总记录数）。这种封装常用于服务层返回统一格式的分页数据

模版如下：

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;
	}

}

示例demo如下：

// 实体类
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; }
}

自定义 wrapper 实现

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())
        );
    }
}

类似输出如下：