java:POI导出excel详解编程语言

package com.cnblogs.yjmyzz.test.domain; 
 
public class AwbDto { 
 
    public AwbDto() { 
        super(); 
 
    } 
 
    public AwbDto(String awbNumber, String agent) { 
        super(); 
        this.awbNumber = awbNumber; 
        this.agent = agent; 
    } 
 
    /** 
     * 运单号 
     */ 
    private String awbNumber; 
 
    /** 
     * 代理人 
     */ 
    private String agent; 
 
    public String getAwbNumber() { 
        return awbNumber; 
    } 
 
    public void setAwbNumber(String awbNumber) { 
        this.awbNumber = awbNumber; 
    } 
 
    public String getAgent() { 
        return agent; 
    } 
 
    public void setAgent(String agent) { 
        this.agent = agent; 
    } 
} 

private List<AwbDto> getData1() { 
        List<AwbDto> data = new ArrayList<AwbDto>(); 
        for (int i = 0; i < 1000; i++) { 
            data.add(new AwbDto("112-" + FileUtil.leftPad(i + "", 8, '0'), "张三")); 
        } 
        return data; 
    } 
     
    private List<AwbDto> getData2() { 
        List<AwbDto> data = new ArrayList<AwbDto>(); 
        for (int i = 0; i < 1000; i++) { 
            data.add(new AwbDto("999-" + FileUtil.leftPad(i + "", 8, '0'), "李四")); 
        } 
        return data; 
    } 

@Test 
    public void testExcelExport() throws Exception { 
 
        // 创建excel 
        HSSFWorkbook wb = new HSSFWorkbook(); 
 
        // 创建sheet 
        HSSFSheet sheet = wb.createSheet("运单数据"); 
 
        // 创建一行 
        HSSFRow rowTitle = sheet.createRow(0); 
 
        // 创建标题栏样式 
        HSSFCellStyle styleTitle = wb.createCellStyle(); 
        styleTitle.setAlignment(HSSFCellStyle.ALIGN_CENTER);// 居中 
        HSSFFont fontTitle = wb.createFont(); 
        // 宋体加粗 
        fontTitle.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD); 
        fontTitle.setFontName("宋体"); 
        fontTitle.setFontHeight((short) 200); 
        styleTitle.setFont(fontTitle); 
 
        // 在行上创建1列 
        HSSFCell cellTitle = rowTitle.createCell(0); 
 
        // 列标题及样式 
        cellTitle.setCellValue("运单号"); 
        cellTitle.setCellStyle(styleTitle); 
 
        // 在行上创建2列 
        cellTitle = rowTitle.createCell(1); 
        cellTitle.setCellValue("代理人"); 
        cellTitle.setCellStyle(styleTitle); 
 
        HSSFCellStyle styleCenter = wb.createCellStyle(); 
        styleCenter.setAlignment(HSSFCellStyle.ALIGN_CENTER);// 居中 
 
        // 取数据 
        List<AwbDto> data = getData1(); 
 
        for (int i = 0; i < data.size(); i++) { 
 
            AwbDto item = data.get(i); 
            HSSFRow row = sheet.createRow(i + 1); 
 
            HSSFCell cell = row.createCell(0); 
            cell.setCellValue(item.getAwbNumber()); 
            cell.setCellStyle(styleCenter); 
 
            cell = row.createCell(1); 
            cell.setCellValue(item.getAgent()); 
            cell.setCellStyle(styleCenter); 
        } 
 
        FileOutputStream fout = new FileOutputStream("r:/awb.xls"); 
        wb.write(fout); 
        fout.close(); 
        wb.close(); 
 
        System.out.println("导出完成！"); 
    } 

