SpringMVC操作Excel

最新推荐文章于 2023-11-13 16:18:59 发布
最新推荐文章于 2023-11-13 16:18:59 发布
阅读量608 收藏
点赞数
分类专栏： JAVAEE

POI操作Excel，读取，写入

package com.ucf.boss.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
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.Font;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.VerticalAlignment;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;



public class PoiUtils {
	private static final Logger LOGGER = LoggerFactory
			.getLogger(PoiUtils.class);
	 /* LONG */
	protected static final String LONG = "java.lang.Long";
	/* SHORT */
	protected static final String SHORT = "java.lang.Short";
	/* INT */
	protected static final String INT = "java.lang.Integer";
	/* STRING */
	protected static final String STRING = "java.lang.String";
	/* DATE */
	protected static final String DATE = "java.sql.Timestamp";
	/* BIG */
	protected static final String BIG = "java.math.BigDecimal";
	/* CLOB */
	protected static final String CLOB = "oracle.sql.CLOB";
	
	public static void main(String[] args) throws FileNotFoundException {
		
		String path ="C:/Program Files/feiq/AutoRecv Files/IP梳理记录表(1)(2).xlsx";
		File file = new File(path);
		InputStream inputStream = new FileInputStream(file);
		int count = getRecordsCountReadStream(inputStream,1, false, 0);
		System.out.print(count);
	}
	
	
	/**
	 * 通过文件路径获取Excel读取行数
	 * @param path 文件路径，只接受xls或xlsx结尾
	 * @param isHeader 是否表头
	 * @param headerCount 表头行数
	 * @return count 如果文件路径为空，返回0；
	 */
	public static int getRecordsCountReadPath(String path, boolean isHeader, int headerCount) {
		
		int count = 0;
		
		if(path == null){
			return count;
		}else if(!path.endsWith("xls") && !path.endsWith("xlsx")
			  && !path.endsWith("XLS") && !path.endsWith("XLSX")){
			return count;
		}
		
		try {
			File file = new File(path);
			InputStream inputStream = new FileInputStream(file);
			Workbook hwb = null;
			if(path.endsWith("xls") || path.endsWith("XLS")){
				hwb = new HSSFWorkbook(inputStream);
			}else if(path.endsWith("xlsx") || path.endsWith("XLSX")){
				hwb = new XSSFWorkbook(inputStream);
			}
			
			if (null==hwb) {
				return count;
			}
			
			Sheet sheet = hwb.getSheetAt(0);//暂定只取首页签
			int begin = sheet.getFirstRowNum();
			if(isHeader){
				begin += headerCount;
			}
			int end = sheet.getLastRowNum(); 
			for (int i = begin; i <= end; i++) {  
				if (null == sheet.getRow(i)) {  
					continue;  
				}  
				count++;  
			}  
			
		} catch (FileNotFoundException e) {  
			LOGGER.error("excel解析:", e);
			return 0;
		} catch (IOException e) {  
			LOGGER.error("excel解析:", e);
			return 0;
		}
		return count;
	}
	
	/**
	 * 通过文件流获取Excel读取行数
	 * @param path 文件路径
	 * @param type 类型，0为xls，1为xlsx；
	 * @param isHeader 是否表头
	 * @param headerCount 表头行数
	 * @return count 如果文件路径为空，返回0；
	 */
	public static int getRecordsCountReadStream(InputStream inputStream,int type, boolean isHeader, int headerCount) {
			
		int count = 0;
		if(type != 0 && type != 1){
			return count;
		}
		
		try {
			Workbook hwb = null;
			if(type == 0){
				hwb = new HSSFWorkbook(inputStream); 
			}else if(type == 1) {
				hwb = new XSSFWorkbook(inputStream);
			}
			
			if (null==hwb) {
				return count;
			}
			
			Sheet sheet = hwb.getSheetAt(0);
			int begin = sheet.getFirstRowNum(); 
			if(isHeader){
				begin += headerCount;
			}
			int end = sheet.getLastRowNum(); 
			for (int i = begin; i <= end; i++) {  
				if (null == sheet.getRow(i)) {  
					continue;  
				}  
				count++;  
			}  
		} catch (FileNotFoundException e) {  
			LOGGER.error("excel解析:", e);
			return 0;
		} catch (IOException e) {  
			LOGGER.error("excel解析:", e);
			return 0;
		}
		return count;
	}
	
	/**
	 * 通过文件流获取Excel读取
	 * @param path 文件路径
	 * @param type 类型，0为xls，1为xlsx；
	 * @param isHeader 是否表头
	 * @param headerCount 表头行数
	 * @return poiList 如果文件路径为空，返回0；
	 */
	public static List<String[]> readRecordsInputStream(InputStream inputStream, int type, boolean isHeader, int headerCount) {
		List<String[]> poiList = new ArrayList<String[]>();
		if(type != 0 && type != 1){
			return null;
		}
		if(type == 0){
			poiList = readXLSRecords(inputStream, isHeader, headerCount); 
		}else if(type == 1) {
			poiList = readXLSXRecords(inputStream, isHeader, headerCount); 
		}
		return poiList;
	}
	
	/**
	 * 通过文件路径获取Excel读取
	 * @param path 文件路径，只接受xls或xlsx结尾
	 * @param isHeader 是否表头
	 * @param headerCount 表头行数
	 * @return count 如果文件路径为空，返回0；
	 */
	public static List<String[]> readRecordsInputPath(String path, boolean isHeader, int headerCount) {
		List<String[]> poiList = new ArrayList<String[]>();
		if(path == null){
			return null;
		}else if(!path.endsWith("xls") && !path.endsWith("xlsx")
			  && !path.endsWith("XLS") && !path.endsWith("XLSX")){
			return null;
		}
		File file = new File(path);
		try {
			InputStream inputStream = new FileInputStream(file);
			
			if(path.endsWith("xls") || path.endsWith("XLS")){
				poiList = readXLSRecords(inputStream, isHeader, headerCount); 
			}else if(path.endsWith("xlsx") || path.endsWith("XLSX")){
				poiList = readXLSXRecords(inputStream, isHeader, headerCount); 
			}
		} catch (Exception e) {  
			LOGGER.error("excel解析:", e);
			return null;
		}
		return poiList;
	}
	
	/**
	 * 解析EXCEL2003文件流
	 * 如果一行记录的行中或行尾出现空格，POI工具类可能会跳过空格不做处理，所以默认第一行是表头，所有待解析的记录都以表头为准
	 * @param inputStream  输入流
	 * @param isHeader  是否要跳过表头
	 * @param headerCount  表头占用行数
	 * @return 返回一个字符串数组List
	 */
	public static List<String[]> readXLSRecords(InputStream inputStream, boolean isHeader, int headerCount) {
		   List<String[]> poiList = new ArrayList<String[]>();
		   try{
			   HSSFWorkbook wbs = new HSSFWorkbook(inputStream);
			   HSSFSheet childSheet = wbs.getSheetAt(0);
			   //获取表头
			   int begin = childSheet.getFirstRowNum(); 
			   HSSFRow firstRow = childSheet.getRow(begin);
			   int cellTotal = firstRow.getPhysicalNumberOfCells();
			   //是否跳过表头解析数据
			   if(isHeader){
					begin += headerCount;
			   }
			   //逐行获取单元格数据
			   for(int i = begin;i <= childSheet.getLastRowNum();i++){
				   HSSFRow row = childSheet.getRow(i); //一行的所有单元格格式都是常规的情况下，返回的row为null
				   if(null != row){
					   String[] cells = new String[cellTotal];
					   for(int k=0;k<cellTotal;k++){
						   HSSFCell cell = row.getCell(k);
						   cells[k] = getStringXLSCellValue(cell);
					   }
					   poiList.add(cells); 
				   }
			   }
		   }catch(Exception e){
			   LOGGER.error("excel解析:", e);
			   return null;
		   }
		   return poiList;
		}
	
