xwcueh
- 浏览: 25279 次
- 性别:
- 来自: 青岛
-
最新评论
-
18335864773：
有个叫pageoffice的插件，也可以和poi一样生成exc ...
POI操作Excel，读取，写入 -
qwfys200：
写的不错。
POI操作Excel，读取，写入 -
jiajunli：
...
Easyui datagrid行内【添加】、【编辑】、【上移】、【下移】
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);
}
}
}
}
}
2
顶
顶
0
踩
踩
分享到：
评论
2 楼
18335864773
2017-06-08
有个叫pageoffice的插件，也可以和poi一样生成excel。同时支持Office2003、2007、2010、2013，2016，还有wps。兼容性很好，而POI、JXL在Office文件格式上做不到很好的兼容，只能应对格式简单的文档。POI处理Office2003的doc、xls文件和Office2007的docx、xlsx文件用的是接口完全不兼容的两组对象，POI用来解析.doc、.xls那部分的组件是残缺不全的并且也已经不再更新了。以后可以尝试一下这种方法。
1 楼
qwfys200
2016-09-28
写的不错。
发表评论
相关推荐
本资源包集合了使用Java进行Excel读取、写入等操作所需的全部jar文件，且这些jar文件已更新至最新版本，支持Excel 2013的格式。以下是对这些操作的详细说明： 一、读取Excel 1. 导入必要的POI库：首先，你需要导入...
4. **写入数据**：从Excel读取的数据可以写入到Word的段落或运行中。你可以根据需要格式化文本，如设置字体、大小、颜色等。 ```java run.setFontFamily("Arial"); run.setFontSize(12); run.setColor("000000")...
使用poi解析excel文件，并将数据写入到数据库 项目说明 这个项目实现的功能是读取excel文件中的数据，解析并写入数据库。 读取的excel文件位于项目目录下的 excel\0805.xlsx 使用IntelliJ IDEA开发此项目 使用MYSQL...
标题和描述提到的"java+poi+excel读取写入等操作所有jar（最新支持excel2013）"指的是使用Java POI库进行Excel文件的各种操作，并且这些操作适用于Excel 2013版本，这表明提供的jar文件应该包含了支持较新Excel格式...
在Java中，使用POI库可以实现对Excel文件的读取、写入以及修改等操作，这对于数据分析、报表生成、自动化测试等场景非常实用。在你提到的资源中，"javaYdmxx80.zip"很可能包含了进行这些操作所需的jar文件，这些文件...
在这个场景中，我们关注的是如何使用POI来创建、读取和操作Excel文档。在Web项目中，这种功能通常用于数据导入导出，报表生成，或者任何需要与用户交换表格数据的场景。 **POI生成Excel** 生成Excel文件主要涉及...
使用poi读取写入复杂excel内容包括样式，工具类
在这个"利用POI解析excel并存入数据库demo"中，我们将关注如何使用 POI 库来读取 Excel 文件，并将数据有效地存入 MySQL 数据库。 首先，要开始使用 POI，你需要在你的项目中引入相应的依赖。如果你使用的是 Maven...
利用Apache POI库能够实现这一功能，即可以通过Java程序操作Excel文件，包括读取、写入、以及处理Excel中的公式。 #### 二、关键技术点 1. **POI库简介**： - Apache POI是Apache软件基金会的Jakarta项目中的一个...
在本主题中，“poi做excel读取增加超链接”指的是使用Apache POI库来处理Excel文档中的超链接。超链接在Excel中是一种功能，它可以将单元格与网页、文件或电子邮件地址关联，点击后可以直接跳转到对应的目标。 首先...
使用Apache POI进行Excel读取的基本步骤如下： 1. **引入依赖**：在Java项目中，你需要将这些JAR文件添加到类路径中。如果是Maven或Gradle项目，你需要在pom.xml或build.gradle文件中添加相应的依赖。 2. **创建...
在Java编程环境中，Apache POI库是一个非常重要的工具，它允许开发者读取、写入以及修改Microsoft Office格式的文件，包括Excel的.xls和.xlsx格式。标题提到的"poi读取excel文件"，指的是使用Apache POI库来处理...
本篇文章将深入探讨如何使用POI进行Excel的读取和写入操作。 首先，要使用Apache POI，你需要在项目中添加相应的依赖。如果你使用的是Maven，可以在pom.xml文件中添加以下依赖： ```xml <groupId>org.apache.poi...
在Java编程环境中，Apache POI库是用于读取和写入Microsoft Office格式文件的强大工具，特别是Excel（.xlsx和.xls）文件。标题提到的“poi读取Excel用到的jar包”指的是在Java项目中使用POI库进行Excel操作所需引入...
在Java开发中，Apache POI库提供了API来读取、写入和操作Excel文件。读取Excel文件时，主要涉及到的工作包括打开工作簿、选择工作表、读取单元格数据等。例如，可以使用以下代码片段打开一个Excel文件： ```java ...
在Java编程环境中，如果你需要读取或写入Excel文件，POI 提供了强大的支持。本教程将深入讲解如何使用POI的HSSF组件来处理Excel 97-2003格式的文件（BIFF8格式）。 一、Excel基础 Excel 97 文件格式，也被称作BIFF8...
这可能包括创建新的工作表、读取单元格数据、写入数据、格式化单元格、处理公式、合并单元格等常见的Excel操作。 根据压缩包文件名称“poi_20140828_nojar”，我们可以推测这是2014年8月28日的一个版本，而且...
在Java开发中，POI库被广泛用于读取、写入和修改Excel文档。本篇将详细介绍如何使用Apache POI来读取Excel模板，复制工作表（Sheet）以及复制行，并特别关注如何处理合并单元格的情况。 首先，我们需要引入Apache ...
Java通过Apache POI库操作Excel是Java开发人员处理Microsoft Office文档的一种常见方法，特别是当需要在应用程序中生成、读取或修改Excel数据时。Apache POI是一个开源项目，提供了丰富的API，使得Java开发者能够...