package com.cnblogs.yjmyzz.utils; 
import java.io.ByteArrayOutputStream; 
import java.io.IOException; 
import java.text.SimpleDateFormat; 
import java.util.Date; 
import java.util.LinkedHashMap; 
import java.util.List; 
import java.util.Set; 
import java.util.Map.Entry; 
import org.apache.poi.hssf.usermodel.HSSFCell; 
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.usermodel.CellStyle; 
import org.apache.poi.ss.usermodel.Font; 
import org.apache.poi.ss.usermodel.IndexedColors; 
import org.apache.poi.ss.util.CellRangeAddress; 
public class ExcelUtil { 
private static HSSFWorkbook wb; 
private static CellStyle titleStyle; // 标题行样式 
private static Font titleFont; // 标题行字体 
private static CellStyle dateStyle; // 日期行样式 
private static Font dateFont; // 日期行字体 
private static CellStyle headStyle; // 表头行样式 
private static Font headFont; // 表头行字体 
private static CellStyle contentStyle; // 内容行样式 
private static Font contentFont; // 内容行字体 
/** 
* 导出文件 
*  
* @param setInfo 
* @param outputExcelFileName 
* @return 
* @throws IOException 
*/ 
public static boolean export2File(ExcelExportData setInfo, 
String outputExcelFileName) throws Exception { 
return FileUtil.write(outputExcelFileName, export2ByteArray(setInfo), 
true, true); 
} 
/** 
* 导出到byte数组 
*  
* @param setInfo 
* @return 
* @throws Exception 
*/ 
public static byte[] export2ByteArray(ExcelExportData setInfo) 
throws Exception { 
return export2Stream(setInfo).toByteArray(); 
} 
/** 
* 导出到流 
*  
* @param setInfo 
* @return 
* @throws Exception 
*/ 
public static ByteArrayOutputStream export2Stream(ExcelExportData setInfo) 
throws Exception { 
init(); 
ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); 
Set<Entry<String, List<?>>> set = setInfo.getDataMap().entrySet(); 
String[] sheetNames = new String[setInfo.getDataMap().size()]; 
int sheetNameNum = 0; 
for (Entry<String, List<?>> entry : set) { 
sheetNames[sheetNameNum] = entry.getKey(); 
sheetNameNum++; 
} 
HSSFSheet[] sheets = getSheets(setInfo.getDataMap().size(), sheetNames); 
int sheetNum = 0; 
for (Entry<String, List<?>> entry : set) { 
// Sheet 
List<?> objs = entry.getValue(); 
// 标题行 
createTableTitleRow(setInfo, sheets, sheetNum); 
// 日期行 
createTableDateRow(setInfo, sheets, sheetNum); 
// 表头 
creatTableHeadRow(setInfo, sheets, sheetNum); 
// 表体 
String[] fieldNames = setInfo.getFieldNames().get(sheetNum); 
int rowNum = 3; 
for (Object obj : objs) { 
HSSFRow contentRow = sheets[sheetNum].createRow(rowNum); 
contentRow.setHeight((short) 300); 
HSSFCell[] cells = getCells(contentRow, setInfo.getFieldNames() 
.get(sheetNum).length); 
int cellNum = 1; // 去掉一列序号，因此从1开始 
if (fieldNames != null) { 
for (int num = 0; num < fieldNames.length; num++) { 
Object value = ReflectionUtil.invokeGetterMethod(obj, 
fieldNames[num]); 
cells[cellNum].setCellValue(value == null ? "" : value 
.toString()); 
cellNum++; 
} 
} 
rowNum++; 
} 
adjustColumnSize(sheets, sheetNum, fieldNames); // 自动调整列宽 
sheetNum++; 
} 
wb.write(outputStream); 
return outputStream; 
} 
/** 
* @Description: 初始化 
*/ 
private static void init() { 
wb = new HSSFWorkbook(); 
titleFont = wb.createFont(); 
titleStyle = wb.createCellStyle(); 
dateStyle = wb.createCellStyle(); 
dateFont = wb.createFont(); 
headStyle = wb.createCellStyle(); 
headFont = wb.createFont(); 
contentStyle = wb.createCellStyle(); 
contentFont = wb.createFont(); 
initTitleCellStyle(); 
initTitleFont(); 
initDateCellStyle(); 
initDateFont(); 
initHeadCellStyle(); 
initHeadFont(); 
initContentCellStyle(); 
initContentFont(); 
} 
/** 
* @Description: 自动调整列宽 
*/ 
private static void adjustColumnSize(HSSFSheet[] sheets, int sheetNum, 
String[] fieldNames) { 
for (int i = 0; i < fieldNames.length + 1; i++) { 
sheets[sheetNum].autoSizeColumn(i, true); 
} 
} 
/** 
* @Description: 创建标题行(需合并单元格) 
*/ 
private static void createTableTitleRow(ExcelExportData setInfo, 
HSSFSheet[] sheets, int sheetNum) { 
CellRangeAddress titleRange = new CellRangeAddress(0, 0, 0, setInfo 
.getFieldNames().get(sheetNum).length); 
sheets[sheetNum].addMergedRegion(titleRange); 
HSSFRow titleRow = sheets[sheetNum].createRow(0); 
titleRow.setHeight((short) 800); 
HSSFCell titleCell = titleRow.createCell(0); 
titleCell.setCellStyle(titleStyle); 
titleCell.setCellValue(setInfo.getTitles()[sheetNum]); 
} 
/** 
* @Description: 创建日期行(需合并单元格) 
*/ 
private static void createTableDateRow(ExcelExportData setInfo, 
HSSFSheet[] sheets, int sheetNum) { 
CellRangeAddress dateRange = new CellRangeAddress(1, 1, 0, setInfo 
.getFieldNames().get(sheetNum).length); 
sheets[sheetNum].addMergedRegion(dateRange); 
HSSFRow dateRow = sheets[sheetNum].createRow(1); 
dateRow.setHeight((short) 350); 
HSSFCell dateCell = dateRow.createCell(0); 
dateCell.setCellStyle(dateStyle); 
// dateCell.setCellValue("导出时间：" + new 
// SimpleDateFormat("yyyy-MM-dd HH:mm:ss") 
// .format(new Date())); 
dateCell.setCellValue(new SimpleDateFormat("yyyy-MM-dd") 
.format(new Date())); 
} 
/** 
* @Description: 创建表头行(需合并单元格) 
*/ 
private static void creatTableHeadRow(ExcelExportData setInfo, 
HSSFSheet[] sheets, int sheetNum) { 
// 表头 
HSSFRow headRow = sheets[sheetNum].createRow(2); 
headRow.setHeight((short) 350); 
// 序号列 
HSSFCell snCell = headRow.createCell(0); 
snCell.setCellStyle(headStyle); 
snCell.setCellValue("序号"); 
// 列头名称 
for (int num = 1, len = setInfo.getColumnNames().get(sheetNum).length; num <= len; num++) { 
HSSFCell headCell = headRow.createCell(num); 
headCell.setCellStyle(headStyle); 
headCell.setCellValue(setInfo.getColumnNames().get(sheetNum)[num - 1]); 
} 
} 
/** 
* @Description: 创建所有的Sheet 
*/ 
private static HSSFSheet[] getSheets(int num, String[] names) { 
HSSFSheet[] sheets = new HSSFSheet[num]; 
for (int i = 0; i < num; i++) { 
sheets[i] = wb.createSheet(names[i]); 
} 
return sheets; 
} 
/** 
* @Description: 创建内容行的每一列(附加一列序号) 
*/ 
private static HSSFCell[] getCells(HSSFRow contentRow, int num) { 
HSSFCell[] cells = new HSSFCell[num + 1]; 
for (int i = 0, len = cells.length; i < len; i++) { 
cells[i] = contentRow.createCell(i); 
cells[i].setCellStyle(contentStyle); 
} 
// 设置序号列值，因为出去标题行和日期行，所有-2 
cells[0].setCellValue(contentRow.getRowNum() - 2); 
return cells; 
} 
/** 
* @Description: 初始化标题行样式 
*/ 
private static void initTitleCellStyle() { 
titleStyle.setAlignment(CellStyle.ALIGN_CENTER); 
titleStyle.setVerticalAlignment(CellStyle.VERTICAL_CENTER); 
titleStyle.setFont(titleFont); 
titleStyle.setFillBackgroundColor(IndexedColors.SKY_BLUE.index); 
} 
/** 
* @Description: 初始化日期行样式 
*/ 
private static void initDateCellStyle() { 
dateStyle.setAlignment(CellStyle.ALIGN_CENTER_SELECTION); 
dateStyle.setVerticalAlignment(CellStyle.VERTICAL_CENTER); 
dateStyle.setFont(dateFont); 
dateStyle.setFillBackgroundColor(IndexedColors.SKY_BLUE.index); 
} 
/** 
* @Description: 初始化表头行样式 
*/ 
private static void initHeadCellStyle() { 
headStyle.setAlignment(CellStyle.ALIGN_CENTER); 
headStyle.setVerticalAlignment(CellStyle.VERTICAL_CENTER); 
headStyle.setFont(headFont); 
headStyle.setFillBackgroundColor(IndexedColors.YELLOW.index); 
headStyle.setBorderTop(CellStyle.BORDER_MEDIUM); 
headStyle.setBorderBottom(CellStyle.BORDER_THIN); 
headStyle.setBorderLeft(CellStyle.BORDER_THIN); 
headStyle.setBorderRight(CellStyle.BORDER_THIN); 
headStyle.setTopBorderColor(IndexedColors.BLUE.index); 
headStyle.setBottomBorderColor(IndexedColors.BLUE.index); 
headStyle.setLeftBorderColor(IndexedColors.BLUE.index); 
headStyle.setRightBorderColor(IndexedColors.BLUE.index); 
} 
/** 
* @Description: 初始化内容行样式 
*/ 
private static void initContentCellStyle() { 
contentStyle.setAlignment(CellStyle.ALIGN_CENTER); 
contentStyle.setVerticalAlignment(CellStyle.VERTICAL_CENTER); 
contentStyle.setFont(contentFont); 
contentStyle.setBorderTop(CellStyle.BORDER_THIN); 
contentStyle.setBorderBottom(CellStyle.BORDER_THIN); 
contentStyle.setBorderLeft(CellStyle.BORDER_THIN); 
contentStyle.setBorderRight(CellStyle.BORDER_THIN); 
contentStyle.setTopBorderColor(IndexedColors.BLUE.index); 
contentStyle.setBottomBorderColor(IndexedColors.BLUE.index); 
contentStyle.setLeftBorderColor(IndexedColors.BLUE.index); 
contentStyle.setRightBorderColor(IndexedColors.BLUE.index); 
contentStyle.setWrapText(true); // 字段换行 
} 
/** 
* @Description: 初始化标题行字体 
*/ 
private static void initTitleFont() { 
titleFont.setFontName("华文楷体"); 
titleFont.setFontHeightInPoints((short) 20); 
titleFont.setBoldweight(Font.BOLDWEIGHT_BOLD); 
titleFont.setCharSet(Font.DEFAULT_CHARSET); 
titleFont.setColor(IndexedColors.BLUE_GREY.index); 
} 
/** 
* @Description: 初始化日期行字体 
*/ 
private static void initDateFont() { 
dateFont.setFontName("隶书"); 
dateFont.setFontHeightInPoints((short) 10); 
dateFont.setBoldweight(Font.BOLDWEIGHT_BOLD); 
dateFont.setCharSet(Font.DEFAULT_CHARSET); 
dateFont.setColor(IndexedColors.BLUE_GREY.index); 
} 
/** 
* @Description: 初始化表头行字体 
*/ 
private static void initHeadFont() { 
headFont.setFontName("宋体"); 
headFont.setFontHeightInPoints((short) 10); 
headFont.setBoldweight(Font.BOLDWEIGHT_BOLD); 
headFont.setCharSet(Font.DEFAULT_CHARSET); 
headFont.setColor(IndexedColors.BLUE_GREY.index); 
} 
/** 
* @Description: 初始化内容行字体 
*/ 
private static void initContentFont() { 
contentFont.setFontName("宋体"); 
contentFont.setFontHeightInPoints((short) 10); 
contentFont.setBoldweight(Font.BOLDWEIGHT_NORMAL); 
contentFont.setCharSet(Font.DEFAULT_CHARSET); 
contentFont.setColor(IndexedColors.BLUE_GREY.index); 
} 
/** 
* Excel导出数据类 
*  
* @author jimmy 
* 
*/ 
public static class ExcelExportData { 
/** 
* 导出数据 key:String 表示每个Sheet的名称 value:List<?> 表示每个Sheet里的所有数据行 
*/ 
private LinkedHashMap<String, List<?>> dataMap; 
/** 
* 每个Sheet里的顶部大标题 
*/ 
private String[] titles; 
/** 
* 单个sheet里的数据列标题 
*/ 
private List<String[]> columnNames; 
/** 
* 单个sheet里每行数据的列对应的对象属性名称 
*/ 
private List<String[]> fieldNames; 
public List<String[]> getFieldNames() { 
return fieldNames; 
} 
public void setFieldNames(List<String[]> fieldNames) { 
this.fieldNames = fieldNames; 
} 
public String[] getTitles() { 
return titles; 
} 
public void setTitles(String[] titles) { 
this.titles = titles; 
} 
public List<String[]> getColumnNames() { 
return columnNames; 
} 
public void setColumnNames(List<String[]> columnNames) { 
this.columnNames = columnNames; 
} 
public LinkedHashMap<String, List<?>> getDataMap() { 
return dataMap; 
} 
public void setDataMap(LinkedHashMap<String, List<?>> dataMap) { 
this.dataMap = dataMap; 
} 
} 
} 