	/**
	 * 解析EXCEL2003文件流
	 * 如果一行记录的行中或行尾出现空格，POI工具类可能会跳过空格不做处理，所以默认第一行是表头，所有待解析的记录都以表头为准
	 * 该解析方法只适用于表头占用一行的情况
	 * @param inputStream  输入流
	 * @param isHeader  是否要跳过表头
	 * @param headerCount  表头占用行数
	 * @param maxColNum  最大列数，适用于多表头
	 * @return 返回一个字符串数组List
	 */
	public static List<String[]> readXLSRecords(InputStream inputStream, boolean isHeader, int headerCount, int maxColNum) {
		   List<String[]> poiList = new ArrayList<String[]>();
		   try{
			   HSSFWorkbook wbs = new HSSFWorkbook(inputStream);
			   HSSFSheet childSheet = wbs.getSheetAt(0);
			   //获取表头
			   int begin = childSheet.getFirstRowNum(); 
			   //HSSFRow firstRow = childSheet.getRow(begin);
			   //int cellTotal = firstRow.getPhysicalNumberOfCells();
			   //是否跳过表头解析数据
			   if(isHeader){
					begin += headerCount;
			   }
			   //逐行获取单元格数据
			   for(int i = begin;i <= childSheet.getLastRowNum();i++){
				   HSSFRow row = childSheet.getRow(i); //一行的所有单元格格式都是常规的情况下，返回的row为null
				   String[] cells = new String[maxColNum]; //空行对应空串数组
				   for(int k=0;k<maxColNum;k++){
					   HSSFCell cell = row==null?null:row.getCell(k);
					   cells[k] = getStringXLSCellValue(cell);
				   }
				   poiList.add(cells); 
			   }
		   }catch(Exception e){
			   LOGGER.error("excel解析:", e);
			   return null;
		   }
		   return poiList;
		}
	
	/**
	 * 解析EXCEL2007文件流
	 * 如果一行记录的行中或行尾出现空格，POI工具类可能会跳过空格不做处理，所以默认第一行是表头，所有待解析的记录都以表头为准
	 * 该处理方法中，表头对应都占用一行
	 * @param inputStream 输入流
	 * @param isHeader 是否要跳过表头
	 * @param headerCount 表头占用行数
	 * @return 返回一个字符串数组List
	 */
	public static List<String[]> readXLSXRecords(InputStream inputStream, boolean isHeader, int headerCount) {
		   List<String[]> poiList = new ArrayList<String[]>();
		   try{
			   XSSFWorkbook wbs = new XSSFWorkbook(inputStream);
			   XSSFSheet childSheet = wbs.getSheetAt(0);
			   //获取表头
			   int begin = childSheet.getFirstRowNum(); 
			   XSSFRow firstRow = childSheet.getRow(begin);
			   int cellTotal = firstRow.getPhysicalNumberOfCells();
			   //是否跳过表头解析数据
			   if(isHeader){
					begin += headerCount;
			   }
			   for(int i = begin;i <= childSheet.getLastRowNum();i++){
				   XSSFRow row = childSheet.getRow(i);  //一行的所有单元格格式都是常规的情况下，返回的row为null
				   if(null != row){
					   String[] cells = new String[cellTotal];
					   for(int k=0;k<cellTotal;k++){
						   XSSFCell cell = row.getCell(k);
						   cells[k] = getStringXLSXCellValue(cell);
					   }
					   poiList.add(cells);
				   }
			   }
		   }catch(Exception e){
			   LOGGER.error("excel解析:", e);
			   return null;
		   }
		   return poiList;
		}
	
	/**
	 * 解析EXCEL2007文件流
	 * 如果一行记录的行中或行尾出现空格，POI工具类可能会跳过空格不做处理，所以默认第一行是表头，所有待解析的记录都以表头为准
	 * 该处理方法中，表头对应都占用一行
	 * @param inputStream 输入流
	 * @param isHeader 是否要跳过表头
	 * @param headerCount 表头占用行数
	 * @param maxColNum 最大列数，适用于多表头的情况
	 * @return 返回一个字符串数组List
	 */
	public static List<String[]> readXLSXRecords(InputStream inputStream, boolean isHeader, int headerCount, int maxColNum) {
		   List<String[]> poiList = new ArrayList<String[]>();
		   try{
			   XSSFWorkbook wbs = new XSSFWorkbook(inputStream);
			   XSSFSheet childSheet = wbs.getSheetAt(0);
			   //获取表头
			   int begin = childSheet.getFirstRowNum(); 
			   //XSSFRow firstRow = childSheet.getRow(begin);
			   //int cellTotal = firstRow.getPhysicalNumberOfCells();
			   //是否跳过表头解析数据
			   if(isHeader){
					begin += headerCount;
			   }
			   for(int i = begin;i <= childSheet.getLastRowNum();i++){
				   XSSFRow row = childSheet.getRow(i);  //一行的所有单元格格式都是常规的情况下，返回的row为null
				   String[] cells = new String[maxColNum];  //空行对应空串数组
				   for(int k=0;k<maxColNum;k++){
					   XSSFCell cell = row==null?null:row.getCell(k);
					   cells[k] = getStringXLSXCellValue(cell);
				   }
				   poiList.add(cells);
			   }
		   }catch(Exception e){
			   LOGGER.error("excel解析:", e);
			   return null;
		   }
		   return poiList;
		}
	
	 /**
	  * 获取单元格数据内容为字符串类型的数据
	  * 
	  * @param cell Excel单元格
	  * @return String 单元格数据内容
	  */
		private static String getStringXLSCellValue(HSSFCell cell) {
			String strCell = "";
			if (cell == null) {
				return "";
			}
			
			//将数值型参数转成文本格式，该算法不能保证1.00这种类型数值的精确度
			DecimalFormat df = (DecimalFormat) NumberFormat.getPercentInstance();  
			StringBuffer sb = new StringBuffer();
			sb.append("0");
			df.applyPattern(sb.toString());  
			
			switch (cell.getCellType()) {
			case HSSFCell.CELL_TYPE_STRING:
				strCell = cell.getStringCellValue();
				break;
			case HSSFCell.CELL_TYPE_NUMERIC:
				double value = cell.getNumericCellValue();
				while(Double.parseDouble(df.format(value))!=value){
					if("0".equals(sb.toString())){
						sb.append(".0");
					}else{
						sb.append("0");
					}
					df.applyPattern(sb.toString());
				}
				strCell = df.format(value);
				break;
			case HSSFCell.CELL_TYPE_BOOLEAN:
				strCell = String.valueOf(cell.getBooleanCellValue());
				break;
			case HSSFCell.CELL_TYPE_BLANK:
				strCell = "";
				break;
			default:
				strCell = "";
				break;
			}
			if (strCell == null || "".equals(strCell)) {
				return "";
			}
			return strCell;
		}
		
