文档章节

配置简单功能强大的excel工具类搞定excel导入导出工具类

时刻在奔跑
 时刻在奔跑
发布于 2018/05/09 17:35
字数 5555
阅读 406
收藏 0

3 月,跳不动了?>>>

对于J2EE项目导入导出Excel是最普通和实用功能,本工具类使用步骤简单,功能强大,只需要对实体类进行简单的注解就能实现导入导出功能,导入导出操作的都是实体对象.

请看一下这个类都有哪些功能:
      * 1.实体属性配置了注解就能导出到excel中,每个属性都对应一列.
      * 2.列名称可以通过注解配置.
      * 3.导出到哪一列可以通过注解配置.
      * 4.鼠标移动到该列时提示信息可以通过注解配置.
      * 5.用注解设置只能下拉选择不能随意填写功能.
      * 6.用注解设置是否只导出标题而不导出内容,这在导出内容作为模板以供用户填写时比较实用.


请看一下效果图:

 

 

请看一下使用步骤:

1.写一个实体类,并设置注解配置.
2.实例化一个ExcelUtil<T>对象,调用exportExcel或importExcel方法.

请看一个demo.

1.写一个实体类,并设置注解配置.

package com.tgb.lk.test03;  
  
import com.tgb.lk.util.ExcelVOAttribute;  
  
public class StudentVO {  
    @ExcelVOAttribute(name = "序号", column = "A")  
    private int id;  
  
    @ExcelVOAttribute(name = "姓名", column = "B", isExport = true)  
    private String name;  
  
    @ExcelVOAttribute(name = "年龄", column = "C", prompt = "年龄保密哦!", isExport = false)  
    private int age;  
  
    @ExcelVOAttribute(name = "班级", column = "D", combo = { "五期提高班", "六期提高班",  
            "七期提高班" })  
    private String clazz;  
  
    @ExcelVOAttribute(name = "公司", column = "F")  
    private String company;  
  
    //get和set方法(略)...  
  
    @Override  
    public String toString() {  
        return "StudentVO [id=" + id + ", name=" + name + ", company="  
                + company + ", age=" + age + ", clazz=" + clazz + "]";  
    }  
  
}  

2.实例化一个ExcelUtil<T>对象,调用exportExcel或importExcel方法.
(1)导出

package com.tgb.lk.test03;  
  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.util.ArrayList;  
import java.util.List;  
  
import com.tgb.lk.util.ExcelUtil;  
  
/* 
 * 使用步骤: 
 * 1.新建一个类,例如StudentVO. 
 * 2.设置哪些属性需要导出,哪些需要设置提示. 
 * 3.设置实体数据 
 * 4.调用exportExcel方法. 
 */  
public class ExportTest03 {  
    public static void main(String[] args) {  
        // 初始化数据  
        List<StudentVO> list = new ArrayList<StudentVO>();  
  
        StudentVO vo = new StudentVO();  
        vo.setId(1);  
        vo.setName("李坤");  
        vo.setAge(26);  
        vo.setClazz("五期提高班");  
        vo.setCompany("天融信");  
        list.add(vo);  
  
        StudentVO vo2 = new StudentVO();  
        vo2.setId(2);  
        vo2.setName("曹贵生");  
        vo2.setClazz("五期提高班");  
        vo2.setCompany("中银");  
        list.add(vo2);  
  
        StudentVO vo3 = new StudentVO();  
        vo3.setId(3);  
        vo3.setName("柳波");  
        vo3.setClazz("五期提高班");  
        list.add(vo3);  
  
        FileOutputStream out = null;  
        try {  
            out = new FileOutputStream("d:\\success3.xls");  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        }  
        ExcelUtil<StudentVO> util = new ExcelUtil<StudentVO>(StudentVO.class);// 创建工具类.  
        util.exportExcel(list, "学生信息", 65536, out);// 导出  
        System.out.println("----执行完毕----------");  
    }  
  
}  

(2)导入

package com.tgb.lk.test03;  
  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.util.List;  
  
import com.tgb.lk.util.ExcelUtil;  
  
public class ImportTest03 {  
    public static void main(String[] args) {  
        FileInputStream fis = null;  
        try {  
            fis = new FileInputStream("d:\\success3.xls");  
            ExcelUtil<StudentVO> util = new ExcelUtil<StudentVO>(  
                    StudentVO.class);// 创建excel工具类  
            List<StudentVO> list = util.importExcel("学生信息0", fis);// 导入  
            System.out.println(list);  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        }  
  
    }  
}  

看完使用步骤一定对封装的类迫不及待了吧,请继续往下看:

(1)注解实现类:

package com.tgb.lk.util;  
  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  
  
@Retention(RetentionPolicy.RUNTIME)  
@Target( { java.lang.annotation.ElementType.FIELD })  
public @interface ExcelVOAttribute {  
  
    /** 
     * 导出到Excel中的名字. 
     */  
    public abstract String name();  
  
    /** 
     * 配置列的名称,对应A,B,C,D.... 
     */  
    public abstract String column();  
  
    /** 
     * 提示信息 
     */  
    public abstract String prompt() default "";  
  
    /** 
     * 设置只能选择不能输入的列内容. 
     */  
    public abstract String[] combo() default {};  
  
    /** 
     * 是否导出数据,应对需求:有时我们需要导出一份模板,这是标题需要但内容需要用户手工填写. 
     */  
    public abstract boolean isExport() default true;  
  
}  

(2)导入导出封装类:

package com.tgb.lk.util;  
  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.lang.reflect.Field;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
  
import org.apache.poi.hssf.usermodel.DVConstraint;  
import org.apache.poi.hssf.usermodel.HSSFCell;  
import org.apache.poi.hssf.usermodel.HSSFDataValidation;  
import org.apache.poi.hssf.usermodel.HSSFRow;  
import org.apache.poi.hssf.usermodel.HSSFSheet;  
import org.apache.poi.hssf.usermodel.HSSFWorkbook;  
import org.apache.poi.ss.util.CellRangeAddressList;  
  