package com.cnblogs.yjmyzz.utils; 
import java.lang.reflect.Field; 
import java.lang.reflect.InvocationTargetException; 
import java.lang.reflect.Method; 
import java.lang.reflect.Modifier; 
import java.lang.reflect.ParameterizedType; 
import java.lang.reflect.Type; 
import java.util.ArrayList; 
import java.util.Collection; 
import java.util.Date; 
import java.util.List; 
import org.apache.commons.beanutils.BeanUtils; 
import org.apache.commons.beanutils.ConvertUtils; 
import org.apache.commons.beanutils.PropertyUtils; 
import org.apache.commons.beanutils.locale.converters.DateLocaleConverter; 
import org.apache.commons.lang.StringUtils; 
import org.apache.commons.logging.Log; 
import org.apache.commons.logging.LogFactory; 
import org.springframework.util.Assert; 
/** 
* 反射工具类. 
*  
* 提供访问私有变量,获取泛型类型Class, 提取集合中元素的属性, 转换字符串到对象等Util函数. 
*  
*/ 
public class ReflectionUtil { 
private static Log logger = LogFactory.getLog(ReflectionUtil.class); 
static { 
DateLocaleConverter dc = new DateLocaleConverter(); 
// dc.setPatterns(new String[] { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss" }); 
ConvertUtils.register(dc, Date.class); 
} 
/** 
* 调用Getter方法. 
*/ 
public static Object invokeGetterMethod(Object target, String propertyName) { 
String getterMethodName = "get" + StringUtils.capitalize(propertyName); 
return invokeMethod(target, getterMethodName, new Class[] {}, 
new Object[] {}); 
} 
/** 
* 调用Setter方法.使用value的Class来查找Setter方法. 
*/ 
public static void invokeSetterMethod(Object target, String propertyName, 
Object value) { 
invokeSetterMethod(target, propertyName, value, null); 
} 
/** 
* 调用Setter方法. 
*  
* @param propertyType 
*            用于查找Setter方法,为空时使用value的Class替代. 
*/ 
public static void invokeSetterMethod(Object target, String propertyName, 
Object value, Class<?> propertyType) { 
Class<?> type = propertyType != null ? propertyType : value.getClass(); 
String setterMethodName = "set" + StringUtils.capitalize(propertyName); 
invokeMethod(target, setterMethodName, new Class[] { type }, 
new Object[] { value }); 
} 
/** 
* 直接读取对象属性值, 无视private/protected修饰符, 不经过getter函数. 
*/ 
public static Object getFieldValue(final Object object, 
final String fieldName) { 
Field field = getDeclaredField(object, fieldName); 
if (field == null) { 
throw new IllegalArgumentException("Could not find field [" 
+ fieldName + "] on target [" + object + "]"); 
} 
makeAccessible(field); 
Object result = null; 
try { 
result = field.get(object); 
} catch (IllegalAccessException e) { 
logger.error("不可能抛出的异常{}" + e.getMessage()); 
} 
return result; 
} 
/** 
* 直接设置对象属性值, 无视private/protected修饰符, 不经过setter函数. 
*/ 
public static void setFieldValue(final Object object, 
final String fieldName, final Object value) { 
Field field = getDeclaredField(object, fieldName); 
if (field == null) { 
throw new IllegalArgumentException("Could not find field [" 
+ fieldName + "] on target [" + object + "]"); 
} 
makeAccessible(field); 
try { 
field.set(object, value); 
} catch (IllegalAccessException e) { 
logger.error("不可能抛出的异常:{}" + e.getMessage()); 
} 
} 
/** 
* 直接调用对象方法, 无视private/protected修饰符. 
*/ 
public static Object invokeMethod(final Object object, 
final String methodName, final Class<?>[] parameterTypes, 
final Object[] parameters) { 
Method method = getDeclaredMethod(object, methodName, parameterTypes); 
if (method == null) { 
throw new IllegalArgumentException("Could not find method [" 
+ methodName + "] parameterType " + parameterTypes 
+ " on target [" + object + "]"); 
} 
method.setAccessible(true); 
try { 
return method.invoke(object, parameters); 
} catch (Exception e) { 
throw convertReflectionExceptionToUnchecked(e); 
} 
} 
/** 
* 循环向上转型, 获取对象的DeclaredField. 
*  
* 如向上转型到Object仍无法找到, 返回null. 
*/ 
protected static Field getDeclaredField(final Object object, 
final String fieldName) { 
Assert.notNull(object, "object不能为空"); 
Assert.hasText(fieldName, "fieldName"); 
for (Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass 
.getSuperclass()) { 
try { 
return superClass.getDeclaredField(fieldName); 
} catch (NoSuchFieldException e) {// NOSONAR 
// Field不在当前类定义,继续向上转型 
} 
} 
return null; 
} 
/** 
* 强行设置Field可访问. 
*/ 
protected static void makeAccessible(final Field field) { 
if (!Modifier.isPublic(field.getModifiers()) 
|| !Modifier.isPublic(field.getDeclaringClass().getModifiers())) { 
field.setAccessible(true); 
} 
} 
/** 
* 循环向上转型, 获取对象的DeclaredMethod. 
*  
* 如向上转型到Object仍无法找到, 返回null. 
*/ 
protected static Method getDeclaredMethod(Object object, String methodName, 
Class<?>[] parameterTypes) { 
Assert.notNull(object, "object不能为空"); 
for (Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass 
.getSuperclass()) { 
try { 
return superClass.getDeclaredMethod(methodName, parameterTypes); 
} catch (NoSuchMethodException e) {// NOSONAR 
// Method不在当前类定义,继续向上转型 
} 
} 
return null; 
} 
/** 
* 通过反射, 获得Class定义中声明的父类的泛型参数的类型. 如无法找到, 返回Object.class. eg. public UserDao 
* extends HibernateDao<User> 
*  
* @param clazz 
*            The class to introspect 
* @return the first generic declaration, or Object.class if cannot be 
*         determined 
*/ 
@SuppressWarnings("unchecked") 
public static <T> Class<T> getSuperClassGenricType(final Class<?> clazz) { 
return getSuperClassGenricType(clazz, 0); 
} 
/** 
* 通过反射, 获得定义Class时声明的父类的泛型参数的类型. 如无法找到, 返回Object.class. 
*  
* 如public UserDao extends HibernateDao<User,Long> 
*  
* @param clazz 
*            clazz The class to introspect 
* @param index 
*            the Index of the generic ddeclaration,start from 0. 
* @return the index generic declaration, or Object.class if cannot be 
*         determined 
*/ 
@SuppressWarnings("unchecked") 
public static Class getSuperClassGenricType(final Class<?> clazz, 
final int index) { 
Type genType = clazz.getGenericSuperclass(); 
if (!(genType instanceof ParameterizedType)) { 
logger.warn(clazz.getSimpleName() 
+ "'s superclass not ParameterizedType"); 
return Object.class; 
} 
Type[] params = ((ParameterizedType) genType).getActualTypeArguments(); 
if (index >= params.length || index < 0) { 
logger.warn("Index: " + index + ", Size of " 
+ clazz.getSimpleName() + "'s Parameterized Type: " 
+ params.length); 
return Object.class; 
} 
if (!(params[index] instanceof Class)) { 
logger.warn(clazz.getSimpleName() 
+ " not set the actual class on superclass generic parameter"); 
return Object.class; 
} 
return (Class) params[index]; 
} 
/** 
* 提取集合中的对象的属性(通过getter函数), 组合成List. 
*  
* @param collection 
*            来源集合. 
* @param propertyName 
*            要提取的属性名. 
*/ 
public static List convertElementPropertyToList( 
final Collection collection, final String propertyName) { 
List list = new ArrayList(); 
try { 
for (Object obj : collection) { 
list.add(PropertyUtils.getProperty(obj, propertyName)); 
} 
} catch (Exception e) { 
throw convertReflectionExceptionToUnchecked(e); 
} 
return list; 
} 
/** 
* 提取集合中的对象的属性(通过getter函数), 组合成由分割符分隔的字符串. 
*  
* @param collection 
*            来源集合. 
* @param propertyName 
*            要提取的属性名. 
* @param separator 
*            分隔符. 
*/ 
@SuppressWarnings("unchecked") 
public static String convertElementPropertyToString( 
final Collection collection, final String propertyName, 
final String separator) { 
List list = convertElementPropertyToList(collection, propertyName); 
return StringUtils.join(list, separator); 
} 
/** 
* 转换字符串到相应类型. 
*  
* @param value 
*            待转换的字符串 
* @param toType 
*            转换目标类型 
*/ 
@SuppressWarnings("unchecked") 
public static <T> T convertStringToObject(String value, Class<T> toType) { 
try { 
return (T) ConvertUtils.convert(value, toType); 
} catch (Exception e) { 
throw convertReflectionExceptionToUnchecked(e); 
} 
} 
/** 
* 将反射时的checked exception转换为unchecked exception. 
*/ 
public static RuntimeException convertReflectionExceptionToUnchecked( 
Exception e) { 
return convertReflectionExceptionToUnchecked(null, e); 
} 
public static RuntimeException convertReflectionExceptionToUnchecked( 
String desc, Exception e) { 
desc = (desc == null) ? "Unexpected Checked Exception." : desc; 
if (e instanceof IllegalAccessException 
|| e instanceof IllegalArgumentException 
|| e instanceof NoSuchMethodException) { 
return new IllegalArgumentException(desc, e); 
} else if (e instanceof InvocationTargetException) { 
return new RuntimeException(desc, 
((InvocationTargetException) e).getTargetException()); 
} else if (e instanceof RuntimeException) { 
return (RuntimeException) e; 
} 
return new RuntimeException(desc, e); 
} 
public static final <T> T getNewInstance(Class<T> cls) { 
try { 
return cls.newInstance(); 
} catch (InstantiationException e) { 
e.printStackTrace(); 
} catch (IllegalAccessException e) { 
e.printStackTrace(); 
} 
return null; 
} 
/** 
* 拷贝 source 指定的porperties 属性 到 dest中 
*  
* @return void 
* @throws InvocationTargetException 
* @throws IllegalAccessException 
*/ 
public static void copyPorperties(Object dest, Object source, 
String[] porperties) throws InvocationTargetException, 
IllegalAccessException { 
for (String por : porperties) { 
Object srcObj = invokeGetterMethod(source, por); 
logger.debug("属性名：" + por + "------------- 属性值：" + srcObj); 
if (srcObj != null) { 
try { 
BeanUtils.setProperty(dest, por, srcObj); 
} catch (IllegalArgumentException e) { 
e.printStackTrace(); 
} catch (IllegalAccessException e) { 
throw e; 
} catch (InvocationTargetException e) { 
throw e; 
} 
} 
} 
} 
/** 
* 两者属性名一致时，拷贝source里的属性到dest里 
*  
* @return void 
* @throws IllegalAccessException 
* @throws InvocationTargetException 
*/ 
public static void copyPorperties(Object dest, Object source) 
throws IllegalAccessException, InvocationTargetException { 
Class<? extends Object> srcCla = source.getClass(); 
Field[] fsF = srcCla.getDeclaredFields(); 
for (Field s : fsF) { 
String name = s.getName(); 
Object srcObj = invokeGetterMethod(source, name); 
try { 
BeanUtils.setProperty(dest, name, srcObj); 
} catch (IllegalArgumentException e) { 
e.printStackTrace(); 
} catch (IllegalAccessException e) { 
throw e; 
} catch (InvocationTargetException e) { 
throw e; 
} 
} 
// BeanUtils.copyProperties(dest, orig); 
} 
public static void main(String[] args) throws InvocationTargetException, 
IllegalAccessException { 
/* 
* Document document = new Document(); document.setId(2); 
* document.setCreateDate(new Date()); DocumentVo dcoVo = new 
* DocumentVo(); ReflectionUtils.copyPorperties(dcoVo, document,new 
* String[]{"id","businessName","createDate","applyName","docTitle", 
* "transactStatus"}); System.out.println(dcoVo.getId()); 
*/ 
} 
} 