		 /**
		  * 获取单元格数据内容为字符串类型的数据
		  * 
		  * @param cell Excel单元格
		  * @return String 单元格数据内容
		  */
			private static String getStringXLSXCellValue(XSSFCell cell) {
				String strCell = "";
				if (cell == null) {
					return "";
				}
				//将数值型参数转成文本格式，该算法不能保证1.00这种类型数值的精确度
				DecimalFormat df = (DecimalFormat) NumberFormat.getPercentInstance();  
				StringBuffer sb = new StringBuffer();
				sb.append("0");
				df.applyPattern(sb.toString()); 
				
				switch (cell.getCellType()) {
				case XSSFCell.CELL_TYPE_STRING:
					strCell = cell.getStringCellValue();
					break;
				case XSSFCell.CELL_TYPE_NUMERIC:
					double value = cell.getNumericCellValue();
					while(Double.parseDouble(df.format(value))!=value){
						if("0".equals(sb.toString())){
							sb.append(".0");
						}else{
							sb.append("0");
						}
						df.applyPattern(sb.toString());
					}
					strCell = df.format(value);
					break;
				case XSSFCell.CELL_TYPE_BOOLEAN:
					strCell = String.valueOf(cell.getBooleanCellValue());
					break;
				case XSSFCell.CELL_TYPE_BLANK:
					strCell = "";
					break;
				default:
					strCell = "";
					break;
				}
				if (strCell == null || "".equals(strCell)) {
					return "";
				}
				return strCell;
			}
			
			
			/**
			 * 导出Excel
			 * @param response
			 * @param request
			 * @param title 
			 * @param map key为标题，list为数据，单表头导出
			 * @param type 0为xls，1为xlsx
			 */
			public static void output(HttpServletResponse response,HttpServletRequest request,
					String title,Map<String, List<Object>> map, int type) throws Exception{
				
				if(type != 0 && type != 1){
					throw new Exception("无效的excel导出类型，type=0表示xls，type=1表示xlsx");
				}
				List<Map<String, List<Object>>> list = new ArrayList<Map<String, List<Object>>>();
				list.add(map);
				if(type == 0){
					outputXLS(response, request, title, list); 
				}else if(type == 1) {
					outputXLSX(response, request, title, list); 
				}
			}
			
			 /**
			 * 导出Excel
			 * @param response
			 * @param request
			 * @param title 
			 * @param List<Map> 支持多表头导出
			 * @param type 0为xls，1为xlsx
			 */
			public static void output(HttpServletResponse response,HttpServletRequest request,
					String title, List<Map<String, List<Object>>> list, int type) throws Exception{
				
				if(type != 0 && type != 1){
					throw new Exception("无效的excel导出类型，type=0表示xls，type=1表示xlsx");
				}
				if(type == 0){
					outputXLS(response, request, title, list); 
				}else if(type == 1) {
					outputXLSX(response, request, title, list); 
				}
			}
			
			 /**
			 * 导出Excel
			 * @param response
			 * @param request
			 * @param title 
			 * @param List<Map> 支持多表头按顺序导出
			 * @param type 0为xls，1为xlsx
			 */
			public static void outputByColId(HttpServletResponse response,HttpServletRequest request,
					String title, List<Map<String, List<Object>>> list, int type) throws Exception{
				
				if(type != 0 && type != 1){
					throw new Exception("无效的excel导出类型，type=0表示xls，type=1表示xlsx");
				}
				if(type == 0){
					outputXLSByCol(response, request, title, list);
				}else if(type == 1) {
					outputXLSByCol(response, request, title, list);
				}
			}
			
			
			public static void outputXLS(HttpServletResponse response,HttpServletRequest request,
					String title,List<Map<String, List<Object>>> list)throws Exception{
					
					//输出流定义
					OutputStream os = response.getOutputStream();
					byte[] fileNameByte = (title + ".xls").getBytes("GBK");
					String filename = new String(fileNameByte, "ISO8859-1");
					response.setContentType("application/x-msdownload");
					response.setCharacterEncoding("UTF-8");response.setHeader("Content-Disposition", "attachment;filename=" + filename);
					
					//创建excel文件
					HSSFWorkbook hssf_w_book=new HSSFWorkbook();
					HSSFSheet hssf_w_sheet=hssf_w_book.createSheet(title);
					hssf_w_sheet.setDefaultColumnWidth(21); //固定列宽度
					HSSFRow hssf_w_row=null;//创建一行
					HSSFCell hssf_w_cell=null;//创建每个单元格
					 
					//定义表头单元格样式
					HSSFCellStyle head_cellStyle = hssf_w_book.createCellStyle();
					//定义表头字体样式
					HSSFFont head_font = hssf_w_book.createFont();
					head_font.setFontName("宋体");//设置头部字体为宋体
					head_font.setBoldweight(Font.BOLDWEIGHT_BOLD); //粗体
					head_font.setFontHeightInPoints((short) 10); //字体大小
					//表头单元格样式设置
					head_cellStyle.setFont(head_font);//单元格样式使用字体
					head_cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
					head_cellStyle.setVerticalAlignment(HSSFCellStyle.ALIGN_CENTER);
//					head_cellStyle.setBorderBottom(XSSFCellStyle.BORDER_THIN);
//					head_cellStyle.setBorderLeft(XSSFCellStyle.BORDER_THIN);
//					head_cellStyle.setBorderRight(XSSFCellStyle.BORDER_THIN);
//					head_cellStyle.setBorderTop(XSSFCellStyle.BORDER_THIN);
					
					//定义数据单元格样式
					HSSFCellStyle cellStyle_CN = hssf_w_book.createCellStyle();//创建数据单元格样式(数据库数据样式)
//					cellStyle_CN.setBorderBottom(XSSFCellStyle.BORDER_THIN);
//					cellStyle_CN.setBorderLeft(XSSFCellStyle.BORDER_THIN);
//					cellStyle_CN.setBorderRight(XSSFCellStyle.BORDER_THIN);
//					cellStyle_CN.setBorderTop(XSSFCellStyle.BORDER_THIN); 
					 
					//在多表头导出时，定义第一个表头出现位置
					int titleFlag = 0;
					
					//遍历写入表数据的list
					for(Map<String, List<Object>> map : list){
						//遍历map获取表头字段，并将表头字段放进String型的数组
						Set<String> key = map.keySet();
						String titles = "";
						int count = 0;
						for (Iterator<String> it = key.iterator(); it.hasNext();) {
							if(count != 0){
								titles += ";";
							}
							titles += (String) it.next();
							count++;
						}
						String[] titleArray = titles.split(";");
						
						//表头写入位置
						hssf_w_row = hssf_w_sheet.createRow(titleFlag);
						for(int i = 0; i < titleArray.length; i++){
							hssf_w_cell = hssf_w_row.createCell(i);
							hssf_w_cell.setCellType(XSSFCell.CELL_TYPE_STRING);
							hssf_w_cell.setCellValue(titleArray[i]);
							hssf_w_cell.setCellStyle(head_cellStyle);
							//hssf_w_sheet.autoSizeColumn(( short ) i ); 
						}
						
						//循环写入表数据，获取表的总列数，然后逐行写入数据
						for(int i = 0; i < map.get(titleArray[0]).size(); i++){
							//定义数据行
							hssf_w_row = hssf_w_sheet.createRow(i+titleFlag+1);
							//按行将每一列的数据写入单元格
							for(int j = 0; j < titleArray.length; j++){
								hssf_w_cell = hssf_w_row.createCell(j);
								Object in = map.get(titleArray[j]).get(i);
								type4ExcelXLS(in,hssf_w_cell,cellStyle_CN);
								//hssf_w_sheet.autoSizeColumn(( short ) i ); 
							}
						}
						//下一个表头的写入位置，和上一个表头数据之间隔一行
						titleFlag+=map.get(titleArray[0]).size()+2;
					}
					
					//excel文件导出
					hssf_w_book.write(os);
					os.close();
					request.getSession().setAttribute("EXCEL_FINISH", "1");
			}
			
