复制到后面一页时，转换为string格式单元格会报错。 (441126ca) | Commits | 潘钊 / bsth_control

Browse Code »

Commit 441126ca2d25bf4bcae33c1c551b5a781a798a60

Authored by 娄高锋 2023-07-03 21:33:36 +0800

1 parent 276a4623

build: skipped

复制到后面一页时，转换为string格式单元格会报错。

Inline Side-by-side

Showing 1 changed file with 905 additions and 875 deletions

src/main/java/com/bsth/util/ReportUtils.java

View file @441126c

1		-package com.bsth.util;
2		-
3		-import java.io.File;
4		-import java.io.FileInputStream;
5		-import java.io.FileOutputStream;
6		-import java.util.ArrayList;
7		-import java.util.HashMap;
8		-import java.util.Iterator;
9		-import java.util.List;
10		-import java.util.Map;
11		-import java.util.TreeMap;
12		-import java.util.regex.Matcher;
13		-import java.util.regex.Pattern;
14		-
15		-import com.bsth.common.ResponseCode;
16		-import org.apache.commons.lang3.StringUtils;
17		-import org.apache.poi.hssf.usermodel.HSSFCell;
18		-import org.apache.poi.hssf.usermodel.HSSFCellStyle;
19		-import org.apache.poi.hssf.usermodel.HSSFFont;
20		-import org.apache.poi.hssf.usermodel.HSSFRow;
21		-import org.apache.poi.hssf.usermodel.HSSFSheet;
22		-import org.apache.poi.hssf.usermodel.HSSFWorkbook;
23		-import org.apache.poi.poifs.filesystem.POIFSFileSystem;
24		-import org.apache.poi.ss.usermodel.Cell;
25		-import org.apache.poi.ss.usermodel.Workbook;
26		-import org.apache.poi.ss.util.CellRangeAddress;
27		-
28		-import com.bsth.entity.Line;
29		-import com.bsth.entity.realcontrol.ScheduleRealInfo;
30		-import org.apache.poi.ss.util.RegionUtil;
31		-import org.apache.poi.xssf.usermodel.XSSFCell;
32		-
33		-public class ReportUtils {
34		- // private final String packaegName = "com.bsth.entity.";
35		- private final String packaegName = "com.bsth.entity.realcontrol.";
36		-
37		- private final Pattern pattern = Pattern.compile("^\\d+(\\.\\d*)?$");
38		-
39		- /**
40		- * /**
41		- *
42		- * @param list
43		- * 模板中，需要重复显示的行所需的数据
44		- * @param map
45		- * 模板中除以上list外所有的数据
46		- * @param index
47		- * 需要重复的行号，该值为行号减1
48		- * @param sourcePath
49		- * 模板路径
50		- * @param targetPath
51		- * 生成路径
52		- */
53		- public void excelReplace(List<Iterator<?>> list, Object[] tArray,
54		- String sourcePath, String targetPath) {
55		- try {
56		- // 把源文件放入流中
57		- POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(
58		- sourcePath));
59		- HSSFWorkbook wb = new HSSFWorkbook(fs);
60		- if(tArray.length != 0 && tArray[0] instanceof java.util.Map){
61		- Map<String, Object> m = (Map<String, Object>)tArray[0];
62		- if(m.containsKey("sheetName") && m.get("sheetName")!=null
63		- && m.get("sheetName").toString().trim().length()!=0)
64		- wb.setSheetName(0, m.get("sheetName").toString());
65		- }
66		- HSSFSheet sheet = wb.getSheetAt(0);
67		- HSSFRow row;
68		- HSSFCell cell = null;
69		- String key;
70		- // 取得总行数
71		- int rowNum = sheet.getLastRowNum();
72		- // 取得总列数
73		- int cellNum = sheet.getRow(0).getLastCellNum();
74		-
75		- // 遍历行
76		- for (int i = 0; i < rowNum; i++) {
77		- row = sheet.getRow(i);
78		- // 遍历列
79		- for (int j = 0; j < cellNum; j++) {
80		- if (row == null) {
81		- continue;
82		- }
83		- cell = row.getCell(j);
84		- if (cell == null) {
85		- continue;
86		- }
87		- // 取得每列的内容，如果列内容是$key$格式，则替换内容
88		- key = getCellValue(cell);
89		- if (key != null && (key.indexOf("$") != -1 \|\| key.indexOf("#list#") != -1)) {
90		- // * 列中内容有#list#，则表示该行为模板行，需要以该行为模板
91		- // * 例如：模板行格式 #list#0_0 $Car.id$
92		- // * 第一个0表示需要在list中取iterator的索引值
93		- // * 第二个0表示在iterator中取的第几个对象，如果不为0，则取下一个对象，而不是沿用前面获取的对象
94		- // * $Car.id$表示所取的对象为Car的对象，并且取值为id的值
95		- if (key.indexOf("#list#") != -1) {
96		- key = key.replace("#list#", "").trim();
97		- String[] lists = key.split(" ");
98		- // 取得list中的索引值
99		- int listIndex = Integer
100		- .valueOf(lists[0].split("_")[0]);
101		- Iterator<?> iterator = list.get(listIndex);
102		- // 根据模板创建行并填弃数据，返回增加的行数
103		- int rowCount = iteratorFillCellValue(wb, sheet,
104		- cell, iterator, i, rowNum, key);
105		- rowNum += rowCount;
106		- i += rowCount;
107		- break;
108		- } else {
109		- // 直接填充数据的列，从对象数组中取得值，这里的数组不传值
110		- getValueAndSetCellValue(cell, key, tArray, new String[]{""});
111		- }
112		- }
113		-
114		- }
115		- }
116		- // 创建目标文件夹
117		- createFolder(targetPath);
118		- // 输出文件
119		- FileOutputStream fileOut = new FileOutputStream(targetPath);
120		- wb.write(fileOut);
121		- fileOut.close();
122		- } catch (Exception e) {
123		- e.printStackTrace();
124		- }
125		- }
126		-
127		-
128		- /**
129		- *
130		- * @param sheetList 多sheet模板中，需要重复显示的行所需的数据
131		- * @param tArray
132		- * @param sourcePath 模板路径
133		- * @param targetPath 生成路径
134		- */
135		- public void excelMoreSheetReplace(List<List<Iterator<?>>> sheetList, Object[] tArray,
136		- String sourcePath, String targetPath) {
137		- try {
138		- // 把源文件放入流中
139		- POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(
140		- sourcePath));
141		- HSSFWorkbook wb = new HSSFWorkbook(fs);
142		- for (int s=0; s<sheetList.size(); s++){
143		- List<Iterator<?>> list = sheetList.get(s);
144		- if(tArray.length != 0 && tArray[0] instanceof java.util.Map){
145		- Map<String, Object> m = (Map<String, Object>)tArray[0];
146		- if(m.containsKey("sheetName"+s+1) && m.get("sheetName"+s+1)!=null
147		- && m.get("sheetName"+s+1).toString().trim().length()!=0)
148		- wb.setSheetName(0, m.get("sheetName"+s+1).toString());
149		- }
150		- HSSFSheet sheet = wb.getSheetAt(s);
151		- HSSFRow row;
152		- HSSFCell cell = null;
153		- String key;
154		- // 取得总行数
155		- int rowNum = sheet.getLastRowNum();
156		- // 取得总列数
157		- int cellNum = sheet.getRow(0).getLastCellNum();
158		-
159		- // 遍历行
160		- for (int i = 0; i <= rowNum; i++) {
161		- row = sheet.getRow(i);
162		- // 遍历列
163		- for (int j = 0; j < cellNum; j++) {
164		- if (row == null) {
165		- continue;
166		- }
167		- cell = row.getCell(j);
168		- if (cell == null) {
169		- continue;
170		- }
171		- // 取得每列的内容，如果列内容是$key$格式，则替换内容
172		- key = getCellValue(cell);
173		- if (key != null && (key.indexOf("$") != -1 \|\| key.indexOf("#list#") != -1)) {
174		- // * 列中内容有#list#，则表示该行为模板行，需要以该行为模板
175		- // * 例如：模板行格式 #list#0_0 $Car.id$
176		- // * 第一个0表示需要在list中取iterator的索引值
177		- // * 第二个0表示在iterator中取的第几个对象，如果不为0，则取下一个对象，而不是沿用前面获取的对象
178		- // * $Car.id$表示所取的对象为Car的对象，并且取值为id的值
179		- if (key.indexOf("#list#") != -1) {
180		- key = key.replace("#list#", "").trim();
181		- String[] lists = key.split(" ");
182		- // 取得list中的索引值
183		- int listIndex = Integer
184		- .valueOf(lists[0].split("_")[0]);
185		- Iterator<?> iterator = list.get(listIndex);
186		- // 根据模板创建行并填充数据，返回增加的行数
187		- int rowCount = iteratorFillCellValue(wb, sheet,
188		- cell, iterator, i, rowNum, key);
189		- rowNum += rowCount;
190		- i += rowCount;
191		- break;
192		- } else {
193		- // 直接填充数据的列，从对象数组中取得值，这里的数组不传值
194		- getValueAndSetCellValue(cell, key, tArray, new String[]{""});
195		- }
196		- }
197		-
198		- }
199		- }
200		- }
201		-
202		- // 创建目标文件夹
203		- createFolder(targetPath);
204		- // 输出文件
205		- FileOutputStream fileOut = new FileOutputStream(targetPath);
206		- wb.write(fileOut);
207		- fileOut.close();
208		- } catch (Exception e) {
209		- e.printStackTrace();
210		- }
211		- }
212		-
213		- /**
214		- * 将file1中的一页sheet复制到file2中
215		- *
216		- * @param file1
217		- * 原sheet所在的excel文件
218		- * @param file2
219		- * 目标excel文件
220		- * @param page
221		- * 原excel中要被复制的sheet的位置（从0开始）
222		- * @param rate
223		- * 调整复制后的缩放倍率（列如：145，则为缩放145%）
224		- */
225		- public void copySheetByFile(File file1, File file2, int page, int rate) {
226		- try {
227		- // 把源文件放入流中
228		- POIFSFileSystem fs1 = new POIFSFileSystem(new FileInputStream(file1));
229		- HSSFWorkbook wb1 = new HSSFWorkbook(fs1);
230		- HSSFSheet sheet = wb1.getSheetAt(page);
231		- POIFSFileSystem fs2 = new POIFSFileSystem(new FileInputStream(file2));
232		- HSSFWorkbook wb2 = new HSSFWorkbook(fs2);
233		- HSSFSheet createSheet = wb2.createSheet(sheet.getSheetName());
234		- HSSFCellStyle createCellStyle = wb2.createCellStyle();
235		- HSSFRow row;
236		-
237		- createSheet.setZoom(rate, 100);
238		- for(int i = 0; i < sheet.getRow(0).getPhysicalNumberOfCells(); i++){
239		- createSheet.setColumnWidth(i, sheet.getColumnWidth(i));
240		- }
241		-
242		- List<CellRangeAddress> mergedRegions = sheet.getMergedRegions();
243		- for(int l = 0; l < mergedRegions.size(); l++){
244		- //复制源表中的合并单元格
245		- createSheet.addMergedRegion(mergedRegions.get(l));
246		- }
247		- int firstRow = sheet.getFirstRowNum();
248		- int lastRow = sheet.getLastRowNum();
249		- for(int k = firstRow; k <= lastRow; k++){
250		- // 创建新建excel Sheet的行
251		- HSSFRow rowCreat = createSheet.createRow(k);
252		- // 取得源有excel Sheet的行
253		- row = sheet.getRow(k);
254		-// rowCreat.setHeight(row.getHeight()); //设置行高
255		- // 单元格式样
256		- int firstCell = row.getFirstCellNum();
257		- int lastCell = row.getLastCellNum();
258		- for (int j = firstCell; j < lastCell; j++) {
259		- // 自动适应列宽貌似不起作用
260		-// createSheet.autoSizeColumn(j);
261		-// System.out.println(row.getCell(j));
262		- rowCreat.createCell(j);
263		- String strVal = "";
264		- if (row.getCell(j)==null) {
265		-
266		- } else {
267		- strVal = row.getCell(j).getStringCellValue();
268		- rowCreat.getCell(j).setCellValue(strVal);
269		- copyCellStyle(wb1, row.getCell(j).getCellStyle(), createCellStyle);
270		- createCellStyle.setBorderTop((short)1);
271		- createCellStyle.setBorderLeft((short)1);
272		- createCellStyle.setBorderRight((short)1);
273		- createCellStyle.setBorderBottom((short)1);
274		- rowCreat.getCell(j).setCellStyle(createCellStyle);
275		- }
276		- }
277		- }
278		-
279		-// int firstRowNum = createSheet.getFirstRowNum();
280		-// int lastRowNum = createSheet.getLastRowNum();
281		-// int test = 0;
282		-// for(int k = firstRowNum; k <= lastRowNum; k++){
283		-// HSSFRow createRow = createSheet.getRow(k);
284		-// int firstCellNum = createRow.getFirstCellNum();
285		-// int lastCellNum = createRow.getLastCellNum();
286		-// for(int i = firstCellNum; i < lastCellNum; i++){
287		-// HSSFCell cell = createRow.getCell(i);
288		-// cell.getCellStyle().setBorderTop(HSSFCellStyle.BORDER_THIN);
289		-// cell.getCellStyle().setBorderLeft(HSSFCellStyle.BORDER_THIN);
290		-// cell.getCellStyle().setBorderRight(HSSFCellStyle.BORDER_THIN);
291		-// cell.getCellStyle().setBorderBottom(HSSFCellStyle.BORDER_THIN);
292		-// test ++;
293		-// }
294		-// }
295		-// System.out.println("test = " + test);
296		-
297		- FileOutputStream fileOut = new FileOutputStream(file2);
298		- wb2.write(fileOut);
299		- fileOut.close();
300		- wb2.close();
301		- wb1.close();
302		- fs2.close();
303		- fs1.close();
304		- file1.delete();
305		-// // 创建目标文件夹
306		-// createFolder(targetPath);
307		- // 输出文件
308		- } catch (Exception e) {
309		- e.printStackTrace();
310		- }
311		- }
312		-
313		- public void test(File file){
314		- POIFSFileSystem fs;
315		- try {
316		- fs = new POIFSFileSystem(new FileInputStream(file));
317		- HSSFWorkbook wb = new HSSFWorkbook(fs);
318		- for(int j = 0; j < wb.getNumberOfSheets(); j++){
319		- HSSFSheet sheet = wb.getSheetAt(j);
320		- int firstRowNum = sheet.getFirstRowNum();
321		- int lastRowNum = sheet.getLastRowNum();
322		- int test = 0;
323		- for(int k = firstRowNum; k <= lastRowNum; k++){
324		- HSSFRow createRow = sheet.getRow(k);
325		- int firstCellNum = createRow.getFirstCellNum();
326		- int lastCellNum = createRow.getLastCellNum();
327		- for(int i = firstCellNum; i < lastCellNum; i++){
328		- HSSFCell cell = createRow.getCell(i);
329		- HSSFCellStyle cellStyle = wb.createCellStyle();
330		-
331		- cellStyle.setBorderTop(HSSFCellStyle.BORDER_THIN);
332		- cellStyle.setBorderLeft(HSSFCellStyle.BORDER_THIN);
333		- cellStyle.setBorderRight(HSSFCellStyle.BORDER_THIN);
334		- cellStyle.setBorderBottom(HSSFCellStyle.BORDER_THIN);
335		- cell.setCellStyle(cellStyle);
336		- test ++;
337		- }
338		- }
339		- System.out.println("test = " + test);
340		-
341		- FileOutputStream fileOut = new FileOutputStream(file);
342		- wb.write(fileOut);
343		- fileOut.close();
344		- }
345		- } catch (Exception e) {
346		- // TODO Auto-generated catch block
347		- e.printStackTrace();
348		- }
349		-
350		- }
351		-
352		- public String getCellValue(HSSFCell cell) {
353		- int cellType = 0;
354		- String result = "";
355		- double d;
356		- if(cell != null) {
357		- // 获取列数据类型
358		- cellType = cell.getCellType();
359		- // 不同列数据类型，取值方法不同
360		- switch(cellType) {
361		- // String
362		- case HSSFCell.CELL_TYPE_STRING:
363		- result = cell.getStringCellValue().toString();
364		- break;
365		- // numeric类型，excel中，日期格式会转成数字格式存储
366		- case HSSFCell.CELL_TYPE_NUMERIC:
367		- result = cell.getNumericCellValue()+"";
368		- break;
369		- // 公式类型
370		- case HSSFCell.CELL_TYPE_FORMULA:
371		- result = cell.getCellFormula() + "";
372		- break;
373		- // boolean类型
374		- case HSSFCell.CELL_TYPE_BOOLEAN:
375		- result = cell.getBooleanCellValue() + "";
376		- break;
377		- // 空格
378		- case HSSFCell.CELL_TYPE_BLANK:
379		- result = null;
380		- break;
381		- // 错误值
382		- case HSSFCell.CELL_TYPE_ERROR:
383		- result = null;
384		- break;
385		- default :
386		- System.out.println("其它");
387		- break;
388		- }
389		- }
390		- return result;
391		- }
392		-
393		- /**
394		- * 根据iterator，以及模板中的标识，填充模板
395		- *
396		- * @param wb
397		- * @param sheet
398		- * @param cell
399		- * @param iterator
400		- * iterator
401		- * @param index
402		- * 模板行索引
403		- * @param rowNum
404		- * 表格总行数
405		- * @param key
406		- * 表格内容
407		- * @return
408		- */
409		- private int iteratorFillCellValue(HSSFWorkbook wb, HSSFSheet sheet,
410		- HSSFCell cell, Iterator<?> iterator, int index, int rowNum,
411		- String key) {
412		- int rowCount = 0;
413		- Object obj = null;
414		- int p = 0;
415		- int i = index;
416		- HSSFRow newRow = null;
417		- int tmpCellNum = 0;
418		- int k = 0;
419		- int listIndex = 0;
420		- // 取得模板行
421		- HSSFRow orgRow = sheet.getRow(index);
422		- HSSFCellStyle style= wb.createCellStyle();
423		- try {
424		- while (iterator.hasNext()) {
425		- // 取得iterator的对象
426		- obj = iterator.next();
427		- // 移动当前编辑行以下的所有行
428		- if (p != 0) {
429		- rowNum += 1;
430		- i += 1;
431		- rowCount += 1;// 增加的总行数
432		- // 把当前行以下的所有行往下移动1行
433		- sheet.shiftRows(i, rowNum, 1);
434		- }
435		- p = 1;
436		- // 创建新行
437		- newRow = sheet.createRow(index + k++);
438		- // 把新行的内容换成和模板行一样
439		- copyRow(wb, orgRow, newRow, true,style);
440		- tmpCellNum = newRow.getLastCellNum();
441		- for (int l = 0; l < tmpCellNum; l++) {
442		- cell = newRow.getCell(l);
443		- key = getCellValue(cell);
444		- /**
445		- * 如果单无格内容为#list#，表示该行是模板行 #list#0_0
446		- * 第一个0表示需要在list中取iterator的索引值
447		- * 第二个0表示在iterator中取的第几个对象，如果不为0，则取下一个对象，而不是沿用前面获取的对象
448		- */
449		- if(key == null \|\| key.equals("")){
450		- obj = iterator.next();
451		- }
452		- if (key.indexOf("#list#") != -1 && key.indexOf("_0") == -1) {
453		- if (iterator.hasNext()) {
454		- obj = iterator.next();
455		- } else {
456		- obj = null;
457		- }
458		- }
459		- if (key.trim().indexOf(" ") != -1) {
460		- key = key.split(" ")[1];
461		- }
462		- getValueAndSetCellValue(cell, key, obj,new String[]{listIndex+""});
463		- }
464		- // list的数量
465		- listIndex ++;
466		- }
467		- } catch (Exception e) {
468		- e.printStackTrace();
469		- }
470		- return rowCount;
471		- }
472		-
473		- /**
474		- * 取到相应的值并填入相应的列中
475		- *
476		- * @param cell 列
477		- * @param key 列内容
478		- * @param obj 数据源对象
479		- * @param args 其他参数数组
480		- * 数组内容：
481		- * 0位：在list中的第几条数据
482		- */
483		- private void getValueAndSetCellValue(HSSFCell cell, String key, Object obj, String[] args) {
484		- try {
485		- // 保有存单元格的内容
486		- String cellValue = key = key.replace("\\n", "");
487		- String tmpKey;
488		- // 判断单元格内容是否是公式
489		- if(cell.getCellType() == HSSFCell.CELL_TYPE_FORMULA){
490		- Pattern p=Pattern.compile("(\\d+)"); //
491		- Matcher m=p.matcher(key);
492		- if(m.find()){
493		- cellValue = key.replace(m.group(1),
494		- Integer.valueOf(m.group(1))+Integer.valueOf(args[0])+"");
495		- cell.setCellFormula(cellValue);
496		- return;
497		- }
498		- }else{//其他格式
499		-
500		- // 循环截取两个$中间的内容，反射出值
501		- while (key.indexOf("$") != -1) {
502		- key = key.substring(key.indexOf("$") + 1);
503		- // 取两个$中间的内容
504		- tmpKey = key.substring(0, key.indexOf("$"));
505		- key = key.substring(key.indexOf("$") + 1);
506		- // 如果内容是如下格式Cars.id，则从obj中值得相应的对象的值
507		- if (tmpKey.indexOf(".") != -1) {
508		- String className = tmpKey.substring(0, tmpKey.indexOf("."));
509		- // 取得类的全限定名
510		- String classWholeName = packaegName + className;
511		- String fieldName = tmpKey.substring(tmpKey.indexOf(".") + 1);
512		- // 如果obj是数组，循环判断哪个对象是对应的
513		- if (obj instanceof Object[]) {
514		- Object[] objs = (Object[]) obj;
515		- for (int k = 0; k < objs.length; k++) {
516		- if (objs[k].getClass().getName().equals(classWholeName)) {
517		- cellValue = cellValue.replace("$" + tmpKey
518		- + "$", getKeyValue(objs[k], fieldName)
519		- + "");
520		- } else if(objs[k].getClass().getName().equals("java.util.HashMap")){
521		- Map<String,Object> map = (HashMap<String,Object>)objs[k];
522		- cellValue = cellValue.replace("$" + tmpKey + "$",map.get(fieldName)+"");
523		- }
524		- }
525		- } else if (obj.getClass().getName().equals(classWholeName)) {
526		- cellValue = cellValue.replace("$" + tmpKey + "$",getKeyValue(obj, fieldName) + "");
527		- } else if (obj.getClass().getName().equals("java.util.HashMap")){
528		- Map<String,Object> map = (HashMap<String,Object>)obj;
529		- cellValue = cellValue.replace("$" + tmpKey + "$",map.get(fieldName)+"");
530		- }
531		- }
532		- }
533		- }
534		- cell.setCellValue(cellValue);
535		- Matcher matcher = pattern.matcher(cellValue);
536		- if (matcher.matches()) {
537		- if (cellValue.indexOf(".") > -1) {
538		- cell.setCellValue(Double.parseDouble(cellValue));
539		- } else {
540		- cell.setCellValue(Integer.parseInt(cellValue));
541		- }
542		- }
543		- } catch (Exception e) {
544		- e.printStackTrace();
545		- }
546		-
547		- }
548		-
549		- /**
550		- * 给列填充数据
551		- *
552		- * @param cell
553		- * 列
554		- * @param obj
555		- * 数据源对象
556		- * @param fieldName
557		- * 需要取数据的字段
558		- */
559		- private Object getKeyValue(Object obj, String fieldName) {
560		- Object value = "";
561		- try {
562		- if (obj != null) {
563		- ReportRelatedUtils test = new ReportRelatedUtils();
564		- value = test.getValue(obj, fieldName) == null ? "" : test .getValue(obj, fieldName);
565		- }
566		- } catch (Exception e) {
567		- e.printStackTrace();
568		- }
569		- return value;
570		- }
571		-
572		- public static void main(String[] args) {
573		-
574		- try {
575		- ReportUtils ee = new ReportUtils();
576		- List<Iterator<?>> list = new ArrayList<Iterator<?>>();
577		- Line line = new Line();
578		- line.setId(1);
579		- line.setName("line1");
580		-
581		- List<Object> dataList = new ArrayList<Object>();
582		-
583		-
584		- ScheduleRealInfo srr = new ScheduleRealInfo();
585		- srr.setId((long) 111);
586		- srr.setXlName("abc11");
587		-
588		- ScheduleRealInfo sr = new ScheduleRealInfo();
589		- sr.setZdsj("06:10");
590		- sr.setZdsjActual("06:25");
591		- dataList.add(sr);
592		- sr = new ScheduleRealInfo();
593		- sr.setZdsj("06:20");
594		- sr.setZdsjActual("");
595		- dataList.add(sr);
596		- list.add(dataList.iterator());
597		-
598		- ee.excelReplace(list, new Object[] { srr }, "D:/waybill.xls",
599		- "D:/22.xls");
600		- System.out.println("ok");
601		- } catch (Exception e) {
602		- e.printStackTrace();
603		- }
604		- }
605		-
606		- /**
607		- * 行复制功能
608		- *
609		- * @param fromRow
610		- * @param toRow
611		- */
612		- private void copyRow(HSSFWorkbook wb, HSSFRow fromRow, HSSFRow toRow,
613		- boolean copyValueFlag, HSSFCellStyle style) {
614		- for (Iterator<Cell> cellIt = fromRow.cellIterator(); cellIt.hasNext();) {
615		- HSSFCell tmpCell = (HSSFCell) cellIt.next();
616		- HSSFCell newCell = toRow.createCell(tmpCell.getColumnIndex(), 0);
617		- copyCell(wb, tmpCell, newCell, copyValueFlag, tmpCell.getCellStyle());
618		- }
619		- }
620		-
621		- /**
622		- * 复制单元格
623		- *
624		- * @param srcCell
625		- * @param distCell
626		- * @param copyValueFlag
627		- * true则连同cell的内容一起复制
628		- */
629		- public void copyCell(HSSFWorkbook wb, HSSFCell srcCell, HSSFCell distCell,
630		- boolean copyValueFlag, HSSFCellStyle newstyle) {
631		-// HSSFCellStyle newstyle = wb.createCellStyle();
632		- copyCellStyle(wb, srcCell.getCellStyle(), newstyle);
633		- // 样式
634		- distCell.setCellStyle(newstyle);
635		- // 评论
636		- if (srcCell.getCellComment() != null) {
637		- distCell.setCellComment(srcCell.getCellComment());
638		- }
639		- // 不同数据类型处理
640		- int srcCellType = srcCell.getCellType();
641		- distCell.setCellType(srcCellType);
642		- if (copyValueFlag) {
643		- if (srcCellType == HSSFCell.CELL_TYPE_NUMERIC) {
644		- distCell.setCellValue(srcCell.getDateCellValue());
645		- } else if (srcCellType == HSSFCell.CELL_TYPE_STRING) {
646		- distCell.setCellValue(srcCell.getRichStringCellValue());
647		- } else if (srcCellType == HSSFCell.CELL_TYPE_BLANK) {
648		-
649		- } else if (srcCellType == HSSFCell.CELL_TYPE_BOOLEAN) {
650		- distCell.setCellValue(srcCell.getBooleanCellValue());
651		- } else if (srcCellType == HSSFCell.CELL_TYPE_ERROR) {
652		- distCell.setCellErrorValue(srcCell.getErrorCellValue());
653		- } else if (srcCellType == HSSFCell.CELL_TYPE_FORMULA) {
654		- distCell.setCellFormula(srcCell.getCellFormula());
655		- } else {
656		- }
657		- }
658		- }
659		-
660		- /**
661		- * 复制一个单元格样式到目的单元格样式
662		- *
663		- * @param fromStyle
664		- * @param toStyle
665		- */
666		- public void copyCellStyle(HSSFWorkbook wb, HSSFCellStyle fromStyle,
667		- HSSFCellStyle toStyle) {
668		- toStyle.setAlignment(fromStyle.getAlignment());
669		- // 边框和边框颜色
670		- toStyle.setBorderBottom(fromStyle.getBorderBottom());
671		- toStyle.setBorderLeft(fromStyle.getBorderLeft());
672		- toStyle.setBorderRight(fromStyle.getBorderRight());
673		- toStyle.setBorderTop(fromStyle.getBorderTop());
674		- toStyle.setTopBorderColor(fromStyle.getTopBorderColor());
675		- toStyle.setBottomBorderColor(fromStyle.getBottomBorderColor());
676		- toStyle.setRightBorderColor(fromStyle.getRightBorderColor());
677		- toStyle.setLeftBorderColor(fromStyle.getLeftBorderColor());
678		-
679		- // 背景和前景
680		- toStyle.setFillBackgroundColor(fromStyle.getFillBackgroundColor());
681		- toStyle.setFillForegroundColor(fromStyle.getFillForegroundColor());
682		-
683		- toStyle.setDataFormat(fromStyle.getDataFormat());
684		- toStyle.setFillPattern(fromStyle.getFillPattern());
685		- toStyle.setHidden(fromStyle.getHidden());
686		- toStyle.setIndention(fromStyle.getIndention());// 首行缩进
687		- toStyle.setLocked(fromStyle.getLocked());
688		- toStyle.setRotation(fromStyle.getRotation());// 旋转
689		- toStyle.setVerticalAlignment(fromStyle.getVerticalAlignment());
690		- toStyle.setWrapText(fromStyle.getWrapText());
691		- // 字体
692		- toStyle.setFont(fromStyle.getFont(wb));
693		-
694		- }
695		-
696		- /**
697		- * 创建文件夹，并删除原有文件
698		- *
699		- * @param path
700		- */
701		- private void createFolder(String path) {
702		- File targetFile = null;
703		- targetFile = new File(path);
704		- if (targetFile.exists()) {// 删除原有文件
705		- targetFile.delete();
706		- }
707		- // 创建目标文件夹
708		- targetFile = new File(path.substring(0, path.lastIndexOf("/")));
709		- if (!targetFile.exists()) {
710		- targetFile.mkdirs();
711		- }
712		- }
713		-
714		- public void createFlie(List<List<String>> list, String name, String type){
715		- HSSFWorkbook workbook = new HSSFWorkbook();
716		- // 生成一个样式
717		- HSSFCellStyle style = workbook.createCellStyle();
718		- // 设置这些样式
719		-// style.setFillForegroundColor(HSSFColor.SKY_BLUE.index);
720		-// style.setFillPattern(HSSFCellStyle.BORDER_THIN);
721		- style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
722		- style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
723		- style.setBorderRight(HSSFCellStyle.BORDER_THIN);
724		- style.setBorderTop(HSSFCellStyle.BORDER_THIN);
725		- style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
726		- // 生成一个字体
727		- HSSFFont font = workbook.createFont();
728		-// font.setColor(HSSFColor.VIOLET.index);
729		- font.setFontHeightInPoints((short) 12);
730		- font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
731		- // 把字体应用到当前的样式
732		- style.setFont(font);
733		- HSSFCellStyle cellStyle =workbook.createCellStyle();
734		- cellStyle.setFont(font);
735		- cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER); //水平布局：居中
736		- cellStyle.setWrapText(true);
737		-
738		- //设置wordsheet名
739		- HSSFSheet sheetYS = workbook.createSheet();//设置wordsheet名
740		- HSSFRow row = sheetYS.createRow(0);
741		- setCellStyleAndValue(row, style, 0, name);
742		- CellRangeAddress callRangeAddress = new CellRangeAddress(0,0,0,list.get(0).size()-1);
743		- sheetYS.addMergedRegion(callRangeAddress);
744		- // 样式
745		- setMergeCellStyle (callRangeAddress, sheetYS, workbook);
746		-
747		- try{
748		- for(int i=0; i<list.size(); i++){
749		- HSSFRow rowYSi = sheetYS.createRow(i+1);
750		- List<String> stringList = list.get(i);
751		- int num = 4;
752		- if("xl".equals(type))
753		- num = 2;
754		- else if("cl".equals(type))
755		- num = 5;
756		- for(int j=0; j<stringList.size(); j++){
757		- String str = stringList.get(j);
758		- if(i == list.size()-1){
759		- if(j==0) {
760		- setCellStyleAndValue(rowYSi, style, j, str);
761		- CellRangeAddress callRangeAddressYSi = new CellRangeAddress(i+1,i+1,0,num);
762		- sheetYS.addMergedRegion(callRangeAddressYSi);
763		- // 样式
764		- setMergeCellStyle (callRangeAddressYSi, sheetYS, workbook);
765		- }else
766		- setCellStyleAndValue(rowYSi,style,j+num,str);
767		- } else {
768		- setCellStyleAndValue(rowYSi,style,j,str);
769		- }
770		- }
771		- }
772		-
773		- // 给列设置宽度自适应
774		- setSizeColumn1(sheetYS,1,list.get(0).size());
775		- String path = this.getClass().getResource("/").getPath() + "static/pages/forms/export/";
776		- String targetPath = path+name+".xls";
777		- createFolder(targetPath);
778		- FileOutputStream fout = new FileOutputStream(targetPath);
779		- //5.输出
780		- workbook.write(fout);
781		- fout.close();
782		- } catch (Exception e) {
783		- e.printStackTrace();
784		- }
785		- }
786		-
787		- /**
788		- * 自适应宽度(中文支持)
789		- * @param sheet
790		- * @param size
791		- */
792		- private static void setSizeColumn(HSSFSheet sheet, int size) {
793		- for (int columnNum = 0; columnNum < size; columnNum++) {
794		- int columnWidth = sheet.getColumnWidth(columnNum) / 256;
795		- for (int rowNum = 0; rowNum < sheet.getLastRowNum(); rowNum++) {
796		- HSSFRow currentRow;
797		- //当前行未被使用过
798		- if (sheet.getRow(rowNum) == null) {
799		- currentRow = sheet.createRow(rowNum);
800		- } else {
801		- currentRow = sheet.getRow(rowNum);
802		- }
803		- if (currentRow.getCell(columnNum) != null) {
804		- HSSFCell currentCell = currentRow.getCell(columnNum);
805		- if (currentCell.getCellType() == XSSFCell.CELL_TYPE_STRING) {
806		- int length = currentCell.getStringCellValue().getBytes().length;
807		- if (columnWidth < length) {
808		- columnWidth = length;
809		- }
810		- }
811		- }
812		- }
813		- sheet.setColumnWidth(columnNum, columnWidth * 300);
814		-// sheet.setColumnWidth(columnNum, columnWidth * 256);
815		- }
816		- }
817		-
818		- /**
819		- * 自适应宽度(中文支持)
820		- * @param sheet
821		- * @param index 从那一行开始自适应
822		- * @param size
823		- */
824		- private static void setSizeColumn1(HSSFSheet sheet,int index, int size) {
825		- for (int columnNum = index; columnNum < size; columnNum++) {
826		- int columnWidth = sheet.getColumnWidth(columnNum) / 256;
827		- for (int rowNum = 0; rowNum < sheet.getLastRowNum(); rowNum++) {
828		- HSSFRow currentRow;
829		- //当前行未被使用过
830		- if (sheet.getRow(rowNum) == null) {
831		- currentRow = sheet.createRow(rowNum);
832		- } else {
833		- currentRow = sheet.getRow(rowNum);
834		- }
835		- if (currentRow.getCell(columnNum) != null) {
836		- HSSFCell currentCell = currentRow.getCell(columnNum);
837		- if (currentCell.getCellType() == XSSFCell.CELL_TYPE_STRING) {
838		- int length = currentCell.getStringCellValue().getBytes().length;
839		- if (columnWidth < length) {
840		- columnWidth = length;
841		- }
842		- }
843		- }
844		- }
845		- sheet.setColumnWidth(columnNum, columnWidth * 300);
846		-// sheet.setColumnWidth(columnNum, columnWidth * 256);
847		- }
848		- }
849		-
850		- /**
851		- * 设置单元格值和样式
852		- * @param row
853		- * @param style
854		- * @param index
855		- * @param value
856		- */
857		- public static void setCellStyleAndValue(HSSFRow row,HSSFCellStyle style,int index,String value){
858		- HSSFCell cell = row.createCell(index);
859		- cell.setCellValue(value);
860		- cell.setCellStyle(style);
861		- }
862		- /**
863		- * 设置合并单元格样式
864		- * @param cra
865		- * @param sheet
866		- * @param workbook
867		- */
868		- public static void setMergeCellStyle (CellRangeAddress cra, HSSFSheet sheet, Workbook workbook){
869		- // 使用RegionUtil类为合并后的单元格添加边框
870		- RegionUtil.setBorderBottom(1, cra, sheet, workbook); // 下边框
871		- RegionUtil.setBorderLeft(1, cra, sheet, workbook); // 左边框
872		- RegionUtil.setBorderRight(1, cra, sheet, workbook); // 有边框
873		- RegionUtil.setBorderTop(1, cra, sheet, workbook); // 上边框
874		- }
875		-}
	1	+package com.bsth.util;
	2	+
	3	+import java.io.File;
	4	+import java.io.FileInputStream;
	5	+import java.io.FileOutputStream;
	6	+import java.util.ArrayList;
	7	+import java.util.HashMap;
	8	+import java.util.Iterator;
	9	+import java.util.List;
	10	+import java.util.Map;
	11	+import java.util.TreeMap;
	12	+import java.util.regex.Matcher;
	13	+import java.util.regex.Pattern;
	14	+
	15	+import com.bsth.common.ResponseCode;
	16	+import org.apache.commons.lang3.StringUtils;
	17	+import org.apache.poi.hssf.usermodel.HSSFCell;
	18	+import org.apache.poi.hssf.usermodel.HSSFCellStyle;
	19	+import org.apache.poi.hssf.usermodel.HSSFFont;
	20	+import org.apache.poi.hssf.usermodel.HSSFRow;
	21	+import org.apache.poi.hssf.usermodel.HSSFSheet;
	22	+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
	23	+import org.apache.poi.poifs.filesystem.POIFSFileSystem;
	24	+import org.apache.poi.ss.usermodel.Cell;
	25	+import org.apache.poi.ss.usermodel.Workbook;
	26	+import org.apache.poi.ss.util.CellRangeAddress;
	27	+
	28	+import com.bsth.entity.Line;
	29	+import com.bsth.entity.realcontrol.ScheduleRealInfo;
	30	+import org.apache.poi.ss.util.RegionUtil;
	31	+import org.apache.poi.xssf.usermodel.XSSFCell;
	32	+
	33	+public class ReportUtils {
	34	+ // private final String packaegName = "com.bsth.entity.";
	35	+ private final String packaegName = "com.bsth.entity.realcontrol.";
	36	+
	37	+ private final Pattern pattern = Pattern.compile("^\\d+(\\.\\d*)?$");
	38	+
	39	+ /**
	40	+ * /**
	41	+ *
	42	+ * @param list
	43	+ * 模板中，需要重复显示的行所需的数据
	44	+ * @param map
	45	+ * 模板中除以上list外所有的数据
	46	+ * @param index
	47	+ * 需要重复的行号，该值为行号减1
	48	+ * @param sourcePath
	49	+ * 模板路径
	50	+ * @param targetPath
	51	+ * 生成路径
	52	+ */
	53	+ public void excelReplace(List<Iterator<?>> list, Object[] tArray,
	54	+ String sourcePath, String targetPath) {
	55	+ try {
	56	+ // 把源文件放入流中
	57	+ POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(
	58	+ sourcePath));
	59	+ HSSFWorkbook wb = new HSSFWorkbook(fs);
	60	+ if(tArray.length != 0 && tArray[0] instanceof java.util.Map){
	61	+ Map<String, Object> m = (Map<String, Object>)tArray[0];
	62	+ if(m.containsKey("sheetName") && m.get("sheetName")!=null
	63	+ && m.get("sheetName").toString().trim().length()!=0)
	64	+ wb.setSheetName(0, m.get("sheetName").toString());
	65	+ }
	66	+ HSSFSheet sheet = wb.getSheetAt(0);
	67	+ HSSFRow row;
	68	+ HSSFCell cell = null;
	69	+ String key;
	70	+ // 取得总行数
	71	+ int rowNum = sheet.getLastRowNum();
	72	+ // 取得总列数
	73	+ int cellNum = sheet.getRow(0).getLastCellNum();
	74	+
	75	+ // 遍历行
	76	+ for (int i = 0; i < rowNum; i++) {
	77	+ row = sheet.getRow(i);
	78	+ // 遍历列
	79	+ for (int j = 0; j < cellNum; j++) {
	80	+ if (row == null) {
	81	+ continue;
	82	+ }
	83	+ cell = row.getCell(j);
	84	+ if (cell == null) {
	85	+ continue;
	86	+ }
	87	+ // 取得每列的内容，如果列内容是$key$格式，则替换内容
	88	+ key = getCellValue(cell);
	89	+ if (key != null && (key.indexOf("$") != -1 \|\| key.indexOf("#list#") != -1)) {
	90	+ // * 列中内容有#list#，则表示该行为模板行，需要以该行为模板
	91	+ // * 例如：模板行格式 #list#0_0 $Car.id$
	92	+ // * 第一个0表示需要在list中取iterator的索引值
	93	+ // * 第二个0表示在iterator中取的第几个对象，如果不为0，则取下一个对象，而不是沿用前面获取的对象
	94	+ // * $Car.id$表示所取的对象为Car的对象，并且取值为id的值
	95	+ if (key.indexOf("#list#") != -1) {
	96	+ key = key.replace("#list#", "").trim();
	97	+ String[] lists = key.split(" ");
	98	+ // 取得list中的索引值
	99	+ int listIndex = Integer
	100	+ .valueOf(lists[0].split("_")[0]);
	101	+ Iterator<?> iterator = list.get(listIndex);
	102	+ // 根据模板创建行并填弃数据，返回增加的行数
	103	+ int rowCount = iteratorFillCellValue(wb, sheet,
	104	+ cell, iterator, i, rowNum, key);
	105	+ rowNum += rowCount;
	106	+ i += rowCount;
	107	+ break;
	108	+ } else {
	109	+ // 直接填充数据的列，从对象数组中取得值，这里的数组不传值
	110	+ getValueAndSetCellValue(cell, key, tArray, new String[]{""});
	111	+ }
	112	+ }
	113	+
	114	+ }
	115	+ }
	116	+ // 创建目标文件夹
	117	+ createFolder(targetPath);
	118	+ // 输出文件
	119	+ FileOutputStream fileOut = new FileOutputStream(targetPath);
	120	+ wb.write(fileOut);
	121	+ fileOut.close();
	122	+ } catch (Exception e) {
	123	+ e.printStackTrace();
	124	+ }
	125	+ }
	126	+
	127	+
	128	+ /**
	129	+ *
	130	+ * @param sheetList 多sheet模板中，需要重复显示的行所需的数据
	131	+ * @param tArray
	132	+ * @param sourcePath 模板路径
	133	+ * @param targetPath 生成路径
	134	+ */
	135	+ public void excelMoreSheetReplace(List<List<Iterator<?>>> sheetList, Object[] tArray,
	136	+ String sourcePath, String targetPath) {
	137	+ try {
	138	+ // 把源文件放入流中
	139	+ POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(
	140	+ sourcePath));
	141	+ HSSFWorkbook wb = new HSSFWorkbook(fs);
	142	+ for (int s=0; s<sheetList.size(); s++){
	143	+ List<Iterator<?>> list = sheetList.get(s);
	144	+ if(tArray.length != 0 && tArray[0] instanceof java.util.Map){
	145	+ Map<String, Object> m = (Map<String, Object>)tArray[0];
	146	+ if(m.containsKey("sheetName"+s+1) && m.get("sheetName"+s+1)!=null
	147	+ && m.get("sheetName"+s+1).toString().trim().length()!=0)
	148	+ wb.setSheetName(0, m.get("sheetName"+s+1).toString());
	149	+ }
	150	+ HSSFSheet sheet = wb.getSheetAt(s);
	151	+ HSSFRow row;
	152	+ HSSFCell cell = null;
	153	+ String key;
	154	+ // 取得总行数
	155	+ int rowNum = sheet.getLastRowNum();
	156	+ // 取得总列数
	157	+ int cellNum = sheet.getRow(0).getLastCellNum();
	158	+
	159	+ // 遍历行
	160	+ for (int i = 0; i <= rowNum; i++) {
	161	+ row = sheet.getRow(i);
	162	+ // 遍历列
	163	+ for (int j = 0; j < cellNum; j++) {
	164	+ if (row == null) {
	165	+ continue;
	166	+ }
	167	+ cell = row.getCell(j);
	168	+ if (cell == null) {
	169	+ continue;
	170	+ }
	171	+ // 取得每列的内容，如果列内容是$key$格式，则替换内容
	172	+ key = getCellValue(cell);
	173	+ if (key != null && (key.indexOf("$") != -1 \|\| key.indexOf("#list#") != -1)) {
	174	+ // * 列中内容有#list#，则表示该行为模板行，需要以该行为模板
	175	+ // * 例如：模板行格式 #list#0_0 $Car.id$
	176	+ // * 第一个0表示需要在list中取iterator的索引值
	177	+ // * 第二个0表示在iterator中取的第几个对象，如果不为0，则取下一个对象，而不是沿用前面获取的对象
	178	+ // * $Car.id$表示所取的对象为Car的对象，并且取值为id的值
	179	+ if (key.indexOf("#list#") != -1) {
	180	+ key = key.replace("#list#", "").trim();
	181	+ String[] lists = key.split(" ");
	182	+ // 取得list中的索引值
	183	+ int listIndex = Integer
	184	+ .valueOf(lists[0].split("_")[0]);
	185	+ Iterator<?> iterator = list.get(listIndex);
	186	+ // 根据模板创建行并填充数据，返回增加的行数
	187	+ int rowCount = iteratorFillCellValue(wb, sheet,
	188	+ cell, iterator, i, rowNum, key);
	189	+ rowNum += rowCount;
	190	+ i += rowCount;
	191	+ break;
	192	+ } else {
	193	+ // 直接填充数据的列，从对象数组中取得值，这里的数组不传值
	194	+ getValueAndSetCellValue(cell, key, tArray, new String[]{""});
	195	+ }
	196	+ }
	197	+
	198	+ }
	199	+ }
	200	+ }
	201	+
	202	+ // 创建目标文件夹
	203	+ createFolder(targetPath);
	204	+ // 输出文件
	205	+ FileOutputStream fileOut = new FileOutputStream(targetPath);
	206	+ wb.write(fileOut);
	207	+ fileOut.close();
	208	+ } catch (Exception e) {
	209	+ e.printStackTrace();
	210	+ }
	211	+ }
	212	+
	213	+ /**
	214	+ * 将file1中的一页sheet复制到file2中
	215	+ *
	216	+ * @param file1
	217	+ * 原sheet所在的excel文件
	218	+ * @param file2
	219	+ * 目标excel文件
	220	+ * @param page
	221	+ * 原excel中要被复制的sheet的位置（从0开始）
	222	+ * @param rate
	223	+ * 调整复制后的缩放倍率（列如：145，则为缩放145%）
	224	+ */
	225	+ public void copySheetByFile(File file1, File file2, int page, int rate) {
	226	+ try {
	227	+ // 把源文件放入流中
	228	+ POIFSFileSystem fs1 = new POIFSFileSystem(new FileInputStream(file1));
	229	+ HSSFWorkbook wb1 = new HSSFWorkbook(fs1);
	230	+ HSSFSheet sheet = wb1.getSheetAt(page);
	231	+ POIFSFileSystem fs2 = new POIFSFileSystem(new FileInputStream(file2));
	232	+ HSSFWorkbook wb2 = new HSSFWorkbook(fs2);
	233	+ HSSFSheet createSheet = wb2.createSheet(sheet.getSheetName());
	234	+ HSSFCellStyle createCellStyle = wb2.createCellStyle();
	235	+ HSSFRow row;
	236	+
	237	+ createSheet.setZoom(rate, 100);
	238	+ for(int i = 0; i < sheet.getRow(0).getPhysicalNumberOfCells(); i++){
	239	+ createSheet.setColumnWidth(i, sheet.getColumnWidth(i));
	240	+ }
	241	+
	242	+ List<CellRangeAddress> mergedRegions = sheet.getMergedRegions();
	243	+ for(int l = 0; l < mergedRegions.size(); l++){
	244	+ //复制源表中的合并单元格
	245	+ createSheet.addMergedRegion(mergedRegions.get(l));
	246	+ }
	247	+ int firstRow = sheet.getFirstRowNum();
	248	+ int lastRow = sheet.getLastRowNum();
	249	+ for(int k = firstRow; k <= lastRow; k++){
	250	+ // 创建新建excel Sheet的行
	251	+ HSSFRow rowCreat = createSheet.createRow(k);
	252	+ // 取得源有excel Sheet的行
	253	+ row = sheet.getRow(k);
	254	+// rowCreat.setHeight(row.getHeight()); //设置行高
	255	+ // 单元格式样
	256	+ int firstCell = row.getFirstCellNum();
	257	+ int lastCell = row.getLastCellNum();
	258	+ for (int j = firstCell; j < lastCell; j++) {
	259	+ // 自动适应列宽貌似不起作用
	260	+// createSheet.autoSizeColumn(j);
	261	+// System.out.println(row.getCell(j));
	262	+ rowCreat.createCell(j);
	263	+ String strVal = "";
	264	+ if (row.getCell(j)==null) {
	265	+
	266	+ } else {
	267	+// strVal = getCellValue(row.getCell(j));
	268	+ switch(row.getCell(j).getCellType()) {
	269	+ // String
	270	+ case HSSFCell.CELL_TYPE_STRING:
	271	+ rowCreat.getCell(j).setCellValue(row.getCell(j).getStringCellValue().toString());
	272	+ break;
	273	+ // numeric类型，excel中，日期格式会转成数字格式存储
	274	+ case HSSFCell.CELL_TYPE_NUMERIC:
	275	+ rowCreat.getCell(j).setCellValue(row.getCell(j).getNumericCellValue());
	276	+ break;
	277	+ // 公式类型
	278	+ case HSSFCell.CELL_TYPE_FORMULA:
	279	+ rowCreat.getCell(j).setCellValue(row.getCell(j).getCellFormula());
	280	+ break;
	281	+ // boolean类型
	282	+ case HSSFCell.CELL_TYPE_BOOLEAN:
	283	+ rowCreat.getCell(j).setCellValue(row.getCell(j).getBooleanCellValue());
	284	+ break;
	285	+ // 空格
	286	+ case HSSFCell.CELL_TYPE_BLANK:
	287	+ rowCreat.getCell(j).setCellValue("");
	288	+ break;
	289	+ // 错误值
	290	+ case HSSFCell.CELL_TYPE_ERROR:
	291	+ rowCreat.getCell(j).setCellValue("");
	292	+ break;
	293	+ default :
	294	+ rowCreat.getCell(j).setCellValue("");
	295	+ break;
	296	+ }
	297	+// strVal = row.getCell(j).getStringCellValue();
	298	+// rowCreat.getCell(j).setCellValue(strVal);
	299	+ copyCellStyle(wb1, row.getCell(j).getCellStyle(), createCellStyle);
	300	+ createCellStyle.setBorderTop((short)1);
	301	+ createCellStyle.setBorderLeft((short)1);
	302	+ createCellStyle.setBorderRight((short)1);
	303	+ createCellStyle.setBorderBottom((short)1);
	304	+ rowCreat.getCell(j).setCellStyle(createCellStyle);
	305	+ }
	306	+ }
	307	+ }
	308	+
	309	+// int firstRowNum = createSheet.getFirstRowNum();
	310	+// int lastRowNum = createSheet.getLastRowNum();
	311	+// int test = 0;
	312	+// for(int k = firstRowNum; k <= lastRowNum; k++){
	313	+// HSSFRow createRow = createSheet.getRow(k);
	314	+// int firstCellNum = createRow.getFirstCellNum();
	315	+// int lastCellNum = createRow.getLastCellNum();
	316	+// for(int i = firstCellNum; i < lastCellNum; i++){
	317	+// HSSFCell cell = createRow.getCell(i);
	318	+// cell.getCellStyle().setBorderTop(HSSFCellStyle.BORDER_THIN);
	319	+// cell.getCellStyle().setBorderLeft(HSSFCellStyle.BORDER_THIN);
	320	+// cell.getCellStyle().setBorderRight(HSSFCellStyle.BORDER_THIN);
	321	+// cell.getCellStyle().setBorderBottom(HSSFCellStyle.BORDER_THIN);
	322	+// test ++;
	323	+// }
	324	+// }
	325	+// System.out.println("test = " + test);
	326	+
	327	+ FileOutputStream fileOut = new FileOutputStream(file2);
	328	+ wb2.write(fileOut);
	329	+ fileOut.close();
	330	+ wb2.close();
	331	+ wb1.close();
	332	+ fs2.close();
	333	+ fs1.close();
	334	+ file1.delete();
	335	+// // 创建目标文件夹
	336	+// createFolder(targetPath);
	337	+ // 输出文件
	338	+ } catch (Exception e) {
	339	+ e.printStackTrace();
	340	+ }
	341	+ }
	342	+
	343	+ public void test(File file){
	344	+ POIFSFileSystem fs;
	345	+ try {
	346	+ fs = new POIFSFileSystem(new FileInputStream(file));
	347	+ HSSFWorkbook wb = new HSSFWorkbook(fs);
	348	+ for(int j = 0; j < wb.getNumberOfSheets(); j++){
	349	+ HSSFSheet sheet = wb.getSheetAt(j);
	350	+ int firstRowNum = sheet.getFirstRowNum();
	351	+ int lastRowNum = sheet.getLastRowNum();
	352	+ int test = 0;
	353	+ for(int k = firstRowNum; k <= lastRowNum; k++){
	354	+ HSSFRow createRow = sheet.getRow(k);
	355	+ int firstCellNum = createRow.getFirstCellNum();
	356	+ int lastCellNum = createRow.getLastCellNum();
	357	+ for(int i = firstCellNum; i < lastCellNum; i++){
	358	+ HSSFCell cell = createRow.getCell(i);
	359	+ HSSFCellStyle cellStyle = wb.createCellStyle();
	360	+
	361	+ cellStyle.setBorderTop(HSSFCellStyle.BORDER_THIN);
	362	+ cellStyle.setBorderLeft(HSSFCellStyle.BORDER_THIN);
	363	+ cellStyle.setBorderRight(HSSFCellStyle.BORDER_THIN);
	364	+ cellStyle.setBorderBottom(HSSFCellStyle.BORDER_THIN);
	365	+ cell.setCellStyle(cellStyle);
	366	+ test ++;
	367	+ }
	368	+ }
	369	+ System.out.println("test = " + test);
	370	+
	371	+ FileOutputStream fileOut = new FileOutputStream(file);
	372	+ wb.write(fileOut);
	373	+ fileOut.close();
	374	+ }
	375	+ } catch (Exception e) {
	376	+ // TODO Auto-generated catch block
	377	+ e.printStackTrace();
	378	+ }
	379	+
	380	+ }
	381	+
	382	+ public String getCellValue(HSSFCell cell) {
	383	+ int cellType = 0;
	384	+ String result = "";
	385	+ double d;
	386	+ if(cell != null) {
	387	+ // 获取列数据类型
	388	+ cellType = cell.getCellType();
	389	+ // 不同列数据类型，取值方法不同
	390	+ switch(cellType) {
	391	+ // String
	392	+ case HSSFCell.CELL_TYPE_STRING:
	393	+ result = cell.getStringCellValue().toString();
	394	+ break;
	395	+ // numeric类型，excel中，日期格式会转成数字格式存储
	396	+ case HSSFCell.CELL_TYPE_NUMERIC:
	397	+ result = cell.getNumericCellValue()+"";
	398	+ break;
	399	+ // 公式类型
	400	+ case HSSFCell.CELL_TYPE_FORMULA:
	401	+ result = cell.getCellFormula() + "";
	402	+ break;
	403	+ // boolean类型
	404	+ case HSSFCell.CELL_TYPE_BOOLEAN:
	405	+ result = cell.getBooleanCellValue() + "";
	406	+ break;
	407	+ // 空格
	408	+ case HSSFCell.CELL_TYPE_BLANK:
	409	+ result = null;
	410	+ break;
	411	+ // 错误值
	412	+ case HSSFCell.CELL_TYPE_ERROR:
	413	+ result = null;
	414	+ break;
	415	+ default :
	416	+ System.out.println("其它");
	417	+ break;
	418	+ }
	419	+ }
	420	+ return result;
	421	+ }
	422	+
	423	+ /**
	424	+ * 根据iterator，以及模板中的标识，填充模板
	425	+ *
	426	+ * @param wb
	427	+ * @param sheet
	428	+ * @param cell
	429	+ * @param iterator
	430	+ * iterator
	431	+ * @param index
	432	+ * 模板行索引
	433	+ * @param rowNum
	434	+ * 表格总行数
	435	+ * @param key
	436	+ * 表格内容
	437	+ * @return
	438	+ */
	439	+ private int iteratorFillCellValue(HSSFWorkbook wb, HSSFSheet sheet,
	440	+ HSSFCell cell, Iterator<?> iterator, int index, int rowNum,
	441	+ String key) {
	442	+ int rowCount = 0;
	443	+ Object obj = null;
	444	+ int p = 0;
	445	+ int i = index;
	446	+ HSSFRow newRow = null;
	447	+ int tmpCellNum = 0;
	448	+ int k = 0;
	449	+ int listIndex = 0;
	450	+ // 取得模板行
	451	+ HSSFRow orgRow = sheet.getRow(index);
	452	+ HSSFCellStyle style= wb.createCellStyle();
	453	+ try {
	454	+ while (iterator.hasNext()) {
	455	+ // 取得iterator的对象
	456	+ obj = iterator.next();
	457	+ // 移动当前编辑行以下的所有行
	458	+ if (p != 0) {
	459	+ rowNum += 1;
	460	+ i += 1;
	461	+ rowCount += 1;// 增加的总行数
	462	+ // 把当前行以下的所有行往下移动1行
	463	+ sheet.shiftRows(i, rowNum, 1);
	464	+ }
	465	+ p = 1;
	466	+ // 创建新行
	467	+ newRow = sheet.createRow(index + k++);
	468	+ // 把新行的内容换成和模板行一样
	469	+ copyRow(wb, orgRow, newRow, true,style);
	470	+ tmpCellNum = newRow.getLastCellNum();
	471	+ for (int l = 0; l < tmpCellNum; l++) {
	472	+ cell = newRow.getCell(l);
	473	+ key = getCellValue(cell);
	474	+ /**
	475	+ * 如果单无格内容为#list#，表示该行是模板行 #list#0_0
	476	+ * 第一个0表示需要在list中取iterator的索引值
	477	+ * 第二个0表示在iterator中取的第几个对象，如果不为0，则取下一个对象，而不是沿用前面获取的对象
	478	+ */
	479	+ if(key == null \|\| key.equals("")){
	480	+ obj = iterator.next();
	481	+ }
	482	+ if (key.indexOf("#list#") != -1 && key.indexOf("_0") == -1) {
	483	+ if (iterator.hasNext()) {
	484	+ obj = iterator.next();
	485	+ } else {
	486	+ obj = null;
	487	+ }
	488	+ }
	489	+ if (key.trim().indexOf(" ") != -1) {
	490	+ key = key.split(" ")[1];
	491	+ }
	492	+ getValueAndSetCellValue(cell, key, obj,new String[]{listIndex+""});
	493	+ }
	494	+ // list的数量
	495	+ listIndex ++;
	496	+ }
	497	+ } catch (Exception e) {
	498	+ e.printStackTrace();
	499	+ }
	500	+ return rowCount;
	501	+ }
	502	+
	503	+ /**
	504	+ * 取到相应的值并填入相应的列中
	505	+ *
	506	+ * @param cell 列
	507	+ * @param key 列内容
	508	+ * @param obj 数据源对象
	509	+ * @param args 其他参数数组
	510	+ * 数组内容：
	511	+ * 0位：在list中的第几条数据
	512	+ */
	513	+ private void getValueAndSetCellValue(HSSFCell cell, String key, Object obj, String[] args) {
	514	+ try {
	515	+ // 保有存单元格的内容
	516	+ String cellValue = key = key.replace("\\n", "");
	517	+ String tmpKey;
	518	+ // 判断单元格内容是否是公式
	519	+ if(cell.getCellType() == HSSFCell.CELL_TYPE_FORMULA){
	520	+ Pattern p=Pattern.compile("(\\d+)"); //
	521	+ Matcher m=p.matcher(key);
	522	+ if(m.find()){
	523	+ cellValue = key.replace(m.group(1),
	524	+ Integer.valueOf(m.group(1))+Integer.valueOf(args[0])+"");
	525	+ cell.setCellFormula(cellValue);
	526	+ return;
	527	+ }
	528	+ }else{//其他格式
	529	+
	530	+ // 循环截取两个$中间的内容，反射出值
	531	+ while (key.indexOf("$") != -1) {
	532	+ key = key.substring(key.indexOf("$") + 1);
	533	+ // 取两个$中间的内容
	534	+ tmpKey = key.substring(0, key.indexOf("$"));
	535	+ key = key.substring(key.indexOf("$") + 1);
	536	+ // 如果内容是如下格式Cars.id，则从obj中值得相应的对象的值
	537	+ if (tmpKey.indexOf(".") != -1) {
	538	+ String className = tmpKey.substring(0, tmpKey.indexOf("."));
	539	+ // 取得类的全限定名
	540	+ String classWholeName = packaegName + className;
	541	+ String fieldName = tmpKey.substring(tmpKey.indexOf(".") + 1);
	542	+ // 如果obj是数组，循环判断哪个对象是对应的
	543	+ if (obj instanceof Object[]) {
	544	+ Object[] objs = (Object[]) obj;
	545	+ for (int k = 0; k < objs.length; k++) {
	546	+ if (objs[k].getClass().getName().equals(classWholeName)) {
	547	+ cellValue = cellValue.replace("$" + tmpKey
	548	+ + "$", getKeyValue(objs[k], fieldName)
	549	+ + "");
	550	+ } else if(objs[k].getClass().getName().equals("java.util.HashMap")){
	551	+ Map<String,Object> map = (HashMap<String,Object>)objs[k];
	552	+ cellValue = cellValue.replace("$" + tmpKey + "$",map.get(fieldName)+"");
	553	+ }
	554	+ }
	555	+ } else if (obj.getClass().getName().equals(classWholeName)) {
	556	+ cellValue = cellValue.replace("$" + tmpKey + "$",getKeyValue(obj, fieldName) + "");
	557	+ } else if (obj.getClass().getName().equals("java.util.HashMap")){
	558	+ Map<String,Object> map = (HashMap<String,Object>)obj;
	559	+ cellValue = cellValue.replace("$" + tmpKey + "$",map.get(fieldName)+"");
	560	+ }
	561	+ }
	562	+ }
	563	+ }
	564	+ cell.setCellValue(cellValue);
	565	+ Matcher matcher = pattern.matcher(cellValue);
	566	+ if (matcher.matches()) {
	567	+ if (cellValue.indexOf(".") > -1) {
	568	+ cell.setCellValue(Double.parseDouble(cellValue));
	569	+ } else {
	570	+ cell.setCellValue(Integer.parseInt(cellValue));
	571	+ }
	572	+ }
	573	+ } catch (Exception e) {
	574	+ e.printStackTrace();
	575	+ }
	576	+
	577	+ }
	578	+
	579	+ /**
	580	+ * 给列填充数据
	581	+ *
	582	+ * @param cell
	583	+ * 列
	584	+ * @param obj
	585	+ * 数据源对象
	586	+ * @param fieldName
	587	+ * 需要取数据的字段
	588	+ */
	589	+ private Object getKeyValue(Object obj, String fieldName) {
	590	+ Object value = "";
	591	+ try {
	592	+ if (obj != null) {
	593	+ ReportRelatedUtils test = new ReportRelatedUtils();
	594	+ value = test.getValue(obj, fieldName) == null ? "" : test .getValue(obj, fieldName);
	595	+ }
	596	+ } catch (Exception e) {
	597	+ e.printStackTrace();
	598	+ }
	599	+ return value;
	600	+ }
	601	+
	602	+ public static void main(String[] args) {
	603	+
	604	+ try {
	605	+ ReportUtils ee = new ReportUtils();
	606	+ List<Iterator<?>> list = new ArrayList<Iterator<?>>();
	607	+ Line line = new Line();
	608	+ line.setId(1);
	609	+ line.setName("line1");
	610	+
	611	+ List<Object> dataList = new ArrayList<Object>();
	612	+
	613	+
	614	+ ScheduleRealInfo srr = new ScheduleRealInfo();
	615	+ srr.setId((long) 111);
	616	+ srr.setXlName("abc11");
	617	+
	618	+ ScheduleRealInfo sr = new ScheduleRealInfo();
	619	+ sr.setZdsj("06:10");
	620	+ sr.setZdsjActual("06:25");
	621	+ dataList.add(sr);
	622	+ sr = new ScheduleRealInfo();
	623	+ sr.setZdsj("06:20");
	624	+ sr.setZdsjActual("");
	625	+ dataList.add(sr);
	626	+ list.add(dataList.iterator());
	627	+
	628	+ ee.excelReplace(list, new Object[] { srr }, "D:/waybill.xls",
	629	+ "D:/22.xls");
	630	+ System.out.println("ok");
	631	+ } catch (Exception e) {
	632	+ e.printStackTrace();
	633	+ }
	634	+ }
	635	+
	636	+ /**
	637	+ * 行复制功能
	638	+ *
	639	+ * @param fromRow
	640	+ * @param toRow
	641	+ */
	642	+ private void copyRow(HSSFWorkbook wb, HSSFRow fromRow, HSSFRow toRow,
	643	+ boolean copyValueFlag, HSSFCellStyle style) {
	644	+ for (Iterator<Cell> cellIt = fromRow.cellIterator(); cellIt.hasNext();) {
	645	+ HSSFCell tmpCell = (HSSFCell) cellIt.next();
	646	+ HSSFCell newCell = toRow.createCell(tmpCell.getColumnIndex(), 0);
	647	+ copyCell(wb, tmpCell, newCell, copyValueFlag, tmpCell.getCellStyle());
	648	+ }
	649	+ }
	650	+
	651	+ /**
	652	+ * 复制单元格
	653	+ *
	654	+ * @param srcCell
	655	+ * @param distCell
	656	+ * @param copyValueFlag
	657	+ * true则连同cell的内容一起复制
	658	+ */
	659	+ public void copyCell(HSSFWorkbook wb, HSSFCell srcCell, HSSFCell distCell,
	660	+ boolean copyValueFlag, HSSFCellStyle newstyle) {
	661	+// HSSFCellStyle newstyle = wb.createCellStyle();
	662	+ copyCellStyle(wb, srcCell.getCellStyle(), newstyle);
	663	+ // 样式
	664	+ distCell.setCellStyle(newstyle);
	665	+ // 评论
	666	+ if (srcCell.getCellComment() != null) {
	667	+ distCell.setCellComment(srcCell.getCellComment());
	668	+ }
	669	+ // 不同数据类型处理
	670	+ int srcCellType = srcCell.getCellType();
	671	+ distCell.setCellType(srcCellType);
	672	+ if (copyValueFlag) {
	673	+ if (srcCellType == HSSFCell.CELL_TYPE_NUMERIC) {
	674	+ distCell.setCellValue(srcCell.getDateCellValue());
	675	+ } else if (srcCellType == HSSFCell.CELL_TYPE_STRING) {
	676	+ distCell.setCellValue(srcCell.getRichStringCellValue());
	677	+ } else if (srcCellType == HSSFCell.CELL_TYPE_BLANK) {
	678	+
	679	+ } else if (srcCellType == HSSFCell.CELL_TYPE_BOOLEAN) {
	680	+ distCell.setCellValue(srcCell.getBooleanCellValue());
	681	+ } else if (srcCellType == HSSFCell.CELL_TYPE_ERROR) {
	682	+ distCell.setCellErrorValue(srcCell.getErrorCellValue());
	683	+ } else if (srcCellType == HSSFCell.CELL_TYPE_FORMULA) {
	684	+ distCell.setCellFormula(srcCell.getCellFormula());
	685	+ } else {
	686	+ }
	687	+ }
	688	+ }
	689	+
	690	+ /**
	691	+ * 复制一个单元格样式到目的单元格样式
	692	+ *
	693	+ * @param fromStyle
	694	+ * @param toStyle
	695	+ */
	696	+ public void copyCellStyle(HSSFWorkbook wb, HSSFCellStyle fromStyle,
	697	+ HSSFCellStyle toStyle) {
	698	+ toStyle.setAlignment(fromStyle.getAlignment());
	699	+ // 边框和边框颜色
	700	+ toStyle.setBorderBottom(fromStyle.getBorderBottom());
	701	+ toStyle.setBorderLeft(fromStyle.getBorderLeft());
	702	+ toStyle.setBorderRight(fromStyle.getBorderRight());
	703	+ toStyle.setBorderTop(fromStyle.getBorderTop());
	704	+ toStyle.setTopBorderColor(fromStyle.getTopBorderColor());
	705	+ toStyle.setBottomBorderColor(fromStyle.getBottomBorderColor());
	706	+ toStyle.setRightBorderColor(fromStyle.getRightBorderColor());
	707	+ toStyle.setLeftBorderColor(fromStyle.getLeftBorderColor());
	708	+
	709	+ // 背景和前景
	710	+ toStyle.setFillBackgroundColor(fromStyle.getFillBackgroundColor());
	711	+ toStyle.setFillForegroundColor(fromStyle.getFillForegroundColor());
	712	+
	713	+ toStyle.setDataFormat(fromStyle.getDataFormat());
	714	+ toStyle.setFillPattern(fromStyle.getFillPattern());
	715	+ toStyle.setHidden(fromStyle.getHidden());
	716	+ toStyle.setIndention(fromStyle.getIndention());// 首行缩进
	717	+ toStyle.setLocked(fromStyle.getLocked());
	718	+ toStyle.setRotation(fromStyle.getRotation());// 旋转
	719	+ toStyle.setVerticalAlignment(fromStyle.getVerticalAlignment());
	720	+ toStyle.setWrapText(fromStyle.getWrapText());
	721	+ // 字体
	722	+ toStyle.setFont(fromStyle.getFont(wb));
	723	+
	724	+ }
	725	+
	726	+ /**
	727	+ * 创建文件夹，并删除原有文件
	728	+ *
	729	+ * @param path
	730	+ */
	731	+ private void createFolder(String path) {
	732	+ File targetFile = null;
	733	+ targetFile = new File(path);
	734	+ if (targetFile.exists()) {// 删除原有文件
	735	+ targetFile.delete();
	736	+ }
	737	+ // 创建目标文件夹
	738	+ targetFile = new File(path.substring(0, path.lastIndexOf("/")));
	739	+ if (!targetFile.exists()) {
	740	+ targetFile.mkdirs();
	741	+ }
	742	+ }
	743	+
	744	+ public void createFlie(List<List<String>> list, String name, String type){
	745	+ HSSFWorkbook workbook = new HSSFWorkbook();
	746	+ // 生成一个样式
	747	+ HSSFCellStyle style = workbook.createCellStyle();
	748	+ // 设置这些样式
	749	+// style.setFillForegroundColor(HSSFColor.SKY_BLUE.index);
	750	+// style.setFillPattern(HSSFCellStyle.BORDER_THIN);
	751	+ style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
	752	+ style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
	753	+ style.setBorderRight(HSSFCellStyle.BORDER_THIN);
	754	+ style.setBorderTop(HSSFCellStyle.BORDER_THIN);
	755	+ style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
	756	+ // 生成一个字体
	757	+ HSSFFont font = workbook.createFont();
	758	+// font.setColor(HSSFColor.VIOLET.index);
	759	+ font.setFontHeightInPoints((short) 12);
	760	+ font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
	761	+ // 把字体应用到当前的样式
	762	+ style.setFont(font);
	763	+ HSSFCellStyle cellStyle =workbook.createCellStyle();
	764	+ cellStyle.setFont(font);
	765	+ cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER); //水平布局：居中
	766	+ cellStyle.setWrapText(true);
	767	+
	768	+ //设置wordsheet名
	769	+ HSSFSheet sheetYS = workbook.createSheet();//设置wordsheet名
	770	+ HSSFRow row = sheetYS.createRow(0);
	771	+ setCellStyleAndValue(row, style, 0, name);
	772	+ CellRangeAddress callRangeAddress = new CellRangeAddress(0,0,0,list.get(0).size()-1);
	773	+ sheetYS.addMergedRegion(callRangeAddress);
	774	+ // 样式
	775	+ setMergeCellStyle (callRangeAddress, sheetYS, workbook);
	776	+
	777	+ try{
	778	+ for(int i=0; i<list.size(); i++){
	779	+ HSSFRow rowYSi = sheetYS.createRow(i+1);
	780	+ List<String> stringList = list.get(i);
	781	+ int num = 4;
	782	+ if("xl".equals(type))
	783	+ num = 2;
	784	+ else if("cl".equals(type))
	785	+ num = 5;
	786	+ for(int j=0; j<stringList.size(); j++){
	787	+ String str = stringList.get(j);
	788	+ if(i == list.size()-1){
	789	+ if(j==0) {
	790	+ setCellStyleAndValue(rowYSi, style, j, str);
	791	+ CellRangeAddress callRangeAddressYSi = new CellRangeAddress(i+1,i+1,0,num);
	792	+ sheetYS.addMergedRegion(callRangeAddressYSi);
	793	+ // 样式
	794	+ setMergeCellStyle (callRangeAddressYSi, sheetYS, workbook);
	795	+ }else
	796	+ setCellStyleAndValue(rowYSi,style,j+num,str);
	797	+ } else {
	798	+ setCellStyleAndValue(rowYSi,style,j,str);
	799	+ }
	800	+ }
	801	+ }
	802	+
	803	+ // 给列设置宽度自适应
	804	+ setSizeColumn1(sheetYS,1,list.get(0).size());
	805	+ String path = this.getClass().getResource("/").getPath() + "static/pages/forms/export/";
	806	+ String targetPath = path+name+".xls";
	807	+ createFolder(targetPath);
	808	+ FileOutputStream fout = new FileOutputStream(targetPath);
	809	+ //5.输出
	810	+ workbook.write(fout);
	811	+ fout.close();
	812	+ } catch (Exception e) {
	813	+ e.printStackTrace();
	814	+ }
	815	+ }
	816	+
	817	+ /**
	818	+ * 自适应宽度(中文支持)
	819	+ * @param sheet
	820	+ * @param size
	821	+ */
	822	+ private static void setSizeColumn(HSSFSheet sheet, int size) {
	823	+ for (int columnNum = 0; columnNum < size; columnNum++) {
	824	+ int columnWidth = sheet.getColumnWidth(columnNum) / 256;
	825	+ for (int rowNum = 0; rowNum < sheet.getLastRowNum(); rowNum++) {
	826	+ HSSFRow currentRow;
	827	+ //当前行未被使用过
	828	+ if (sheet.getRow(rowNum) == null) {
	829	+ currentRow = sheet.createRow(rowNum);
	830	+ } else {
	831	+ currentRow = sheet.getRow(rowNum);
	832	+ }
	833	+ if (currentRow.getCell(columnNum) != null) {
	834	+ HSSFCell currentCell = currentRow.getCell(columnNum);
	835	+ if (currentCell.getCellType() == XSSFCell.CELL_TYPE_STRING) {
	836	+ int length = currentCell.getStringCellValue().getBytes().length;
	837	+ if (columnWidth < length) {
	838	+ columnWidth = length;
	839	+ }
	840	+ }
	841	+ }
	842	+ }
	843	+ sheet.setColumnWidth(columnNum, columnWidth * 300);
	844	+// sheet.setColumnWidth(columnNum, columnWidth * 256);
	845	+ }
	846	+ }
	847	+
	848	+ /**
	849	+ * 自适应宽度(中文支持)
	850	+ * @param sheet
	851	+ * @param index 从那一行开始自适应
	852	+ * @param size
	853	+ */
	854	+ private static void setSizeColumn1(HSSFSheet sheet,int index, int size) {
	855	+ for (int columnNum = index; columnNum < size; columnNum++) {
	856	+ int columnWidth = sheet.getColumnWidth(columnNum) / 256;
	857	+ for (int rowNum = 0; rowNum < sheet.getLastRowNum(); rowNum++) {
	858	+ HSSFRow currentRow;
	859	+ //当前行未被使用过
	860	+ if (sheet.getRow(rowNum) == null) {
	861	+ currentRow = sheet.createRow(rowNum);
	862	+ } else {
	863	+ currentRow = sheet.getRow(rowNum);
	864	+ }
	865	+ if (currentRow.getCell(columnNum) != null) {
	866	+ HSSFCell currentCell = currentRow.getCell(columnNum);
	867	+ if (currentCell.getCellType() == XSSFCell.CELL_TYPE_STRING) {
	868	+ int length = currentCell.getStringCellValue().getBytes().length;
	869	+ if (columnWidth < length) {
	870	+ columnWidth = length;
	871	+ }
	872	+ }
	873	+ }
	874	+ }
	875	+ sheet.setColumnWidth(columnNum, columnWidth * 300);
	876	+// sheet.setColumnWidth(columnNum, columnWidth * 256);
	877	+ }
	878	+ }
	879	+
	880	+ /**
	881	+ * 设置单元格值和样式
	882	+ * @param row
	883	+ * @param style
	884	+ * @param index
	885	+ * @param value
	886	+ */
	887	+ public static void setCellStyleAndValue(HSSFRow row,HSSFCellStyle style,int index,String value){
	888	+ HSSFCell cell = row.createCell(index);
	889	+ cell.setCellValue(value);
	890	+ cell.setCellStyle(style);
	891	+ }
	892	+ /**
	893	+ * 设置合并单元格样式
	894	+ * @param cra
	895	+ * @param sheet
	896	+ * @param workbook
	897	+ */
	898	+ public static void setMergeCellStyle (CellRangeAddress cra, HSSFSheet sheet, Workbook workbook){
	899	+ // 使用RegionUtil类为合并后的单元格添加边框
	900	+ RegionUtil.setBorderBottom(1, cra, sheet, workbook); // 下边框
	901	+ RegionUtil.setBorderLeft(1, cra, sheet, workbook); // 左边框
	902	+ RegionUtil.setBorderRight(1, cra, sheet, workbook); // 有边框
	903	+ RegionUtil.setBorderTop(1, cra, sheet, workbook); // 上边框
	904	+ }
	905	+}
...	...

潘钊 / bsth_control · Commits

GitLab

复制到后面一页时，转换为string格式单元格会报错。