/* 
 * ExcelUtil工具类实现功能: 
 * 导出时传入list<T>,即可实现导出为一个excel,其中每个对象T为Excel中的一条记录. 
 * 导入时读取excel,得到的结果是一个list<T>.T是自己定义的对象. 
 * 需要导出的实体对象只需简单配置注解就能实现灵活导出,通过注解您可以方便实现下面功能: 
 * 1.实体属性配置了注解就能导出到excel中,每个属性都对应一列. 
 * 2.列名称可以通过注解配置. 
 * 3.导出到哪一列可以通过注解配置. 
 * 4.鼠标移动到该列时提示信息可以通过注解配置. 
 * 5.用注解设置只能下拉选择不能随意填写功能. 
 * 6.用注解设置是否只导出标题而不导出内容,这在导出内容作为模板以供用户填写时比较实用. 
 * 本工具类以后可能还会加功能,请关注我的博客: http://blog.csdn.net/lk_blog 
 */  
public class ExcelUtil<T> {  
    Class<T> clazz;  
  
    public ExcelUtil(Class<T> clazz) {  
        this.clazz = clazz;  
    }  
  
    public List<T> importExcel(String sheetName, InputStream input) {  
        List<T> list = new ArrayList<T>();  
        try {  
            HSSFWorkbook workbook = new HSSFWorkbook(input);  
            HSSFSheet sheet = workbook.getSheet(sheetName);  
            if (!sheetName.trim().equals("")) {  
                sheet = workbook.getSheet(sheetName);// 如果指定sheet名,则取指定sheet中的内容.  
            }  
            if (sheet == null) {  
                sheet = workbook.getSheetAt(0); // 如果传入的sheet名不存在则默认指向第1个sheet.  
            }  
            int rows = sheet.getPhysicalNumberOfRows();  
  
            if (rows > 0) {// 有数据时才处理  
                Field[] allFields = clazz.getDeclaredFields();// 得到类的所有field.  
                Map<Integer, Field> fieldsMap = new HashMap<Integer, Field>();// 定义一个map用于存放列的序号和field.  
                for (Field field : allFields) {  
                    // 将有注解的field存放到map中.  
                    if (field.isAnnotationPresent(ExcelVOAttribute.class)) {  
                        ExcelVOAttribute attr = field  
                                .getAnnotation(ExcelVOAttribute.class);  
                        int col = getExcelCol(attr.column());// 获得列号  
                        // System.out.println(col + "====" + field.getName());  
                        field.setAccessible(true);// 设置类的私有字段属性可访问.  
                        fieldsMap.put(col, field);  
                    }  
                }  
                for (int i = 1; i < rows; i++) {// 从第2行开始取数据,默认第一行是表头.  
                    HSSFRow row = sheet.getRow(i);  
                    int cellNum = row.getPhysicalNumberOfCells();  
                    T entity = null;  
                    for (int j = 0; j < cellNum; j++) {  
                        HSSFCell cell = row.getCell(j);  
                        if (cell == null) {  
                            continue;  
                        }  
                        String c = cell.getStringCellValue();  
                        System.out.println(c);  
                        if (c.equals("")) {  
                            continue;  
                        }  
                        entity = (entity == null ? clazz.newInstance() : entity);// 如果不存在实例则新建.  
                        // System.out.println(cells[j].getContents());  
                        Field field = fieldsMap.get(j);// 从map中得到对应列的field.  
                        // 取得类型,并根据对象类型设置值.  
                        Class<?> fieldType = field.getType();  
                        if (String.class == fieldType) {  
                            field.set(entity, String.valueOf(c));  
                        } else if ((Integer.TYPE == fieldType)  
                                || (Integer.class == fieldType)) {  
                            field.set(entity, Integer.parseInt(c));  
                        } else if ((Long.TYPE == fieldType)  
                                || (Long.class == fieldType)) {  
                            field.set(entity, Long.valueOf(c));  
                        } else if ((Float.TYPE == fieldType)  
                                || (Float.class == fieldType)) {  
                            field.set(entity, Float.valueOf(c));  
                        } else if ((Short.TYPE == fieldType)  
                                || (Short.class == fieldType)) {  
                            field.set(entity, Short.valueOf(c));  
                        } else if ((Double.TYPE == fieldType)  
                                || (Double.class == fieldType)) {  
                            field.set(entity, Double.valueOf(c));  
                        } else if (Character.TYPE == fieldType) {  
                            if ((c != null) && (c.length() > 0)) {  
                                field.set(entity, Character  
                                        .valueOf(c.charAt(0)));  
                            }  
                        }  
  
                    }  
                    if (entity != null) {  
                        list.add(entity);  
                    }  
                }  
                //以下内容为引用jxl-xx.jar时的代码,因为jxl对office2010不支持,所以改为使用poi读写方式.  
                // HSSFRow[] cells = sheet.getRow(i); // 得到一行中的所有单元格对象.  
                // T entity = null;  
                // for (int j = 0; j < cells.length; j++) {  
                // String c = cells[j].getContents();// 单元格中的内容.  
                // if (c.equals("")) {  
                // continue;  
                // }  
                // entity = (entity == null ? clazz.newInstance() : entity);//  
                // 如果不存在实例则新建.  
                // // System.out.println(cells[j].getContents());  
                // Field field = fieldsMap.get(j);// 从map中得到对应列的field.  
                // // 取得类型,并根据对象类型设置值.  
                // Class<?> fieldType = field.getType();  
                // if ((Integer.TYPE == fieldType)  
                // || (Integer.class == fieldType)) {  
                // field.set(entity, Integer.parseInt(c));  
                // } else if (String.class == fieldType) {  
                // field.set(entity, String.valueOf(c));  
                // } else if ((Long.TYPE == fieldType)  
                // || (Long.class == fieldType)) {  
                // field.set(entity, Long.valueOf(c));  
                // } else if ((Float.TYPE == fieldType)  
                // || (Float.class == fieldType)) {  
                // field.set(entity, Float.valueOf(c));  
                // } else if ((Short.TYPE == fieldType)  
                // || (Short.class == fieldType)) {  
                // field.set(entity, Short.valueOf(c));  
                // } else if ((Double.TYPE == fieldType)  
                // || (Double.class == fieldType)) {  
                // field.set(entity, Double.valueOf(c));  
                // } else if (Character.TYPE == fieldType) {  
                // if ((c != null) && (c.length() > 0)) {  
                // field.set(entity, Character  
                // .valueOf(c.charAt(0)));  
                // }  
                // }  
                //  
                // }  
                // if (entity != null) {  
                // list.add(entity);  
                // }  
                // }  
            }  
  
        } catch (IOException e) {  
            e.printStackTrace();  
        } catch (InstantiationException e) {  
            e.printStackTrace();  
        } catch (IllegalAccessException e) {  
            e.printStackTrace();  
        } catch (IllegalArgumentException e) {  
            e.printStackTrace();  
        }  
        return list;  
    }  
  