			public static void outputXLSByCol(HttpServletResponse response,HttpServletRequest request,
					String title,List<Map<String, List<Object>>> list)throws Exception{
					
					//输出流定义
					OutputStream os = response.getOutputStream();
					byte[] fileNameByte = (title + ".xls").getBytes("GBK");
					String filename = new String(fileNameByte, "ISO8859-1");
					response.setContentType("application/x-msdownload");
					response.setCharacterEncoding("UTF-8");response.setHeader("Content-Disposition", "attachment;filename=" + filename);
					
					//创建excel文件
					HSSFWorkbook hssf_w_book=new HSSFWorkbook();
					HSSFSheet hssf_w_sheet=hssf_w_book.createSheet(title);
					hssf_w_sheet.setDefaultColumnWidth(21); //固定列宽度
					HSSFRow hssf_w_row=null;//创建一行
					HSSFCell hssf_w_cell=null;//创建每个单元格
					 
					//定义表头单元格样式
					HSSFCellStyle head_cellStyle = hssf_w_book.createCellStyle();
					//定义表头字体样式
					HSSFFont head_font = hssf_w_book.createFont();
					head_font.setFontName("宋体");//设置头部字体为宋体
					head_font.setBoldweight(Font.BOLDWEIGHT_BOLD); //粗体
					head_font.setFontHeightInPoints((short) 10); //字体大小
					//表头单元格样式设置
					head_cellStyle.setFont(head_font);//单元格样式使用字体
					head_cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
					head_cellStyle.setVerticalAlignment(HSSFCellStyle.ALIGN_CENTER);
//					head_cellStyle.setBorderBottom(XSSFCellStyle.BORDER_THIN);
//					head_cellStyle.setBorderLeft(XSSFCellStyle.BORDER_THIN);
//					head_cellStyle.setBorderRight(XSSFCellStyle.BORDER_THIN);
//					head_cellStyle.setBorderTop(XSSFCellStyle.BORDER_THIN);
					
					//定义数据单元格样式
					HSSFCellStyle cellStyle_CN = hssf_w_book.createCellStyle();//创建数据单元格样式(数据库数据样式)
//					cellStyle_CN.setBorderBottom(XSSFCellStyle.BORDER_THIN);
//					cellStyle_CN.setBorderLeft(XSSFCellStyle.BORDER_THIN);
//					cellStyle_CN.setBorderRight(XSSFCellStyle.BORDER_THIN);
//					cellStyle_CN.setBorderTop(XSSFCellStyle.BORDER_THIN); 
					 
					//在多表头导出时，定义第一个表头出现位置
					int titleFlag = 0;
					
					//遍历写入表数据的list
					for(Map<String, List<Object>> map : list){
						//遍历map获取表头字段，并将表头字段放进String型的数组
						Set<String> key = map.keySet();
						String titles = "";
						int count = 0;
						for (Iterator<String> it = key.iterator(); it.hasNext();) {
							if(count != 0){
								titles += ";";
							}
							titles += (String) it.next();
							count++;
						}
						String[] titleArray = titles.split(";");
						String[] temArr = new String[titleArray.length];
						String[] temCol = new String[titleArray.length];
						for(int k = 0;k<titleArray.length;k++){
							String tem = titleArray[k];
							String[] t= tem.split("_");
							String c = t[1];
							int n = Integer.parseInt(c);
							temArr[n] = t[0]+"_"+c;
							temCol[n] = t[0];
						}
						
						//表头写入位置
						hssf_w_row = hssf_w_sheet.createRow(titleFlag);
						for(int i = 0; i < temArr.length; i++){
							hssf_w_cell = hssf_w_row.createCell(i);
							hssf_w_cell.setCellType(XSSFCell.CELL_TYPE_STRING);
							hssf_w_cell.setCellValue(temCol[i]);
							hssf_w_cell.setCellStyle(head_cellStyle);
							//hssf_w_sheet.autoSizeColumn(( short ) i ); 
						}
						
						//循环写入表数据，获取表的总列数，然后逐行写入数据
						for(int i = 0; i < map.get(temArr[0]).size(); i++){
							//定义数据行
							hssf_w_row = hssf_w_sheet.createRow(i+titleFlag+1);
							//按行将每一列的数据写入单元格
							for(int j = 0; j < temArr.length; j++){
								hssf_w_cell = hssf_w_row.createCell(j);
								Object in = map.get(temArr[j]).get(i);
								type4ExcelXLS(in,hssf_w_cell,cellStyle_CN);
								//hssf_w_sheet.autoSizeColumn(( short ) i ); 
							}
						}
						//下一个表头的写入位置，和上一个表头数据之间隔一行
						titleFlag+=map.get(temArr[0]).size()+2;
					}
					
					//excel文件导出
					hssf_w_book.write(os);
					os.close();
					request.getSession().setAttribute("EXCEL_FINISH", "1");
			}
			