package com.cnblogs.yjmyzz.utils; 
import java.io.*; 
import java.util.*; 
import java.util.concurrent.*; 
/** 
* 文件处理辅助类 
*  
* @author [email protected] 
* @version 0.2 
* @since 2014-11-17 
* 
*/ 
public class FileUtil { 
/** 
* 当前目录路径 
*/ 
public static String currentWorkDir = System.getProperty("user.dir") + "//"; 
/** 
* 左填充 
*  
* @param str 
* @param length 
* @param ch 
* @return 
*/ 
public static String leftPad(String str, int length, char ch) { 
if (str.length() >= length) { 
return str; 
} 
char[] chs = new char[length]; 
Arrays.fill(chs, ch); 
char[] src = str.toCharArray(); 
System.arraycopy(src, 0, chs, length - src.length, src.length); 
return new String(chs); 
} 
/** 
* 删除文件 
*  
* @param fileName 
*            待删除的完整文件名 
* @return 
*/ 
public static boolean delete(String fileName) { 
boolean result = false; 
File f = new File(fileName); 
if (f.exists()) { 
result = f.delete(); 
} else { 
result = true; 
} 
return result; 
} 
/*** 
* 递归获取指定目录下的所有的文件（不包括文件夹） 
*  
* @param obj 
* @return 
*/ 
public static ArrayList<File> getAllFiles(String dirPath) { 
File dir = new File(dirPath); 
ArrayList<File> files = new ArrayList<File>(); 
if (dir.isDirectory()) { 
File[] fileArr = dir.listFiles(); 
for (int i = 0; i < fileArr.length; i++) { 
File f = fileArr[i]; 
if (f.isFile()) { 
files.add(f); 
} else { 
files.addAll(getAllFiles(f.getPath())); 
} 
} 
} 
return files; 
} 
/** 
* 获取指定目录下的所有文件(不包括子文件夹) 
*  
* @param dirPath 
* @return 
*/ 
public static ArrayList<File> getDirFiles(String dirPath) { 
File path = new File(dirPath); 
File[] fileArr = path.listFiles(); 
ArrayList<File> files = new ArrayList<File>(); 
for (File f : fileArr) { 
if (f.isFile()) { 
files.add(f); 
} 
} 
return files; 
} 
/** 
* 获取指定目录下特定文件后缀名的文件列表(不包括子文件夹) 
*  
* @param dirPath 
*            目录路径 
* @param suffix 
*            文件后缀 
* @return 
*/ 
public static ArrayList<File> getDirFiles(String dirPath, 
final String suffix) { 
File path = new File(dirPath); 
File[] fileArr = path.listFiles(new FilenameFilter() { 
public boolean accept(File dir, String name) { 
String lowerName = name.toLowerCase(); 
String lowerSuffix = suffix.toLowerCase(); 
if (lowerName.endsWith(lowerSuffix)) { 
return true; 
} 
return false; 
} 
}); 
ArrayList<File> files = new ArrayList<File>(); 
for (File f : fileArr) { 
if (f.isFile()) { 
files.add(f); 
} 
} 
return files; 
} 
/** 
* 读取文件内容 
*  
* @param fileName 
*            待读取的完整文件名 
* @return 文件内容 
* @throws IOException 
*/ 
public static String read(String fileName) throws IOException { 
File f = new File(fileName); 
FileInputStream fs = new FileInputStream(f); 
String result = null; 
byte[] b = new byte[fs.available()]; 
fs.read(b); 
fs.close(); 
result = new String(b); 
return result; 
} 
/** 
* 写文件 
*  
* @param fileName 
*            目标文件名 
* @param fileContent 
*            写入的内容 
* @return 
* @throws IOException 
*/ 
public static boolean write(String fileName, String fileContent) 
throws IOException { 
return write(fileName, fileContent, true, true); 
} 
/** 
* 写文件 
*  
* @param fileName 
*            完整文件名(类似：/usr/a/b/c/d.txt) 
* @param fileContent 
*            文件内容 
* @param autoCreateDir 
*            目录不存在时，是否自动创建(多级)目录 
* @param autoOverWrite 
*            目标文件存在时，是否自动覆盖 
* @return 
* @throws IOException 
*/ 
public static boolean write(String fileName, String fileContent, 
boolean autoCreateDir, boolean autoOverwrite) throws IOException { 
return write(fileName, fileContent.getBytes(), autoCreateDir, 
autoOverwrite); 
} 
/** 
* 写文件 
*  
* @param fileName 
*            完整文件名(类似：/usr/a/b/c/d.txt) 
* @param contentBytes 
*            文件内容的字节数组 
* @param autoCreateDir 
*            目录不存在时，是否自动创建(多级)目录 
* @param autoOverWrite 
*            目标文件存在时，是否自动覆盖 
* @return 
* @throws IOException 
*/ 
public static boolean write(String fileName, byte[] contentBytes, 
boolean autoCreateDir, boolean autoOverwrite) throws IOException { 
boolean result = false; 
if (autoCreateDir) { 
createDirs(fileName); 
} 
if (autoOverwrite) { 
delete(fileName); 
} 
File f = new File(fileName); 
FileOutputStream fs = new FileOutputStream(f); 
fs.write(contentBytes); 
fs.flush(); 
fs.close(); 
result = true; 
return result; 
} 
/** 
* 追加内容到指定文件 
*  
* @param fileName 
* @param fileContent 
* @return 
* @throws IOException 
*/ 
public static boolean append(String fileName, String fileContent) 
throws IOException { 
boolean result = false; 
File f = new File(fileName); 
if (f.exists()) { 
RandomAccessFile rFile = new RandomAccessFile(f, "rw"); 
byte[] b = fileContent.getBytes(); 
long originLen = f.length(); 
rFile.setLength(originLen + b.length); 
rFile.seek(originLen); 
rFile.write(b); 
rFile.close(); 
} 
result = true; 
return result; 
} 
/** 
* 拆分文件 
*  
* @param fileName 
*            待拆分的完整文件名 
* @param byteSize 
*            按多少字节大小拆分 
* @return 拆分后的文件名列表 
* @throws IOException 
*/ 
public List<String> splitBySize(String fileName, int byteSize) 
throws IOException { 
List<String> parts = new ArrayList<String>(); 
File file = new File(fileName); 
int count = (int) Math.ceil(file.length() / (double) byteSize); 
int countLen = (count + "").length(); 
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(count, 
count * 3, 1, TimeUnit.SECONDS, 
new ArrayBlockingQueue<Runnable>(count * 2)); 
for (int i = 0; i < count; i++) { 
String partFileName = file.getPath() + "." 
+ leftPad((i + 1) + "", countLen, '0') + ".part"; 
threadPool.execute(new SplitRunnable(byteSize, i * byteSize, 
partFileName, file)); 
parts.add(partFileName); 
} 
return parts; 
} 
/** 
* 合并文件 
*  
* @param dirPath 
*            拆分文件所在目录名 
* @param partFileSuffix 
*            拆分文件后缀名 
* @param partFileSize 
*            拆分文件的字节数大小 
* @param mergeFileName 
*            合并后的文件名 
* @throws IOException 
*/ 
public void mergePartFiles(String dirPath, String partFileSuffix, 
int partFileSize, String mergeFileName) throws IOException { 
ArrayList<File> partFiles = FileUtil.getDirFiles(dirPath, 
partFileSuffix); 
Collections.sort(partFiles, new FileComparator()); 
RandomAccessFile randomAccessFile = new RandomAccessFile(mergeFileName, 
"rw"); 
randomAccessFile.setLength(partFileSize * (partFiles.size() - 1) 
+ partFiles.get(partFiles.size() - 1).length()); 
randomAccessFile.close(); 
ThreadPoolExecutor threadPool = new ThreadPoolExecutor( 
partFiles.size(), partFiles.size() * 3, 1, TimeUnit.SECONDS, 
new ArrayBlockingQueue<Runnable>(partFiles.size() * 2)); 
for (int i = 0; i < partFiles.size(); i++) { 
threadPool.execute(new MergeRunnable(i * partFileSize, 
mergeFileName, partFiles.get(i))); 
} 
} 
/** 
* 根据文件名，比较文件 
*  
* @author [email protected] 
* 
*/ 
private class FileComparator implements Comparator<File> { 
public int compare(File o1, File o2) { 
return o1.getName().compareToIgnoreCase(o2.getName()); 
} 
} 
/** 
* 创建(多级)目录 
*  
* @param filePath 
*            完整的文件名(类似：/usr/a/b/c/d.xml) 
*/ 
public static void createDirs(String filePath) { 
File file = new File(filePath); 
File parent = file.getParentFile(); 
if (parent != null && !parent.exists()) { 
parent.mkdirs(); 
} 
} 
/** 
* 分割处理Runnable 
*  
* @author [email protected] 
* 
*/ 
private class SplitRunnable implements Runnable { 
int byteSize; 
String partFileName; 
File originFile; 
int startPos; 
public SplitRunnable(int byteSize, int startPos, String partFileName, 
File originFile) { 
this.startPos = startPos; 
this.byteSize = byteSize; 
this.partFileName = partFileName; 
this.originFile = originFile; 
} 
public void run() { 
RandomAccessFile rFile; 
OutputStream os; 
try { 
rFile = new RandomAccessFile(originFile, "r"); 
byte[] b = new byte[byteSize]; 
rFile.seek(startPos);// 移动指针到每“段”开头 
int s = rFile.read(b); 
os = new FileOutputStream(partFileName); 
os.write(b, 0, s); 
os.flush(); 
os.close(); 
} catch (IOException e) { 
e.printStackTrace(); 
} 
} 
} 
/** 
* 合并处理Runnable 
*  
* @author [email protected] 
* 
*/ 
private class MergeRunnable implements Runnable { 
long startPos; 
String mergeFileName; 
File partFile; 
public MergeRunnable(long startPos, String mergeFileName, File partFile) { 
this.startPos = startPos; 
this.mergeFileName = mergeFileName; 
this.partFile = partFile; 
} 
public void run() { 
RandomAccessFile rFile; 
try { 
rFile = new RandomAccessFile(mergeFileName, "rw"); 
rFile.seek(startPos); 
FileInputStream fs = new FileInputStream(partFile); 
byte[] b = new byte[fs.available()]; 
fs.read(b); 
fs.close(); 
rFile.write(b); 
rFile.close(); 
} catch (IOException e) { 
e.printStackTrace(); 
} 
} 
} 
} 

@Test 
public void testExcel() throws Exception { 
List<String[]> columNames = new ArrayList<String[]>(); 
columNames.add(new String[] { "运单号", "代理人" }); 
columNames.add(new String[] { "运单号", "代理人" }); 
List<String[]> fieldNames = new ArrayList<String[]>(); 
fieldNames.add(new String[] { "awbNumber", "agent" }); 
fieldNames.add(new String[] { "awbNumber", "agent" }); 
LinkedHashMap<String, List<?>> map = new LinkedHashMap<String, List<?>>(); 
map.put("运单月报(1月)", getData1()); 
map.put("运单月报(2月)", getData2()); 
ExcelExportData setInfo = new ExcelExportData(); 
setInfo.setDataMap(map); 
setInfo.setFieldNames(fieldNames); 
setInfo.setTitles(new String[] { "航空运单报表1","航空运单报表2"}); 
setInfo.setColumnNames(columNames); 
// 将需要导出的数据输出到文件 
System.out.println(ExcelUtil.export2File(setInfo, "r:/test.xls")); 
}