Java 使用EasyExcel写入文件动态表头不创建对象

以下是使用EasyExcel在Java中写入文件并使用动态表头的示例代码：

// 导入EasyExcel依赖
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.write.builder.ExcelWriterBuilder;
import com.alibaba.excel.write.metadata.WriteSheet;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class WriteExcelDynamicHeaderExample {

    public static void main(String[] args) {

        // 定义数据
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> data1 = new LinkedHashMap<>();
        data1.put("姓名", "张三");
        data1.put("年龄", 20);
        data1.put("性别", "男");
        dataList.add(data1);

        Map<String, Object> data2 = new LinkedHashMap<>();
        data2.put("姓名", "李四");
        data2.put("年龄", 25);
        data2.put("性别", "女");
        dataList.add(data2);

        // 定义表头
        List<List<String>> headList = new ArrayList<>();
        List<String> headRow1 = new ArrayList<>();
        headRow1.add("姓名");
        headRow1.add("年龄");
        headRow1.add("性别");
        headList.add(headRow1);

        // 定义文件名和sheet名
        String fileName = "dynamic_header.xlsx";
        String sheetName = "Sheet1";

        // 创建ExcelWriterBuilder对象
        ExcelWriterBuilder writerBuilder = EasyExcel.write(fileName);

        // 设置sheet名
        WriteSheet writeSheet = EasyExcel.writerSheet(sheetName).build();

        // 写入数据和表头
        writerBuilder.head(headList).registerWriteHandler(new DynamicHeadWriteHandler()).sheet().doWrite(dataList, writeSheet);

        System.out.println("Excel文件导出完毕！");
    }

    /**
     * 动态表头写入处理器
     */
    private static class DynamicHeadWriteHandler extends AbstractRowWriteHandler {

        /**
         * 在写入行数据之前执行
         *
         * @param context 上下文
         */
        @Override
        public void beforeRowCreate(WriteHandlerContext context) {
            // 获取表头
            List<List<String>> headList = context.writeSheetHolder().excelWriteHeadProperty().getHead();

            // 获取数据
            Map<Integer, String> columnIndexMap = context.writeSheetHolder().getCellMap().getColumnIndexMap();
            List<Object> rowData = context.currentRowAnalysisResult().getRowData();
            Map<String, Object> dataMap = new LinkedHashMap<>();
            for (int i = 0; i < rowData.size(); i++) {
                dataMap.put(columnIndexMap.get(i), rowData.get(i));
            }

            // 动态添加表头
            if (headList.size() <= 1) {
                List<String> headRow2 = new ArrayList<>();
                for (String key : dataMap.keySet()) {
                    headRow2.add(key);
                }
                headList.add(headRow2);
            }
        }
    }

    /**
     * 抽象的行写入处理器
     */
    private static abstract class AbstractRowWriteHandler extends BaseRowWriteHandler {

        /**
         * 在写入行数据之前执行
         *
         * @param context 上下文
         */
        public abstract void beforeRowCreate(WriteHandlerContext context);

        /**
         * 在写入行数据之前调用
         *
         * @param context 上下文
         */
        @Override
        public void beforeRowCreate(WriteHandlerContext context, WriteRowData writeRowData) {
            beforeRowCreate(context);
            super.beforeRowCreate(context, writeRowData);
        }
    }

    /**
     * 基本的行写入处理器
     */
    private static class BaseRowWriteHandler implements RowWriteHandler {

        /**
         * 在写入行数据之前调用
         *
         * @param context 上下文
         */
        @Override
        public void beforeRowCreate(WriteHandlerContext context, WriteRowData writeRowData) {
            // do nothing
        }

        /**
         * 在写入行数据之后调用
         *
         * @param context 上下文
         */
        @Override
        public void afterRowCreate(WriteHandlerContext context, WriteRowData writeRowData) {
            // do nothing
        }

        /**
         * 在写入单元格之前调用
         *
         * @param context 上下文
         */
        @Override
        public void beforeCellCreate(WriteHandlerContext context, WriteCellData<?> writeCellData) {
            // do nothing
        }

        /**
         * 在写入单元格之后调用
         *
         * @param context 上下文
         */
        @Override
        public void afterCellCreate(WriteHandlerContext context, WriteCellData<?> writeCellData) {
            // do nothing
        }
    }

    /**
     * 写入Excel的数据对象
     */
    public static class ExcelData {

        @ExcelProperty("姓名")
        private String name;

        @ExcelProperty("年龄")
        private int age;

        @ExcelProperty("性别")
        private String gender;

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

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public String getGender() {
            return gender;
        }

        public void setGender(String gender) {
            this.gender = gender;
        }
    }
}

在上面的示例代码中，我们首先定义了要写入Excel文件的数据和表头。数据是一个List<Map<String, Object>>类型的集合，每个Map表示一行数据，其中key为列名，value为数据值。表头是一个List<List>类型的集合，每个List表示一行，其中每个元素表示一列的列名。

接着我们创建了一个ExcelWriterBuilder对象，并设置了文件名和sheet名。然后我们调用head()方法设置表头，同时注册了一个DynamicHeadWriteHandler处理器来动态添加表头。最后我们调用sheet()方法写入数据和表头，并使用doWrite()方法将数据写入文件。

DynamicHeadWriteHandler是一个自定义的处理器，它继承自AbstractRowWriteHandler类，实现了beforeRowCreate()方法，在写入每行数据之前动态添加表头。AbstractRowWriteHandler类是一个抽象的行写入处理器，定义了beforeRowCreate()方法，在写入每行数据之前调用。BaseRowWriteHandler类是一个基本的行写入处理器，它实现了RowWriteHandler接口，并提供了空实现，方便其他处理器继承它并只需要实现需要的方法。

最后我们定义了一个ExcelData类作为数据对象，用@ExcelProperty注解来指定每个属性对应的列名。但是在这个示例中我们并没有使用这个类，而是直接使用了List<Map<String, Object>>类型的集合来存储数据，这是因为EasyExcel支持直接将Map类型的数据写入文件，不需要额外定义数据对象