			public static void outputXLSX(HttpServletResponse response,HttpServletRequest request,
					String title,List<Map<String, List<Object>>> list) throws Exception{
					
					//输出流定义
					OutputStream os = response.getOutputStream();
					byte[] fileNameByte = (title + ".xlsx").getBytes("GBK");
					String filename = new String(fileNameByte, "ISO8859-1");
					response.setContentType("application/x-msdownload");
					response.setCharacterEncoding("UTF-8");
					response.setHeader("Content-Disposition", "attachment;filename=" + filename);
					
					//创建excel文件
					XSSFWorkbook xssf_w_book=new XSSFWorkbook();
					XSSFSheet xssf_w_sheet=xssf_w_book.createSheet(title);
					xssf_w_sheet.setDefaultColumnWidth(21); //固定列宽度
					XSSFRow xssf_w_row=null;//创建一行
					XSSFCell xssf_w_cell=null;//创建每个单元格
					 
					//定义表头单元格样式
					XSSFCellStyle head_cellStyle=xssf_w_book.createCellStyle();
					//定义表头字体样式
					XSSFFont  head_font=xssf_w_book.createFont();
					head_font.setFontName("宋体");//设置头部字体为宋体
					head_font.setBoldweight(Font.BOLDWEIGHT_BOLD); //粗体
					head_font.setFontHeightInPoints((short) 10);
					//表头单元格样式设置
					head_cellStyle.setFont(head_font);//单元格使用表头字体样式
					head_cellStyle.setAlignment(HorizontalAlignment.CENTER);
					head_cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
					head_cellStyle.setBorderBottom(XSSFCellStyle.BORDER_THIN);
					head_cellStyle.setBorderLeft(XSSFCellStyle.BORDER_THIN);
					head_cellStyle.setBorderRight(XSSFCellStyle.BORDER_THIN);
					head_cellStyle.setBorderTop(XSSFCellStyle.BORDER_THIN);
					
					//定义数据单元格样式
					XSSFCellStyle cellStyle_CN=xssf_w_book.createCellStyle();//创建数据单元格样式(数据库数据样式)
					cellStyle_CN.setBorderBottom(XSSFCellStyle.BORDER_THIN);
					cellStyle_CN.setBorderLeft(XSSFCellStyle.BORDER_THIN);
					cellStyle_CN.setBorderRight(XSSFCellStyle.BORDER_THIN);
					cellStyle_CN.setBorderTop(XSSFCellStyle.BORDER_THIN); 
					 
					//在多表头导出时，定义第一个表头出现位置
					int titleFlag = 0;
					
					//遍历写入表数据的list
					for(Map<String, List<Object>> map : list){
						//遍历map获取表头字段，并将表头字段放进String型的数组
						Set<String> key = map.keySet();
						String titles = "";
						int count = 0;
						for (Iterator<String> it = key.iterator(); it.hasNext();) {
							if(count != 0){
								titles += ";";
							}
							titles += (String) it.next();
							count++;
						}
						String[] titleArray = titles.split(";");
						
						//第一行写入表头
						xssf_w_row=xssf_w_sheet.createRow(titleFlag);
						for(int i = 0; i < titleArray.length; i++){
							xssf_w_cell = xssf_w_row.createCell(i);
							xssf_w_cell.setCellType(XSSFCell.CELL_TYPE_STRING);
							xssf_w_cell.setCellValue(titleArray[i]);
							xssf_w_cell.setCellStyle(head_cellStyle);
							//xssf_w_sheet.autoSizeColumn(( short ) i ); 
						}
						
						//循环写入表数据
						for(int i = 0; i < map.get(titleArray[0]).size(); i++){
							//定义数据行
							xssf_w_row=xssf_w_sheet.createRow(i+titleFlag+1);
							for(int j = 0; j < titleArray.length; j++){
								xssf_w_cell = xssf_w_row.createCell(j);
								Object in = map.get(titleArray[j]).get(i);
								type4ExcelXLSX(in,xssf_w_cell,cellStyle_CN);
								//xssf_w_sheet.autoSizeColumn(( short ) i ); 
							}
						}
						
						//下一个表头的写入位置，和上一个表头数据之间隔一行
						titleFlag+=map.get(titleArray[0]).size()+2;
					}
					
					//excel文件导出
					xssf_w_book.write(os);
					os.close();
					request.getSession().setAttribute("EXCEL_FINISH", "1");
			}
			
		
		
		 /**
		 * 导出Excel
		 * @param response
		 * @param request
		 * @param title 
		 * @param map key为标题，list为数据，统计信息在一行
		 * @param map key为标题，list为数据，表数据
		 * @param type 0为xls，1为xlsx
		 * @param add null不加结尾说明，非null时表示添加结尾说明
		 */
		public static void output(HttpServletResponse response,HttpServletRequest request,
				String title, Map<String, List<Object>> mapTitle, Map<String, List<Object>> map, int type, String add) throws Exception{
			
			if(type != 0 && type != 1){
				throw new Exception("无效的excel导出类型，type=0表示xls，type=1表示xlsx");
			}
			List<Map<String, List<Object>>> listTitle = new ArrayList<Map<String, List<Object>>>();
			if (null!=mapTitle)
			listTitle.add(mapTitle);
			List<Map<String, List<Object>>> list = new ArrayList<Map<String, List<Object>>>();
			list.add(map);
			if(type == 0){
				outputXLS(response, request, title, listTitle, list, add); 
			}else if(type == 1) {
				outputXLSX(response, request, title, listTitle, list, add); 
			}
		}
		
		public static void outputXLS(HttpServletResponse response,HttpServletRequest request,
				String title,List<Map<String, List<Object>>> listTitle,List<Map<String, List<Object>>> list, String add)throws Exception{
				
				//输出流定义
				OutputStream os = response.getOutputStream();
				byte[] fileNameByte = (title + ".xls").getBytes("GBK");
				String filename = new String(fileNameByte, "ISO8859-1");
				response.setContentType("application/x-msdownload");
				response.setCharacterEncoding("UTF-8");response.setHeader("Content-Disposition", "attachment;filename=" + filename);
				
				//创建excel文件
				HSSFWorkbook hssf_w_book=new HSSFWorkbook();
				HSSFSheet hssf_w_sheet=hssf_w_book.createSheet(title);
				hssf_w_sheet.setDefaultColumnWidth(21); //固定列宽度
				HSSFRow hssf_w_row=null;//创建一行
				HSSFCell hssf_w_cell=null;//创建每个单元格
				 
				//定义表头单元格样式
				HSSFCellStyle head_cellStyle = hssf_w_book.createCellStyle();
				//定义表头字体样式
				HSSFFont head_font = hssf_w_book.createFont();
				head_font.setFontName("宋体");//设置头部字体为宋体
				head_font.setBoldweight(Font.BOLDWEIGHT_BOLD); //粗体
				head_font.setFontHeightInPoints((short) 10); //字体大小
				//表头单元格样式设置
				head_cellStyle.setFont(head_font);//单元格样式使用字体
				head_cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
				head_cellStyle.setVerticalAlignment(HSSFCellStyle.ALIGN_CENTER);
				head_cellStyle.setBorderBottom(XSSFCellStyle.BORDER_THIN);
				head_cellStyle.setBorderLeft(XSSFCellStyle.BORDER_THIN);
				head_cellStyle.setBorderRight(XSSFCellStyle.BORDER_THIN);
				head_cellStyle.setBorderTop(XSSFCellStyle.BORDER_THIN);
				
				//定义数据单元格样式
				HSSFCellStyle cellStyle_CN = hssf_w_book.createCellStyle();//创建数据单元格样式(数据库数据样式)
				cellStyle_CN.setBorderBottom(XSSFCellStyle.BORDER_THIN);
				cellStyle_CN.setBorderLeft(XSSFCellStyle.BORDER_THIN);
				cellStyle_CN.setBorderRight(XSSFCellStyle.BORDER_THIN);
				cellStyle_CN.setBorderTop(XSSFCellStyle.BORDER_THIN); 
				 
				//在多表头导出时，定义第一个表头出现位置
				int titleFlag = 0;
				
				List<List<Map<String, List<Object>>>> listDatas = new ArrayList<List<Map<String, List<Object>>>>();
				if (null!=listTitle)
					listDatas.add(listTitle);
				listDatas.add(list);
				
				for (List<Map<String, List<Object>>> listData : listDatas) {
				
					//遍历写入表数据的list
					for(Map<String, List<Object>> map : listData){
						//遍历map获取表头字段，并将表头字段放进String型的数组
						Set<String> key = map.keySet();
						String titles = "";
						int count = 0;
						for (Iterator<String> it = key.iterator(); it.hasNext();) {
							if(count != 0){
								titles += ";";
							}
							titles += (String) it.next();
							count++;
						}
						String[] titleArray = titles.split(";");
						
						//表头写入位置
						hssf_w_row = hssf_w_sheet.createRow(titleFlag);
						for(int i = 0; i < titleArray.length; i++){
							hssf_w_cell = hssf_w_row.createCell(i);
							hssf_w_cell.setCellType(XSSFCell.CELL_TYPE_STRING);
							hssf_w_cell.setCellValue(titleArray[i]);
							hssf_w_cell.setCellStyle(head_cellStyle);
							//hssf_w_sheet.autoSizeColumn(( short ) i ); 
						}
						
						//循环写入表数据，获取表的总列数，然后逐行写入数据
						for(int i = 0; i < map.get(titleArray[0]).size(); i++){
							//定义数据行
							hssf_w_row = hssf_w_sheet.createRow(i+titleFlag+1);
							//按行将每一列的数据写入单元格
							for(int j = 0; j < titleArray.length; j++){
								hssf_w_cell = hssf_w_row.createCell(j);
								Object in = map.get(titleArray[j]).get(i);
								type4ExcelXLS(in,hssf_w_cell,cellStyle_CN);
								//hssf_w_sheet.autoSizeColumn(( short ) i ); 
							}
						}
						//下一个表头的写入位置，和上一个表头数据之间隔一行
						titleFlag+=map.get(titleArray[0]).size()+1;
					}
				}
				
				if (null!=add) {
					//定义表头单元格样式
					HSSFCellStyle head_cellStyle2 = hssf_w_book.createCellStyle();
					//表头单元格样式设置
					head_cellStyle2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
					head_cellStyle2.setAlignment(HSSFCellStyle.ALIGN_LEFT);
					head_cellStyle2.setWrapText(true);
					
					//定义表头字体样式
					HSSFFont head_font2 = hssf_w_book.createFont();
					head_font2.setFontName("宋体");//设置头部字体为宋体
					head_font2.setBoldweight(Font.BOLDWEIGHT_BOLD); //粗体
					head_font2.setFontHeightInPoints((short) 9); //字体大小
					head_font2.setColor(Font.COLOR_RED);
					
					HSSFFont head_font3 = hssf_w_book.createFont();
					head_font3.setFontName("宋体");//设置头部字体为宋体
					head_font3.setFontHeightInPoints((short) 9); //字体大小
					head_font3.setColor(Font.COLOR_RED);
					
					HSSFRichTextString ts= new HSSFRichTextString(add);
					ts.applyFont(0,30,head_font2);
					ts.applyFont(30,ts.length(),head_font3);
					
					titleFlag+=3;
					hssf_w_row = hssf_w_sheet.createRow(titleFlag);
					hssf_w_cell = hssf_w_row.createCell(0);
					hssf_w_cell.setCellType(XSSFCell.CELL_TYPE_STRING);
					
					hssf_w_cell.setCellValue(ts);
					hssf_w_cell.setCellStyle(head_cellStyle2);
					hssf_w_sheet.addMergedRegion(new CellRangeAddress(titleFlag,titleFlag+8,0,4));
				}
				//excel文件导出
				hssf_w_book.write(os);
				os.close();
		}
		