    /** 
     * 对list数据源将其里面的数据导入到excel表单 
     *  
     * @param sheetName 
     *            工作表的名称 
     * @param sheetSize 
     *            每个sheet中数据的行数,此数值必须小于65536 
     * @param output 
     *            java输出流 
     */  
    public boolean exportExcel(List<T> list, String sheetName, int sheetSize,  
            OutputStream output) {  
  
        Field[] allFields = clazz.getDeclaredFields();// 得到所有定义字段  
        List<Field> fields = new ArrayList<Field>();  
        // 得到所有field并存放到一个list中.  
        for (Field field : allFields) {  
            if (field.isAnnotationPresent(ExcelVOAttribute.class)) {  
                fields.add(field);  
            }  
        }  
  
        HSSFWorkbook workbook = new HSSFWorkbook();// 产生工作薄对象  
  
        // excel2003中每个sheet中最多有65536行,为避免产生错误所以加这个逻辑.  
        if (sheetSize > 65536 || sheetSize < 1) {  
            sheetSize = 65536;  
        }  
        double sheetNo = Math.ceil(list.size() / sheetSize);// 取出一共有多少个sheet.  
        for (int index = 0; index <= sheetNo; index++) {  
            HSSFSheet sheet = workbook.createSheet();// 产生工作表对象  
            if (sheetNo == 0) {  
                workbook.setSheetName(index, sheetName);  
            } else {  
                workbook.setSheetName(index, sheetName + index);// 设置工作表的名称.  
            }  
            HSSFRow row;  
            HSSFCell cell;// 产生单元格  
  
            row = sheet.createRow(0);// 产生一行  
            // 写入各个字段的列头名称  
            for (int i = 0; i < fields.size(); i++) {  
                Field field = fields.get(i);  
                ExcelVOAttribute attr = field  
                        .getAnnotation(ExcelVOAttribute.class);  
                int col = getExcelCol(attr.column());// 获得列号  
                cell = row.createCell(col);// 创建列  
                cell.setCellType(HSSFCell.CELL_TYPE_STRING);// 设置列中写入内容为String类型  
                cell.setCellValue(attr.name());// 写入列名  
  
                // 如果设置了提示信息则鼠标放上去提示.  
                if (!attr.prompt().trim().equals("")) {  
                    setHSSFPrompt(sheet, "", attr.prompt(), 1, 100, col, col);// 这里默认设了2-101列提示.  
                }  
                // 如果设置了combo属性则本列只能选择不能输入  
                if (attr.combo().length > 0) {  
                    setHSSFValidation(sheet, attr.combo(), 1, 100, col, col);// 这里默认设了2-101列只能选择不能输入.  
                }  
            }  
  
            int startNo = index * sheetSize;  
            int endNo = Math.min(startNo + sheetSize, list.size());  
            // 写入各条记录,每条记录对应excel表中的一行  
            for (int i = startNo; i < endNo; i++) {  
                row = sheet.createRow(i + 1 - startNo);  
                T vo = (T) list.get(i); // 得到导出对象.  
                for (int j = 0; j < fields.size(); j++) {  
                    Field field = fields.get(j);// 获得field.  
                    field.setAccessible(true);// 设置实体类私有属性可访问  
                    ExcelVOAttribute attr = field  
                            .getAnnotation(ExcelVOAttribute.class);  
                    try {  
                        // 根据ExcelVOAttribute中设置情况决定是否导出,有些情况需要保持为空,希望用户填写这一列.  
                        if (attr.isExport()) {  
                            cell = row.createCell(getExcelCol(attr.column()));// 创建cell  
                            cell.setCellType(HSSFCell.CELL_TYPE_STRING);  
                            cell.setCellValue(field.get(vo) == null ? ""  
                                    : String.valueOf(field.get(vo)));// 如果数据存在就填入,不存在填入空格.  
                        }  
                    } catch (IllegalArgumentException e) {  
                        e.printStackTrace();  
                    } catch (IllegalAccessException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
  
        }  
        try {  
            output.flush();  
            workbook.write(output);  
            output.close();  
            return true;  
        } catch (IOException e) {  
            e.printStackTrace();  
            System.out.println("Output is closed ");  
            return false;  
        }  
  
    }  
  
    /** 
     * 将EXCEL中A,B,C,D,E列映射成0,1,2,3 
     *  
     * @param col 
     */  
    public static int getExcelCol(String col) {  
        col = col.toUpperCase();  
        // 从-1开始计算,字母重1开始运算。这种总数下来算数正好相同。  
        int count = -1;  
        char[] cs = col.toCharArray();  
        for (int i = 0; i < cs.length; i++) {  
            count += (cs[i] - 64) * Math.pow(26, cs.length - 1 - i);  
        }  
        return count;  
    }  
  
    /** 
     * 设置单元格上提示 
     *  
     * @param sheet 
     *            要设置的sheet. 
     * @param promptTitle 
     *            标题 
     * @param promptContent 
     *            内容 
     * @param firstRow 
     *            开始行 
     * @param endRow 
     *            结束行 
     * @param firstCol 
     *            开始列 
     * @param endCol 
     *            结束列 
     * @return 设置好的sheet. 
     */  
    public static HSSFSheet setHSSFPrompt(HSSFSheet sheet, String promptTitle,  
            String promptContent, int firstRow, int endRow, int firstCol,  
            int endCol) {  
        // 构造constraint对象  
        DVConstraint constraint = DVConstraint  
                .createCustomFormulaConstraint("DD1");  
        // 四个参数分别是:起始行、终止行、起始列、终止列  
        CellRangeAddressList regions = new CellRangeAddressList(firstRow,  
                endRow, firstCol, endCol);  
        // 数据有效性对象  
        HSSFDataValidation data_validation_view = new HSSFDataValidation(  
                regions, constraint);  
        data_validation_view.createPromptBox(promptTitle, promptContent);  
        sheet.addValidationData(data_validation_view);  
        return sheet;  
    }  
  
    /** 
     * 设置某些列的值只能输入预制的数据,显示下拉框. 
     *  
     * @param sheet 
     *            要设置的sheet. 
     * @param textlist 
     *            下拉框显示的内容 
     * @param firstRow 
     *            开始行 
     * @param endRow 
     *            结束行 
     * @param firstCol 
     *            开始列 
     * @param endCol 
     *            结束列 
     * @return 设置好的sheet. 
     */  
    public static HSSFSheet setHSSFValidation(HSSFSheet sheet,  
            String[] textlist, int firstRow, int endRow, int firstCol,  
            int endCol) {  
        // 加载下拉列表内容  
        DVConstraint constraint = DVConstraint  
                .createExplicitListConstraint(textlist);  
        // 设置数据有效性加载在哪个单元格上,四个参数分别是:起始行、终止行、起始列、终止列  
        CellRangeAddressList regions = new CellRangeAddressList(firstRow,  
                endRow, firstCol, endCol);  
        // 数据有效性对象  
        HSSFDataValidation data_validation_list = new HSSFDataValidation(  
                regions, constraint);  
        sheet.addValidationData(data_validation_list);  
        return sheet;  
    }  
}  

 

工具类修订版(2013-10-23):

import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.lang.reflect.Field;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
  
import org.apache.poi.hssf.usermodel.DVConstraint;  
import org.apache.poi.hssf.usermodel.HSSFCell;  
import org.apache.poi.hssf.usermodel.HSSFCellStyle;  
import org.apache.poi.hssf.usermodel.HSSFDataValidation;  
import org.apache.poi.hssf.usermodel.HSSFRow;  
import org.apache.poi.hssf.usermodel.HSSFSheet;  
import org.apache.poi.hssf.usermodel.HSSFWorkbook;  
import org.apache.poi.hssf.util.HSSFColor;  
import org.apache.poi.ss.util.CellRangeAddressList;  
  
/* 
 * ExcelUtil工具类实现功能: 
 * 导出时传入list<T>,即可实现导出为一个excel,其中每个对象T为Excel中的一条记录. 
 * 导入时读取excel,得到的结果是一个list<T>.T是自己定义的对象. 
 * 需要导出的实体对象只需简单配置注解就能实现灵活导出,通过注解您可以方便实现下面功能: 
 * 1.实体属性配置了注解就能导出到excel中,每个属性都对应一列. 
 * 2.列名称可以通过注解配置. 
 * 3.导出到哪一列可以通过注解配置. 
 * 4.鼠标移动到该列时提示信息可以通过注解配置. 
 * 5.用注解设置只能下拉选择不能随意填写功能. 
 * 6.用注解设置是否只导出标题而不导出内容,这在导出内容作为模板以供用户填写时比较实用. 
 * 本工具类以后可能还会加功能,请关注我的博客: http://blog.csdn.net/lk_blog 
 */  
public class ExcelUtil2<T> {  
    Class<T> clazz;  
  
    public ExcelUtil2(Class<T> clazz) {  
        this.clazz = clazz;  
    }  
  
    public List<T> importExcel(String sheetName, InputStream input) {  
        int maxCol = 0;  
        List<T> list = new ArrayList<T>();  
        try {  
            HSSFWorkbook workbook = new HSSFWorkbook(input);  
            HSSFSheet sheet = workbook.getSheet(sheetName);  
            if (!sheetName.trim().equals("")) {  
                sheet = workbook.getSheet(sheetName);// 如果指定sheet名,则取指定sheet中的内容.  
            }  
            if (sheet == null) {  
                sheet = workbook.getSheetAt(0); // 如果传入的sheet名不存在则默认指向第1个sheet.  
            }  
            int rows = sheet.getPhysicalNumberOfRows();  
  
            if (rows > 0) {// 有数据时才处理  
                // Field[] allFields = clazz.getDeclaredFields();// 得到类的所有field.  
                List<Field> allFields = getMappedFiled(clazz, null);  
  
                Map<Integer, Field> fieldsMap = new HashMap<Integer, Field>();// 定义一个map用于存放列的序号和field.  
                for (Field field : allFields) {  
                    // 将有注解的field存放到map中.  
                    if (field.isAnnotationPresent(ExcelVOAttribute.class)) {  
                        ExcelVOAttribute attr = field  
                                .getAnnotation(ExcelVOAttribute.class);  
                        int col = getExcelCol(attr.column());// 获得列号  
                        maxCol = Math.max(col, maxCol);  
                        // System.out.println(col + "====" + field.getName());  
                        field.setAccessible(true);// 设置类的私有字段属性可访问.  
                        fieldsMap.put(col, field);  
                    }  
                }  
                for (int i = 1; i < rows; i++) {// 从第2行开始取数据,默认第一行是表头.  
                    HSSFRow row = sheet.getRow(i);  
                    // int cellNum = row.getPhysicalNumberOfCells();  
                    // int cellNum = row.getLastCellNum();  
                    int cellNum = maxCol;  
                    T entity = null;  
                    for (int j = 0; j < cellNum; j++) {  
                        HSSFCell cell = row.getCell(j);  
                        if (cell == null) {  
                            continue;  
                        }  
                        int cellType = cell.getCellType();  
                        String c = "";  
                        if (cellType == HSSFCell.CELL_TYPE_NUMERIC) {  
                            c = String.valueOf(cell.getNumericCellValue());  
                        } else if (cellType == HSSFCell.CELL_TYPE_BOOLEAN) {  
                            c = String.valueOf(cell.getBooleanCellValue());  
                        } else {  
                            c = cell.getStringCellValue();  
                        }  
                        if (c == null || c.equals("")) {  
                            continue;  
                        }  
                        entity = (entity == null ? clazz.newInstance() : entity);// 如果不存在实例则新建.  
                        // System.out.println(cells[j].getContents());  
                        Field field = fieldsMap.get(j);// 从map中得到对应列的field.  
                        if (field==null) {  
                            continue;  
                        }  
                        // 取得类型,并根据对象类型设置值.  
                        Class<?> fieldType = field.getType();  
                        if (String.class == fieldType) {  
                            field.set(entity, String.valueOf(c));  
                        } else if ((Integer.TYPE == fieldType)  
                                || (Integer.class == fieldType)) {  
                            field.set(entity, Integer.parseInt(c));  
                        } else if ((Long.TYPE == fieldType)  
                                || (Long.class == fieldType)) {  
                            field.set(entity, Long.valueOf(c));  
                        } else if ((Float.TYPE == fieldType)  
                                || (Float.class == fieldType)) {  
                            field.set(entity, Float.valueOf(c));  
                        } else if ((Short.TYPE == fieldType)  
                                || (Short.class == fieldType)) {  
                            field.set(entity, Short.valueOf(c));  
                        } else if ((Double.TYPE == fieldType)  
                                || (Double.class == fieldType)) {  
                            field.set(entity, Double.valueOf(c));  
                        } else if (Character.TYPE == fieldType) {  
                            if ((c != null) && (c.length() > 0)) {  
                                field.set(entity, Character  
                                        .valueOf(c.charAt(0)));  
                            }  
                        }  
  
                    }  
                    if (entity != null) {  
                        list.add(entity);  
                    }  
                }  
            }  
  
        } catch (IOException e) {  
            e.printStackTrace();  
        } catch (InstantiationException e) {  
            e.printStackTrace();  
        } catch (IllegalAccessException e) {  
            e.printStackTrace();  
        } catch (IllegalArgumentException e) {  
            e.printStackTrace();  
        }  
        return list;  
    }  
  
    /** 
     * 对list数据源将其里面的数据导入到excel表单 
     *  
     * @param sheetName 
     *            工作表的名称 
     * @param output 
     *            java输出流 
     */  
    public boolean exportExcel(List<T> lists[], String sheetNames[],  
            OutputStream output) {  
        if (lists.length != sheetNames.length) {  
            System.out.println("数组长度不一致");  
            return false;  
        }  
  
        HSSFWorkbook workbook = new HSSFWorkbook();// 产生工作薄对象  
  
        for (int ii = 0; ii < lists.length; ii++) {  
            List<T> list = lists[ii];  
            String sheetName = sheetNames[ii];  
  
            List<Field> fields = getMappedFiled(clazz, null);  
  
            HSSFSheet sheet = workbook.createSheet();// 产生工作表对象  
  
            workbook.setSheetName(ii, sheetName);  
  
            HSSFRow row;  
            HSSFCell cell;// 产生单元格  
            HSSFCellStyle style = workbook.createCellStyle();  
            style.setFillForegroundColor(HSSFColor.SKY_BLUE.index);  
            style.setFillBackgroundColor(HSSFColor.GREY_40_PERCENT.index);  
            row = sheet.createRow(0);// 产生一行  
            // 写入各个字段的列头名称  
            for (int i = 0; i < fields.size(); i++) {  
                Field field = fields.get(i);  
                ExcelVOAttribute attr = field  
                        .getAnnotation(ExcelVOAttribute.class);  
                int col = getExcelCol(attr.column());// 获得列号  
                cell = row.createCell(col);// 创建列  
                cell.setCellType(HSSFCell.CELL_TYPE_STRING);// 设置列中写入内容为String类型  
                cell.setCellValue(attr.name());// 写入列名  
  
                // 如果设置了提示信息则鼠标放上去提示.  
                if (!attr.prompt().trim().equals("")) {  
                    setHSSFPrompt(sheet, "", attr.prompt(), 1, 100, col, col);// 这里默认设了2-101列提示.  
                }  
                // 如果设置了combo属性则本列只能选择不能输入  
                if (attr.combo().length > 0) {  
                    setHSSFValidation(sheet, attr.combo(), 1, 100, col, col);// 这里默认设了2-101列只能选择不能输入.  
                }  
                cell.setCellStyle(style);  
            }  
  
            int startNo = 0;  
            int endNo = list.size();  
            // 写入各条记录,每条记录对应excel表中的一行  
            for (int i = startNo; i < endNo; i++) {  
                row = sheet.createRow(i + 1 - startNo);  
                T vo = (T) list.get(i); // 得到导出对象.  
                for (int j = 0; j < fields.size(); j++) {  
                    Field field = fields.get(j);// 获得field.  
                    field.setAccessible(true);// 设置实体类私有属性可访问  
                    ExcelVOAttribute attr = field  
                            .getAnnotation(ExcelVOAttribute.class);  
                    try {  
                        // 根据ExcelVOAttribute中设置情况决定是否导出,有些情况需要保持为空,希望用户填写这一列.  
                        if (attr.isExport()) {  
                            cell = row.createCell(getExcelCol(attr.column()));// 创建cell  
                            cell.setCellType(HSSFCell.CELL_TYPE_STRING);  
                            cell.setCellValue(field.get(vo) == null ? ""  
                                    : String.valueOf(field.get(vo)));// 如果数据存在就填入,不存在填入空格.  
                        }  
                    } catch (IllegalArgumentException e) {  
                        e.printStackTrace();  
                    } catch (IllegalAccessException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        }  
  
        try {  
            output.flush();  
            workbook.write(output);  
            output.close();  
            return true;  
        } catch (IOException e) {  
            e.printStackTrace();  
            System.out.println("Output is closed ");  
            return false;  
        }  
  
    }  
  
    /** 
     * 对list数据源将其里面的数据导入到excel表单 
     *  
     * @param sheetName 
     *            工作表的名称 
     * @param sheetSize 
     *            每个sheet中数据的行数,此数值必须小于65536 
     * @param output 
     *            java输出流 
     */  
    public boolean exportExcel(List<T> list, String sheetName,  
            OutputStream output) {  
        List<T>[] lists = new ArrayList[1];  
        lists[0] = list;  
  
        String[] sheetNames = new String[1];  
        sheetNames[0] = sheetName;  
  
        return exportExcel(lists, sheetNames, output);  
    }  
  
    /** 
     * 将EXCEL中A,B,C,D,E列映射成0,1,2,3 
     *  
     * @param col 
     */  
    public static int getExcelCol(String col) {  
        col = col.toUpperCase();  
        // 从-1开始计算,字母重1开始运算。这种总数下来算数正好相同。  
        int count = -1;  
        char[] cs = col.toCharArray();  
        for (int i = 0; i < cs.length; i++) {  
            count += (cs[i] - 64) * Math.pow(26, cs.length - 1 - i);  
        }  
        return count;  
    }  
  
    /** 
     * 设置单元格上提示 
     *  
     * @param sheet 
     *            要设置的sheet. 
     * @param promptTitle 
     *            标题 
     * @param promptContent 
     *            内容 
     * @param firstRow 
     *            开始行 
     * @param endRow 
     *            结束行 
     * @param firstCol 
     *            开始列 
     * @param endCol 
     *            结束列 
     * @return 设置好的sheet. 
     */  
    public static HSSFSheet setHSSFPrompt(HSSFSheet sheet, String promptTitle,  
            String promptContent, int firstRow, int endRow, int firstCol,  
            int endCol) {  
        // 构造constraint对象  
        DVConstraint constraint = DVConstraint  
                .createCustomFormulaConstraint("DD1");  
        // 四个参数分别是:起始行、终止行、起始列、终止列  
        CellRangeAddressList regions = new CellRangeAddressList(firstRow,  
                endRow, firstCol, endCol);  
        // 数据有效性对象  
        HSSFDataValidation data_validation_view = new HSSFDataValidation(  
                regions, constraint);  
        data_validation_view.createPromptBox(promptTitle, promptContent);  
        sheet.addValidationData(data_validation_view);  
        return sheet;  
    }  
  
    /** 
     * 设置某些列的值只能输入预制的数据,显示下拉框. 
     *  
     * @param sheet 
     *            要设置的sheet. 
     * @param textlist 
     *            下拉框显示的内容 
     * @param firstRow 
     *            开始行 
     * @param endRow 
     *            结束行 
     * @param firstCol 
     *            开始列 
     * @param endCol 
     *            结束列 
     * @return 设置好的sheet. 
     */  
    public static HSSFSheet setHSSFValidation(HSSFSheet sheet,  
            String[] textlist, int firstRow, int endRow, int firstCol,  
            int endCol) {  
        // 加载下拉列表内容  
        DVConstraint constraint = DVConstraint  
                .createExplicitListConstraint(textlist);  
        // 设置数据有效性加载在哪个单元格上,四个参数分别是:起始行、终止行、起始列、终止列  
        CellRangeAddressList regions = new CellRangeAddressList(firstRow,  
                endRow, firstCol, endCol);  
        // 数据有效性对象  
        HSSFDataValidation data_validation_list = new HSSFDataValidation(  
                regions, constraint);  
        sheet.addValidationData(data_validation_list);  
        return sheet;  
    }  
  
    /** 
     * 得到实体类所有通过注解映射了数据表的字段 
     *  
     * @param map 
     * @return 
     */  
    private List<Field> getMappedFiled(Class clazz, List<Field> fields) {  
        if (fields == null) {  
            fields = new ArrayList<Field>();  
        }  
  
        Field[] allFields = clazz.getDeclaredFields();// 得到所有定义字段  
        // 得到所有field并存放到一个list中.  
        for (Field field : allFields) {  
            if (field.isAnnotationPresent(ExcelVOAttribute.class)) {  
                fields.add(field);  
            }  
        }  
        if (clazz.getSuperclass() != null  
                && !clazz.getSuperclass().equals(Object.class)) {  
            getMappedFiled(clazz.getSuperclass(), fields);  
        }  
  
        return fields;  
    }  
}  

 

您是否有这样的需求呢:
1.实体类中存放的值是一个编码,而导出的文件中需要把编码转成有意义的文字.例如:实体类中性别用0,1表示,而希望导出的excel文件中是"男","女".
2.想对导入的内容加一些逻辑,例如:判断某些值不能为空.或判断年龄不能小于0且不能大于100.

上篇文章留了个小悬念,您是否有这样的需求呢:
1.实体类中存放的值是一个编码,而导出的文件中需要把编码转成有意义的文字.例如:实体类中性别用0,1表示,而希望导出的excel文件中是"男","女".
2.想对导入的内容加一些逻辑,例如:判断某些值不能为空.或判断年龄不能小于0且不能大于100.

我们可以用一个中间类来实现这个功能.

请看代码:

(1)我们程序中真正的实体类:

package com.tgb.lk.test04;  
  
import java.util.Date;  
  
public class Student {  
    private int id;  
  
    private String name;  
  
    private int sex;  
  
    private int clazz;  
  
    private Date birthday;  
  
    private String company;  
  
    public int getId() {  
        return id;  
    }  
  
   //get和set方法(略).....  
  
    @Override  
    public String toString() {  
        return "Student [birthday=" + birthday + ", clazz=" + clazz  
                + ", company=" + company + ", id=" + id + ", name=" + name  
                + ", sex=" + sex + "]";  
    }  
  
} 

(2)我们用于导入导出的excelVO类:

package com.tgb.lk.test04;  
  
import com.tgb.lk.util.ExcelVOAttribute;  
  
public class StudentVO {  
  
    @ExcelVOAttribute(name = "姓名", column = "B", isExport = true, prompt = "姓名为必填项哦!")  
    private String name;  
  
    @ExcelVOAttribute(name = "性别", column = "C", combo = { "男", "女" })  
    private String sex;  
  
    @ExcelVOAttribute(name = "班级", column = "D", combo = { "五期提高班", "六期提高班",  
            "七期提高班" })  
    private String clazz;  
      
    @ExcelVOAttribute(name="生日",column="E")  
    private String birthday;  
  
    @ExcelVOAttribute(name = "公司", column = "F")  
    private String company;  
  
   //此处省略set()、get()方法
}  

(3)导出demo,注意convertStu2VO方法,这个方法中实现了我们导出时把编码转成有意义的文字功能.

package com.tgb.lk.test04;  
  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.text.SimpleDateFormat;  
import java.util.ArrayList;  
import java.util.Date;  
import java.util.List;  
  
import com.tgb.lk.util.ExcelUtil;  
  
/* 
 * 使用步骤: 
 * 1.新建一个类,例如StudentVO. 
 * 2.设置哪些属性需要导出,哪些需要设置提示. 
 * 3.设置实体数据 
 * 4.调用exportExcel方法. 
 * 本例向您提供以下问题的解决方案: 
 * 1.实体对象存放的值需要转换为其他文字的情况,例如:实例中有0,1表示男,女;而导入导出的excel中是中文的"男","女". 
 * 2.实体对象的时间类型处理. 
 *  
 */  
public class ExportTest04 {  
    public static void main(String[] args) {  
        // 初始化数据  
        List<Student> list = new ArrayList<Student>();  
  
        Student stu = new Student();  
        stu.setId(1);  
        stu.setName("李坤");  
        stu.setSex(0);  
        stu.setClazz(5);  
        stu.setCompany("天融信");  
        stu.setBirthday(new Date());  
        list.add(stu);  
  
        Student stu2 = new Student();  
        stu2.setId(2);  
        stu2.setName("曹贵生");  
        stu2.setSex(0);  
        stu2.setClazz(5);  
        stu2.setCompany("中银");  
        list.add(stu2);  
  
        Student stu3 = new Student();  
        stu3.setId(3);  
        stu3.setName("李学宇");  
        stu3.setSex(1);  
        stu3.setClazz(6);  
        list.add(stu3);  
  
        FileOutputStream out = null;  
        try {  
            out = new FileOutputStream("d:\\success4.xls");  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        }  
        ExcelUtil<StudentVO> util = new ExcelUtil<StudentVO>(StudentVO.class);  
        util.exportExcel(convertStu2VO(list), "学生信息", 60000, out);  
        System.out.println("----执行完毕----------");  
    }  
      
    //将student对象转换为studentVO用于导出.  
    private static List<StudentVO> convertStu2VO(List<Student> list) {  
        List<StudentVO> list2 = new ArrayList<StudentVO>();  
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/M/d HH:mm:ss");  
        for (int i = 0; i < list.size(); i++) {  
            StudentVO stuVo = new StudentVO();  
            Student stu = list.get(i);  
            stuVo.setName(stu.getName());  
            switch (stu.getSex()) {  
            case 0:  
                stuVo.setSex("男");  
                break;  
            case 1:  
                stuVo.setSex("女");  
                break;  
            default:  
                break;  
            }  
            //处理时间  
            if (stu.getBirthday() != null) {  
                stuVo.setBirthday(sdf.format(stu.getBirthday()));  
            }  
  
            switch (stu.getClazz()) {  
            case 5:  
                stuVo.setClazz("五期提高班");  
                break;  
            case 6:  
                stuVo.setClazz("六期提高班");  
                break;  
            case 7:  
                stuVo.setClazz("七期提高班");  
            default:  
                break;  
            }  
            list2.add(stuVo);  
        }  
  
        return list2;  
    }  
  
}  

(4)导入demo,在convertStu2VO这个方法中我们可以加一些逻辑控制.

package com.tgb.lk.test04;  
  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.text.ParseException;  
import java.text.SimpleDateFormat;  
import java.util.ArrayList;  
import java.util.List;  
  
import com.tgb.lk.util.ExcelUtil;  
  
public class ImportTest04 {  
    public static void main(String[] args) {  
        FileInputStream fis = null;  
        try {  
            fis = new FileInputStream("d:\\success4.xls");  
            ExcelUtil<StudentVO> util = new ExcelUtil<StudentVO>(  
                    StudentVO.class);  
            List<StudentVO> list = util.importExcel("学生信息", fis);  
            System.out.println(list);  
            //输出:[StudentVO [birthday=2012/9/22 15:44:10, clazz=五期提高班, company=null, name=李坤, sex=男], StudentVO [birthday=null, clazz=五期提高班, company=null, name=曹贵生, sex=男], StudentVO [birthday=null, clazz=六期提高班, company=null, name=李学宇, sex=女]]  
            System.out.println(convertStu2VO(list));  
            //输出:[Student [birthday=Sat Sep 22 15:44:10 CST 2012, clazz=5, company=null, id=0, name=李坤, sex=0], Student [birthday=null, clazz=5, company=null, id=0, name=曹贵生, sex=0], Student [birthday=null, clazz=6, company=null, id=0, name=李学宇, sex=1]]  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        }  
    }  
  
    private static List<Student> convertStu2VO(List<StudentVO> list) {  
        List<Student> retList = new ArrayList<Student>();  
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/M/d HH:mm:ss");  
        for (int i = 0; i < list.size(); i++) {  
            StudentVO vo = list.get(i);  
            Student student = new Student();  
            student.setName(vo.getName());  
  
            //在这个方法中还可以控制不允许为空,年龄值不能小于0后大于100等逻辑.  
              
            String sex = vo.getSex();  
            if (sex.equals("男")) {  
                student.setSex(0);  
            } else {  
                student.setSex(1);  
            }  
              
            if (vo.getBirthday()!=null && !vo.getBirthday().trim().equals("")) {  
                try {  
                    student.setBirthday(sdf.parse(vo.getBirthday()));  
                } catch (ParseException e) {  
                    e.printStackTrace();  
                }  
            }  
  
            String clazz = vo.getClazz();  
            if (clazz != null) {  
                if (clazz.equals("五期提高班")) {  
                    student.setClazz(5);  
                } else if (clazz.equals("六期提高班")) {  
                    student.setClazz(6);  
                } else if (clazz.equals("七期提高班")) {  
                    student.setClazz(7);  
                } else {  
                    System.out.println("输入的数据不合法");  
                }  
            }  
            retList.add(student);  
        }  
        return retList;  
    }  
}  

 

 

实现一个配置简单功能强大的excel工具类搞定excel导入导出
http://blog.csdn.net/lk_blog/article/details/8007777
http://blog.csdn.net/lk_blog/article/details/8007837

 

 代码下载: http://download.csdn.net/detail/lk_blog/4588280

      限于本人水平有限,很多地方写的并不完美,希望大家不吝赐教.如果觉得本文对您有帮助请顶支持一下,如果有不足之处欢迎留言交流,希望在和大家的交流中得到提高.

本文转载自:https://blog.csdn.net/lk_blog/article/details/8007777

时刻在奔跑
粉丝 3
博文 322
码字总数 110126
作品 0
安庆
私信 提问
加载中

评论(0)

配置简单功能强大的excel工具类搞定excel导入导出工具类(一)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/lk_blog/article/details/8007777 对于J2EE项目导入导出Excel是最普通和实用功能,本工具类使用步骤简单,功能强...

天赋吉运李坤
2012/09/22
0
0
Excel和Word 简易工具类,JEasyPoi 2.1.5 版本发布

Excel和Word 简易工具类,JEasyPoi 2.1.5 版本发布 摘要: jeasypoi 功能如同名字easy,主打的功能就是容易,让一个没见接触过poi的人员 就可以方便的写出Excel导出,Excel模板导出,Excel导入,...

Jeecg
2018/04/13
10
0
快速Office,PDF 开发 工具--EasyPoi

easypoi 功能如同名字easy,主打的功能就是易容,让一个没见接触过poi的人员 就可以方便的写出Excel导出,Excel模板导出,Excel导入,Word模板导出,通过简单的注解和模板 语言(熟悉的表达式语法)...

Anotherjueyue
2014/12/12
3.5W
12
web报表开发技术专题五:Excel的阴影

自从 n 年前 Excel 击败 Lotus ,独霸电子表格软件市场以来。所有的表格类软件都不能不充分考虑 Excel ,寻找 Excel 照顾不到的功能点。所有的表格类软件都要被迫考虑和 Excel 兼容,能够导入...

长平狐
2012/10/11
256
0
Excel 和 Word 简易工具类 JEasyPoi 2.1.5 发布

Excel 和 Word 简易工具类 JEasyPoi 2.1.5 发布。 JEasyPoi 功能如同名字easy,主打的功能就是容易,可以让一个没接触过poi的人方便地写出 Excel 导出、Excel 模板导出、Excel 导入与 Word 模...

Jeecg
2018/04/11
1.8K
1

没有更多内容

加载失败,请刷新页面

加载更多

什么是反射,为什么有用? - What is reflection and why is it useful?

问题: What is reflection, and why is it useful? 什么是反射,为什么有用? I'm particularly interested in Java, but I assume the principles are the same in any language. 我对Jav......

技术盛宴
29分钟前
3
0
SSM框架整合

mybatis逆向工程 mybatis-generator生成pojo、mapper接口及映射文件 mapper放到e3-manager-dao层中 导入sql到数据库中; 导入逆向工程工具,配置xml文件 运行main方法 重复运行main不会覆盖!...

七宝1
今天
30
0
OSChina 周日乱弹 —— 和网友的第一次开房经历

Osc乱弹歌单(2020)请戳(这里) 【今日歌曲】 @薛定谔的兄弟 :分享洛神有语创建的歌单「我喜欢的音乐」: 《Ljósið》- Ólafur Arnalds 手机党少年们想听歌,请使劲儿戳(这里) @xiaos...

小小编辑
今天
54
0
程序员职业生涯指引

程序员应该尽早规划自己的职业生涯 为什么写 众所周知 IT 这一行到了一定的年龄、大部分人都或多或少有危机感,特别是今年全国乃至全球发生的疫情、导致整体经济受到很大的影响、这次的疫情影...

科比可比克
今天
11
0
JVM调优实战分析

一、查看服务器项目JVM参数以及参数分析 1、jps 命令 : 列出系统中所有的 Java 应用程序以及PID 如下图所示,26647就是我部署在服务器的一个小项目的 PID 2、jmap命令:查看堆的使用情况 如...

IT-Mamba
今天
46
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部