		public static void outputXLSX(HttpServletResponse response,HttpServletRequest request,
				String title,List<Map<String, List<Object>>> listTitle,List<Map<String, List<Object>>> list, String add) throws Exception{
				
				//输出流定义
				OutputStream os = response.getOutputStream();
				byte[] fileNameByte = (title + ".xlsx").getBytes("GBK");
				String filename = new String(fileNameByte, "ISO8859-1");
				response.setContentType("application/x-msdownload");
				response.setCharacterEncoding("UTF-8");
				response.setHeader("Content-Disposition", "attachment;filename=" + filename);
				
				//创建excel文件
				XSSFWorkbook xssf_w_book=new XSSFWorkbook();
				XSSFSheet xssf_w_sheet=xssf_w_book.createSheet(title);
				xssf_w_sheet.setDefaultColumnWidth(21); //固定列宽度
				XSSFRow xssf_w_row=null;//创建一行
				XSSFCell xssf_w_cell=null;//创建每个单元格
				 
				//定义表头单元格样式
				XSSFCellStyle head_cellStyle=xssf_w_book.createCellStyle();
				//定义表头字体样式
				XSSFFont  head_font=xssf_w_book.createFont();
				head_font.setFontName("宋体");//设置头部字体为宋体
				head_font.setBoldweight(Font.BOLDWEIGHT_BOLD); //粗体
				head_font.setFontHeightInPoints((short) 10);
				//表头单元格样式设置
				head_cellStyle.setFont(head_font);//单元格使用表头字体样式
				head_cellStyle.setAlignment(HorizontalAlignment.CENTER);
				head_cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
				head_cellStyle.setBorderBottom(XSSFCellStyle.BORDER_THIN);
				head_cellStyle.setBorderLeft(XSSFCellStyle.BORDER_THIN);
				head_cellStyle.setBorderRight(XSSFCellStyle.BORDER_THIN);
				head_cellStyle.setBorderTop(XSSFCellStyle.BORDER_THIN);
				
				//定义数据单元格样式
				XSSFCellStyle cellStyle_CN=xssf_w_book.createCellStyle();//创建数据单元格样式(数据库数据样式)
				cellStyle_CN.setBorderBottom(XSSFCellStyle.BORDER_THIN);
				cellStyle_CN.setBorderLeft(XSSFCellStyle.BORDER_THIN);
				cellStyle_CN.setBorderRight(XSSFCellStyle.BORDER_THIN);
				cellStyle_CN.setBorderTop(XSSFCellStyle.BORDER_THIN); 
				 
				//在多表头导出时，定义第一个表头出现位置
				int titleFlag = 0;
				
				//遍历写入表数据的list
				for(Map<String, List<Object>> map : list){
					//遍历map获取表头字段，并将表头字段放进String型的数组
					Set<String> key = map.keySet();
					String titles = "";
					int count = 0;
					for (Iterator<String> it = key.iterator(); it.hasNext();) {
						if(count != 0){
							titles += ";";
						}
						titles += (String) it.next();
						count++;
					}
					String[] titleArray = titles.split(";");
					
					//第一行写入表头
					xssf_w_row=xssf_w_sheet.createRow(titleFlag);
					for(int i = 0; i < titleArray.length; i++){
						xssf_w_cell = xssf_w_row.createCell(i);
						xssf_w_cell.setCellType(XSSFCell.CELL_TYPE_STRING);
						xssf_w_cell.setCellValue(titleArray[i]);
						xssf_w_cell.setCellStyle(head_cellStyle);
						//xssf_w_sheet.autoSizeColumn(( short ) i ); 
					}
					
					//循环写入表数据
					for(int i = 0; i < map.get(titleArray[0]).size(); i++){
						//定义数据行
						xssf_w_row=xssf_w_sheet.createRow(i+titleFlag+1);
						for(int j = 0; j < titleArray.length; j++){
							xssf_w_cell = xssf_w_row.createCell(j);
							Object in = map.get(titleArray[j]).get(i);
							type4ExcelXLSX(in,xssf_w_cell,cellStyle_CN);
							//xssf_w_sheet.autoSizeColumn(( short ) i ); 
						}
					}
					
					//下一个表头的写入位置，和上一个表头数据之间隔一行
					titleFlag+=map.get(titleArray[0]).size()+2;
				}
				if (null!=add) {
					titleFlag+=3;
					xssf_w_row = xssf_w_sheet.createRow(titleFlag);
					xssf_w_cell = xssf_w_row.createCell(0);
					xssf_w_cell.setCellType(XSSFCell.CELL_TYPE_STRING);
					xssf_w_cell.setCellValue(add);
					xssf_w_cell.setCellStyle(head_cellStyle);
					xssf_w_sheet.addMergedRegion(new CellRangeAddress(titleFlag,titleFlag+8,0,4));
				}
				//excel文件导出
				xssf_w_book.write(os);
				os.close();
		}
		
		/**
		 * 根据类型自适应格式
		 * @param col
		 * @param row
		 * @param in
		 * @return
		 * @throws Exception
		 */
		public static void type4ExcelXLSX(Object in, XSSFCell cell, XSSFCellStyle style) throws Exception{
			if (null == in){
				cell.setCellType(XSSFCell.CELL_TYPE_STRING);
				XSSFRichTextString xssfString = new XSSFRichTextString("");
				cell.setCellValue(xssfString);
				cell.setCellStyle(style);
			}else{
				in = ClobUtils.clobToString(in);
				String type = in.getClass().getName();
				if (INT.equals(type)){
					cell.setCellType(XSSFCell.CELL_TYPE_NUMERIC);
					cell.setCellValue(Double.parseDouble(String.valueOf(in)));
					cell.setCellStyle(style);
				}else if (LONG.equals(type) && String.valueOf(in).length() <= 11){
					cell.setCellType(XSSFCell.CELL_TYPE_NUMERIC);
					cell.setCellValue(Double.parseDouble(String.valueOf(in)));
					cell.setCellStyle(style);
				}else if (SHORT.equals(type)){
					cell.setCellType(XSSFCell.CELL_TYPE_NUMERIC);
					cell.setCellValue(Double.parseDouble(String.valueOf(in)));
					cell.setCellStyle(style);
				}else if (DATE.equals(type)) {
					java.sql.Timestamp sqlDate = (java.sql.Timestamp)in;
					Date d = new java.util.Date(sqlDate.getTime());
					Date ds = new SimpleDateFormat("yyyy-MM-dd").parse(new SimpleDateFormat("yyyy-MM-dd").format(d));
					SimpleDateFormat df = null;
					if (d.compareTo(ds) == 0){
						df = new SimpleDateFormat("yyyy-MM-dd");
					}else{
						df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
					}
					cell.setCellType(XSSFCell.CELL_TYPE_STRING);
					XSSFRichTextString xssfString = new XSSFRichTextString(df.format(d));
					cell.setCellValue(xssfString);
					cell.setCellStyle(style);
				}else if (in instanceof java.util.Date){
					Date d = (Date)in;
					Date ds = new SimpleDateFormat("yyyy-MM-dd").parse(new SimpleDateFormat("yyyy-MM-dd").format(d));
					SimpleDateFormat df = null;
					if (d.compareTo(ds) == 0){
						df = new SimpleDateFormat("yyyy-MM-dd");
					}else{
						df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
					}
					cell.setCellType(XSSFCell.CELL_TYPE_STRING);
					XSSFRichTextString xssfString = new XSSFRichTextString(df.format(d));
					cell.setCellValue(xssfString);
					cell.setCellStyle(style);
				}else if (STRING.equals(type)){
					cell.setCellType(XSSFCell.CELL_TYPE_STRING);
					XSSFRichTextString xssfString = new XSSFRichTextString(String.valueOf(in));
					cell.setCellValue(xssfString);
					cell.setCellStyle(style);
				}else if (in instanceof BigDecimal){
					cell.setCellType(XSSFCell.CELL_TYPE_NUMERIC);
					cell.setCellValue(Double.parseDouble(String.valueOf(in)));
					cell.setCellStyle(style);
				}else{
					try{
						double d = Double.parseDouble(String.valueOf(in));
						//if (String.valueOf(d).equals(String.valueOf(in)) && String.valueOf(in).length() <= 11){
						if (String.valueOf(in).length() <= 11){
							cell.setCellType(XSSFCell.CELL_TYPE_NUMERIC);
							cell.setCellValue(d);
							cell.setCellStyle(style);
						}else{
							cell.setCellType(XSSFCell.CELL_TYPE_STRING);
							XSSFRichTextString xssfString = new XSSFRichTextString(String.valueOf(in));
							cell.setCellValue(xssfString);
							cell.setCellStyle(style);
						}
	
					}catch (Exception e) {
						cell.setCellType(XSSFCell.CELL_TYPE_STRING);
						XSSFRichTextString xssfString = new XSSFRichTextString("");
						cell.setCellValue(xssfString);
						cell.setCellStyle(style);
						LOGGER.error("excel解析:", e);
					}
	
				}
			}

		}
		
		
		/**
		 * 根据类型自适应格式
		 * @param col
		 * @param row
		 * @param in
		 * @return
		 * @throws Exception
		 */
		public static void type4ExcelXLS(Object in, HSSFCell cell, HSSFCellStyle style) throws Exception{
			if (null == in){
				cell.setCellType(HSSFCell.CELL_TYPE_STRING);
				HSSFRichTextString hssfString = new HSSFRichTextString("");
				cell.setCellValue(hssfString);
				cell.setCellStyle(style);
			}else{
				in = ClobUtils.clobToString(in);
				String type = in.getClass().getName();
				if (INT.equals(type)){
					cell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
					cell.setCellValue(Double.parseDouble(String.valueOf(in)));
					cell.setCellStyle(style);
				}else if (LONG.equals(type) && String.valueOf(in).length() <= 11){
					cell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
					cell.setCellValue(Double.parseDouble(String.valueOf(in)));
					cell.setCellStyle(style);
				}else if (SHORT.equals(type)){
					cell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
					cell.setCellValue(Double.parseDouble(String.valueOf(in)));
					cell.setCellStyle(style);
				}else if (DATE.equals(type)) {
					java.sql.Timestamp sqlDate = (java.sql.Timestamp)in;
					Date d = new java.util.Date(sqlDate.getTime());
					Date ds = new SimpleDateFormat("yyyy-MM-dd").parse(new SimpleDateFormat("yyyy-MM-dd").format(d));
					SimpleDateFormat df = null;
					if (d.compareTo(ds) == 0){
						df = new SimpleDateFormat("yyyy-MM-dd");
					}else{
						df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
					}
					cell.setCellType(HSSFCell.CELL_TYPE_STRING);
					HSSFRichTextString hssfString = new HSSFRichTextString(df.format(d));
					cell.setCellValue(hssfString);
					cell.setCellStyle(style);
				}else if (in instanceof java.util.Date){
					Date d = (Date)in;
					Date ds = new SimpleDateFormat("yyyy-MM-dd").parse(new SimpleDateFormat("yyyy-MM-dd").format(d));
					SimpleDateFormat df = null;
					if (d.compareTo(ds) == 0){
						df = new SimpleDateFormat("yyyy-MM-dd");
					}else{
						df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
					}
					cell.setCellType(HSSFCell.CELL_TYPE_STRING);
					HSSFRichTextString hssfString = new HSSFRichTextString(df.format(d));
					cell.setCellValue(hssfString);
					cell.setCellStyle(style);
				}else if (STRING.equals(type)){
					cell.setCellType(HSSFCell.CELL_TYPE_STRING);
					HSSFRichTextString hssfString = new HSSFRichTextString(String.valueOf(in));
					cell.setCellValue(hssfString);
					cell.setCellStyle(style);
				}else if (in instanceof BigDecimal){
					cell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
					cell.setCellValue(Double.parseDouble(String.valueOf(in)));
					cell.setCellStyle(style);
				}else{
					try{
						double d = Double.parseDouble(String.valueOf(in));
						//if (String.valueOf(d).equals(String.valueOf(in)) && String.valueOf(in).length() <= 11){
						if (String.valueOf(in).length() <= 11){
							cell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
							cell.setCellValue(d);
							cell.setCellStyle(style);
						}else{
							cell.setCellType(HSSFCell.CELL_TYPE_STRING);
							HSSFRichTextString hssfString = new HSSFRichTextString(String.valueOf(in));
							cell.setCellValue(hssfString);
							cell.setCellStyle(style);
						}
	
					}catch (Exception e) {
						cell.setCellType(HSSFCell.CELL_TYPE_STRING);
						HSSFRichTextString hssfString = new HSSFRichTextString("");
						cell.setCellValue(hssfString);
						cell.setCellStyle(style);
						LOGGER.error("excel解析:", e);
					}
	
				}
			}

		}
}
游侠509
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMvc+POI 处理Excel的导入操作
05-22
springMVC 整合poi导入数据，在很多项目中都会使用，能大大减少很多工作量
SpringBoot实现数据导出成Excel
qq_45367825的博客
12-20 1670
SpringBoot实现Excel写入 SpringBoot实现Excel读取在另一篇文章 文章地址： https://blog.csdn.net/qq_45367825/article/details/111411691
spring自定义注解Excel文档应用场景
LGangJin的博客
03-28 744
导入数据时，我们经常需要 一、新建@Excel注解 import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * 自定义导出Excel数据注解 * @author sugar */ @Retention(Retention
vue中组件的导出导入_SpringBoot中关于Excel的导入和导出
weixin_39763902的博客
11-18 205
前言  由于在最近的项目中使用Excel导入和导出较为频繁，以此篇博客作为记录，方便日后查阅。本文前台页面将使用layui，来演示对Excel文件导入和导出的效果。本文代码已上传至我的gitHub，欢迎访问，地址：https://github.com/rename123/excel-demo准备工作1. 添加操作Excel的有关依赖，如下：org.apache.poipo...
Java、SpringBoot实现对Excel内容的读取并将Excel内容导入到数据库中（后端篇）
最新发布
weixin_57466771的博客
11-13 4360
这个错误貌似很多人也遇到过，是SpringBoot中关于打印MultipartFile类型参数的log问题，而且大家也都没有具体的问题原因和解决方案，大多数人都是把有关的日志注解给注释掉来解决问题，虽然这种方法不能从根本上解决问题，但胜在方便，所以我也修改了项目中用AOP（面向切面编程）实现的日志处理切面的代码。在上图的表格中，我们需要在数据库中写入站点配置、车道配置、枪机配置等三张表的数据，且车道配置、枪机配置表的行数随着站点配置中的车道数量的变化而变化，此时就需要用到下面的方法。
java中读取Excel问题
沈春莲的博客
05-13 318
The supplied data appears to be in the Office 2007+ XML. You are calling the part of POI that deals  原因是： HSSFWorkbook:是操作Excel2003以前（包括2003）的版本，扩展名是.xls  XSSFWorkbook:是操作Excel2007的版本，扩展名是.xlsx
SpringMvc+POI 导入Excel文件
11-17
SpringMvc+POI 实现Excel文件的导入操作，采用传统表单提交和Jquery.form.js插件提供的异步表单提交方式
springMVC poi解析ajax上传excel文件，返回json对象\list数组
06-09
解析通过MutilpartFile导入的Excel并解析里面数据，先判断文件的类型(excel处理有两种此处为两种通用)是.xls/.xlsx，采用Apache的POI的API来操作Excel，读取内容后保存到List中，再将List转Json（使用Linked，增删快...
springmvc+hibernate+poi实现mysql数据库简单操作以及导出excel功能
07-17
基于springmvc+hibernate框架实现对mysql数据库的简单操作，并通过java+poi技术实现导出excel
spring3.2.5 MVC Poi3.9操作excel批量导入
11-21
spring3.2.5 MVC Poi3.9 maven2 操作excel批量导入数据库和可以从数据库导出数据成excel表方便数据分析。
Springboot常见注解总结
Yolo_lxt的博客
06-03 535
java常用注解总结
SpringBoot中java操作excel【EasyExcel】
土味儿
07-24 2459
Java解析、生成Excel比较有名的框架有Apache poi、jxl。但他们都存在一个严重的问题就是非常的耗内存，poi有一套SAX模式的API可以一定程度的解决一些内存溢出的问题，但POI还是有一些缺陷，比如07版Excel解压缩以及解压后存储都是在内存中完成的，内存消耗依然很大。easyexcel重写了poi对07版Excel的解析，一个3M的excel用POI sax解析依然需要100M左右内存，改用easyexcel可以降低到几M，并且再大的excel也不会出现内存溢出；
SpringBoot操作Excel实现导入和导出功能（详细讲解+Gitee源码）
黄团团的个人博客
07-04 4891
在日常的开发中，避免不了操作Excel，比如从系统当中导出一个报表，或者通过解析客户上传的Excel文件进行批量解析数据入库等等，本篇博客主要汇总日常开发中如何使用开源的Apache提供的POI流操作Excel进行导入导出功能详解
SpringBoot整合Easyexcel操作Excel,闲暇之余，让我们学习更多
m0_64867839的博客
12-17 2122
easyexcel 3.0.2 org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter org.projectlombok lombok com.alibaba fastjson 1.2.74 org.springframework.boot spring-boot-starter-test junit junit 4.12 1.2、项目结构 搭建个项
【java POI】xssfcellstyle设置居中_java POI 单元格格式设置
依旧的博客
06-23 7532
//创建格式对象 XSSFCellStyle cellStyle = wb.createCellStyle(); //设置格式 cellStyle.setDataFormat(HSSFDataFormat.getBuiltinFormat("0.00%"));//设置百分小数位 cellStyle.setAlignment(HorizontalAlignment.CENTER);//设置水平居中 cellStyle.setVerticalAlignment(VerticalAlignment....
轻松玩转Excel，springboot集成easyexcel
Mr_Xu12308的博客
01-07 1132
最近这不又接到一个需求，上游用户想要下载上报给我们的列表数据，用来进行一些简单的线下分析。 用户的需求必须满足啊！于是我就吭哧吭哧的找到俺的chrome大哥，立即所搜”springboot下载json数据“的模板代码，妄图通过CV大法快速实现用户需求。
CellStyle单元格样式操作
AYangMeiLing的博客
06-17 9687
表格样式设置
SpringBoot集成Apache POI对excel的基本操作
qq_42801391的博客
11-06 585
Apache是用Java编写的免费开源的跨平台的 Java API，Apache POI提供API给Java程序对格式档案读和写的功能,本文我们来介绍一下其对Excel的操作。
Spring Boot框架下实现Excel导入导出
DTCloud
06-28 1193
Apache POI提供了一组API，用于读取、写入和操作Microsoft Office格式的文件，包括Excel文件。最后，我们将生成的Excel文件写入HttpServletResponse的输出流，以便将文件发送到客户端进行下载。请注意，这只是一个基本示例，你可以根据自己的需求进行更多的定制和优化。同时，你还可以使用其他Apache POI提供的功能来操作Excel文件，例如设置单元格样式、合并单元格等。接下来，我将向你展示如何在Spring Boot中实现Excel的导入和导出功能的基本步骤。
easyexcel导出excel
05-09
其中，EasyExcel借鉴了Spring的BeanUtils和SpringMVC的注解机制，支持将Java对象映射到Excel表格中，实现对Java对象与Excel表格之间的无缝转换。 EasyExcel支持多种Excel格式的读写操作，同时也支持对大型Excel文件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值