Skip to content

E
easyexcel

司南-yh / easyexcel
与 Fork 源项目一致

从无法访问的项目Fork

通知 1
Star 0
Fork 0
E
easyexcel

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 f065e370 编写于 作者: 庄家钜's avatar 庄家钜
浏览文件
操作

提交部分代码

上级 827153fd
展开全部 隐藏空白更改
内联 并排
Showing with 2005 addition and 14 deletion
README.md
浏览文件 @ f065e370
......@@ -30,7 +30,7 @@ DEMO代码地址：[https://github.com/alibaba/easyexcel/blob/master/src/test/ja
/**
* 最简单的读
* <p>1. 创建excel对应的实体对象 参照{@link DemoData}
* <p>2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
* <p>2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
* <p>3. 直接读即可
*/
@Test
......@@ -81,7 +81,7 @@ DEMO代码地址：[https://github.com/alibaba/easyexcel/blob/master/src/test/ja
/**
* 文件上传
* <p>1. 创建excel对应的实体对象 参照{@link UploadData}
* <p>2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link UploadDataListener}
* <p>2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link UploadDataListener}
* <p>3. 直接读即可
*/
@PostMapping("upload")
......
src/main/java/com/alibaba/excel/constant/BuiltinFormats.java 0 → 100644
浏览文件 @ f065e370
package com.alibaba.excel.constant;
import com.alibaba.excel.util.StringUtils;
/**
* Excel's built-in format conversion.Currently only supports Chinese.
*
* <p>
* If it is not Chinese, it is recommended to directly modify the builtinFormats, which will better support
* internationalization in the future.
*
* <p>
* Specific correspondence please see:
* https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.numberingformat?view=openxml-2.8.1
*
* @author Jiaju Zhuang
**/
public class BuiltinFormats {
public static String[] builtinFormats = {
// 0
"General",
// 1
"0",
// 2
"0.00",
// 3
"#,##0",
// 4
"#,##0.00",
// 5
"\"$\"#,##0_);(\"$\"#,##0)",
// 6
"\"$\"#,##0_);[Red](\"$\"#,##0)",
// 7
"\"$\"#,##0.00_);(\"$\"#,##0.00)",
// 8
"\"$\"#,##0.00_);[Red](\"$\"#,##0.00)",
// 9
"0%",
// 10
"0.00%",
// 11
"0.00E+00",
// 12
"# ?/?",
// 13
"# ??/??",
// 14
"m/d/yy",
// 15
"d-mmm-yy",
// 16
"d-mmm",
// 17
"mmm-yy",
// 18
"h:mm AM/PM",
// 19
"h:mm:ss AM/PM",
// 20
"h:mm",
// 21
"h:mm:ss",
// 22
"m/d/yy h:mm",
// 23-26 No specific correspondence found in the official documentation.
// 23
null,
// 24
null,
// 25
null,
// 26
null,
// 27
"yyyy\"5E74\"m\"6708\"",
// 28
"m\"6708\"d\"65E5\"",
// 29
"m\"6708\"d\"65E5\"",
// 30
"m-d-yy",
// 31
"yyyy\"5E74\"m\"6708\"d\"65E5\"",
// 32
"h\"65F6\"mm\"5206\"",
// 33
"h\"65F6\"mm\"5206\"ss\"79D2\"",
// 34
"4E0A5348/4E0B5348h\"65F6\"mm\"5206\"",
// 35
"4E0A5348/4E0B5348h\"65F6\"mm\"5206\"ss\"79D2\"",
// 36
"yyyy\"5E74\"m\"6708\"",
// 37
"#,##0_);(#,##0)",
// 38
"#,##0_);[Red](#,##0)",
// 39
"#,##0.00_);(#,##0.00)",
// 40
"#,##0.00_);[Red](#,##0.00)",
// 41
"_(* #,##0_);_(* (#,##0);_(* \"-\"_);_(@_)",
// 42
"_(\"$\"* #,##0_);_(\"$\"* (#,##0);_(\"$\"* \"-\"_);_(@_)",
// 43
"_(* #,##0.00_);_(* (#,##0.00);_(* \"-\"??_);_(@_)",
// 44
"_(\"$\"* #,##0.00_);_(\"$\"* (#,##0.00);_(\"$\"* \"-\"??_);_(@_)",
// 45
"mm:ss",
// 46
"[h]:mm:ss",
// 47
"mm:ss.0",
// 48
"##0.0E+0",
// 49
"@",
// 50
"yyyy\"5E74\"m\"6708\"",
// 51
"m\"6708\"d\"65E5\"",
// 52
"yyyy\"5E74\"m\"6708\"",
// 53
"m\"6708\"d\"65E5\"",
// 54
"m\"6708\"d\"65E5\"",
// 55
"4E0A5348/4E0B5348h\"65F6\"mm\"5206\"",
// 56
"4E0A5348/4E0B5348h\"65F6\"mm\"5206\"ss\"79D2\"",
// 57
"yyyy\"5E74\"m\"6708\"",
// 58
"m\"6708\"d\"65E5\"",
// 59
"t0",
// 60
"t0.00",
// 61
"t#,##0",
// 62
"t#,##0.00",
// 63-66 No specific correspondence found in the official documentation.
// 63
null,
// 64
null,
// 65
null,
// 66
null,
// 67
"t0%",
// 68
"t0.00%",
// 69
"t# ?/?",
// 70
"t# ??/??",
// 71
"0E27/0E14/0E1B0E1B0E1B0E1B",
// 72
"0E27-0E140E140E14-0E1B0E1B",
// 73
"0E27-0E140E140E14",
// 74
"0E140E140E14-0E1B0E1B",
// 75
"0E0A:0E190E19",
// 76
"0E0A:0E190E19:0E170E17",
// 77
"0E27/0E14/0E1B0E1B0E1B0E1B 0E0A:0E190E19",
// 78
"0E190E19:0E170E17",
// 79
"[0E0A]:0E190E19:0E170E17",
// 80
"0E190E19:0E170E17.0",
// 81
"d/m/bb",
// end
};
public static String getBuiltinFormat(Integer index) {
if (index == null || index < 0 || index >= builtinFormats.length) {
return null;
}
return builtinFormats[index];
}
public static String getFormat(Integer index, String format) {
if (!StringUtils.isEmpty(format)) {
return format;
}
return getBuiltinFormat(index);
}
}
src/main/java/com/alibaba/excel/util/DateUtils.java
浏览文件 @ f065e370
package com.alibaba.excel.util;
import java.text.Format;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.alibaba.excel.exception.ExcelDataConvertException;
import org.apache.poi.ss.formula.ConditionalFormattingEvaluator;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.ExcelNumberFormat;
import org.apache.poi.ss.usermodel.ExcelStyleDateFormatter;
/**
* Date utils
......@@ -12,6 +17,9 @@ import com.alibaba.excel.exception.ExcelDataConvertException;
* @author Jiaju Zhuang
**/
public class DateUtils {
public static final String DATE_FORMAT_10 = "yyyy-MM-dd";
public static final String DATE_FORMAT_14 = "yyyyMMddHHmmss";
public static final String DATE_FORMAT_17 = "yyyyMMdd HH:mm:ss";
......@@ -101,4 +109,194 @@ public class DateUtils {
}
return new SimpleDateFormat(dateFormat).format(date);
}
//
// /**
// * Determine if it is a date format.
// *
// * @param dataFormat
// * @param dataFormatString
// * @return
// */
// public static boolean isDateFormatted(Integer dataFormat, String dataFormatString) {
// if (cell == null) {
// return false;
// }
// boolean isDate = false;
//
// double d = cell.getNumericCellValue();
// if (DateUtil.isValidExcelDate(d)) {
// ExcelNumberFormat nf = ExcelNumberFormat.from(cell, cfEvaluator);
// if (nf == null) {
// return false;
// }
// bDate = isADateFormat(nf);
// }
// return bDate;
// }
//
// private String getFormattedDateString(Cell cell, ConditionalFormattingEvaluator cfEvaluator) {
// if (cell == null) {
// return null;
// }
// Format dateFormat = getFormat(cell, cfEvaluator);
// synchronized (dateFormat) {
// if(dateFormat instanceof ExcelStyleDateFormatter) {
// // Hint about the raw excel value
// ((ExcelStyleDateFormatter)dateFormat).setDateToBeFormatted(
// cell.getNumericCellValue()
// );
// }
// Date d = cell.getDateCellValue();
// return performDateFormatting(d, dateFormat);
// }
// }
//
//
// public static boolean isADateFormat(int formatIndex, String formatString) {
// // First up, is this an internal date format?
// if (isInternalDateFormat(formatIndex)) {
// return true;
// }
// if (StringUtils.isEmpty(formatString)) {
// return false;
// }
//
// // check the cache first
// if (isCached(formatString, formatIndex)) {
// return lastCachedResult.get();
// }
//
// String fs = formatString;
// /*if (false) {
// // Normalize the format string. The code below is equivalent
// // to the following consecutive regexp replacements:
//
// // Translate \- into just -, before matching
// fs = fs.replaceAll("\\\\-","-");
// // And \, into ,
// fs = fs.replaceAll("\\\\,",",");
// // And \. into .
// fs = fs.replaceAll("\\\\\\.",".");
// // And '\ ' into ' '
// fs = fs.replaceAll("\\\\ "," ");
//
// // If it end in ;@, that's some crazy dd/mm vs mm/dd
// // switching stuff, which we can ignore
// fs = fs.replaceAll(";@", "");
//
// // The code above was reworked as suggested in bug 48425:
// // simple loop is more efficient than consecutive regexp replacements.
// }*/
// final int length = fs.length();
// StringBuilder sb = new StringBuilder(length);
// for (int i = 0; i < length; i++) {
// char c = fs.charAt(i);
// if (i < length - 1) {
// char nc = fs.charAt(i + 1);
// if (c == '\\') {
// switch (nc) {
// case '-':
// case ',':
// case '.':
// case ' ':
// case '\\':
// // skip current '\' and continue to the next char
// continue;
// }
// } else if (c == ';' && nc == '@') {
// i++;
// // skip ";@" duplets
// continue;
// }
// }
// sb.append(c);
// }
// fs = sb.toString();
//
// // short-circuit if it indicates elapsed time: [h], [m] or [s]
// if (date_ptrn4.matcher(fs).matches()) {
// cache(formatString, formatIndex, true);
// return true;
// }
// // If it starts with [DBNum1] or [DBNum2] or [DBNum3]
// // then it could be a Chinese date
// fs = date_ptrn5.matcher(fs).replaceAll("");
// // If it starts with [$-...], then could be a date, but
// // who knows what that starting bit is all about
// fs = date_ptrn1.matcher(fs).replaceAll("");
// // If it starts with something like [Black] or [Yellow],
// // then it could be a date
// fs = date_ptrn2.matcher(fs).replaceAll("");
// // You're allowed something like dd/mm/yy;[red]dd/mm/yy
// // which would place dates before 1900/1904 in red
// // For now, only consider the first one
// final int separatorIndex = fs.indexOf(';');
// if (0 < separatorIndex && separatorIndex < fs.length() - 1) {
// fs = fs.substring(0, separatorIndex);
// }
//
// // Ensure it has some date letters in it
// // (Avoids false positives on the rest of pattern 3)
// if (!date_ptrn3a.matcher(fs).find()) {
// return false;
// }
//
// // If we get here, check it's only made up, in any case, of:
// // y m d h s - \ / , . : [ ] T
// // optionally followed by AM/PM
//
// boolean result = date_ptrn3b.matcher(fs).matches();
// cache(formatString, formatIndex, result);
// return result;
// }
//
// /**
// * Given a format ID this will check whether the format represents an internal excel date format or not.
// *
// * @see #isADateFormat(int, java.lang.String)
// */
// public static boolean isInternalDateFormat(int format) {
// switch (format) {
// // Internal Date Formats as described on page 427 in
// // Microsoft Excel Dev's Kit...
// // 14-22
// case 0x0e:
// case 0x0f:
// case 0x10:
// case 0x11:
// case 0x12:
// case 0x13:
// case 0x14:
// case 0x15:
// case 0x16:
// // 27-36
// case 0x1b:
// case 0x1c:
// case 0x1d:
// case 0x1e:
// case 0x1f:
// case 0x20:
// case 0x21:
// case 0x22:
// case 0x23:
// case 0x24:
// // 45-47
// case 0x2d:
// case 0x2e:
// case 0x2f:
// // 50-58
// case 0x32:
// case 0x33:
// case 0x34:
// case 0x35:
// case 0x36:
// case 0x37:
// case 0x38:
// case 0x39:
// case 0x3a:
// return true;
// }
// return false;
// }
}
src/main/java/com/alibaba/excel/util/NumberDataFormatterUtils.java 0 → 100644
浏览文件 @ f065e370
//package com.alibaba.excel.util;
//
//import java.text.Format;
//
//import org.apache.poi.ss.format.CellFormat;
//import org.apache.poi.ss.formula.ConditionalFormattingEvaluator;
//import org.apache.poi.ss.usermodel.Cell;
//import org.apache.poi.ss.usermodel.DataFormatter;
//import org.apache.poi.ss.usermodel.DateUtil;
//import org.apache.poi.ss.usermodel.ExcelNumberFormat;
//import org.apache.poi.ss.usermodel.ExcelStyleDateFormatter;
//import org.apache.poi.util.POILogger;
//
///**
// * Convert number data, including date.
// *
// * @author Jiaju Zhuang
// **/
//public class NumberDataFormatterUtils {
//
// /**
// *
// * @param data
// * Not null.
// * @param dataFormatString
// * Not null.
// * @return
// */
// public String format(Double data, Integer dataFormat, String dataFormatString) {
//
// if (DateUtil.isCellDateFormatted(cell, cfEvaluator)) {
// return getFormattedDateString(cell, cfEvaluator);
// }
// return getFormattedNumberString(cell, cfEvaluator);
//
// }
//
// private String getFormattedDateString(Double data,String dataFormatString) {
//
//
// if (cell == null) {
// return null;
// }
// Format dateFormat = getFormat(cell, cfEvaluator);
// synchronized (dateFormat) {
// if (dateFormat instanceof ExcelStyleDateFormatter) {
// // Hint about the raw excel value
// ((ExcelStyleDateFormatter)dateFormat).setDateToBeFormatted(cell.getNumericCellValue());
// }
// Date d = cell.getDateCellValue();
// return performDateFormatting(d, dateFormat);
// }
// }
//
//
// /**
// * Return a Format for the given cell if one exists, otherwise try to
// * create one. This method will return <code>null</code> if the any of the
// * following is true:
// * <ul>
// * <li>the cell's style is null</li>
// * <li>the style's data format string is null or empty</li>
// * <li>the format string cannot be recognized as either a number or date</li>
// * </ul>
// *
// * @param cell The cell to retrieve a Format for
// * @return A Format for the format String
// */
// private Format getFormat(Cell cell, ConditionalFormattingEvaluator cfEvaluator) {
// if (cell == null) return null;
//
// ExcelNumberFormat numFmt = ExcelNumberFormat.from(cell, cfEvaluator);
//
// if ( numFmt == null) {
// return null;
// }
//
// int formatIndex = numFmt.getIdx();
// String formatStr = numFmt.getFormat();
// if(formatStr == null || formatStr.trim().length() == 0) {
// return null;
// }
// return getFormat(cell.getNumericCellValue(), formatIndex, formatStr, isDate1904(cell));
// }
//
// private boolean isDate1904(Cell cell) {
// if ( cell != null && cell.getSheet().getWorkbook() instanceof Date1904Support) {
// return ((Date1904Support)cell.getSheet().getWorkbook()).isDate1904();
//
// }
// return false;
// }
//
// private Format getFormat(double cellValue, int formatIndex, String formatStrIn, boolean use1904Windowing) {
// localeChangedObservable.checkForLocaleChange();
//
// // Might be better to separate out the n p and z formats, falling back to p when n and z are not set.
// // That however would require other code to be re factored.
// // String[] formatBits = formatStrIn.split(";");
// // int i = cellValue > 0.0 ? 0 : cellValue < 0.0 ? 1 : 2;
// // String formatStr = (i < formatBits.length) ? formatBits[i] : formatBits[0];
//
// String formatStr = formatStrIn;
//
// // Excel supports 2+ part conditional data formats, eg positive/negative/zero,
// // or (>1000),(>0),(0),(negative). As Java doesn't handle these kinds
// // of different formats for different ranges, just +ve/-ve, we need to
// // handle these ourselves in a special way.
// // For now, if we detect 2+ parts, we call out to CellFormat to handle it
// // TODO Going forward, we should really merge the logic between the two classes
// if (formatStr.contains(";") &&
// (formatStr.indexOf(';') != formatStr.lastIndexOf(';')
// || rangeConditionalPattern.matcher(formatStr).matches()
// ) ) {
// try {
// // Ask CellFormat to get a formatter for it
// CellFormat cfmt = CellFormat.getInstance(locale, formatStr);
// // CellFormat requires callers to identify date vs not, so do so
// Object cellValueO = Double.valueOf(cellValue);
// if (DateUtil.isADateFormat(formatIndex, formatStr) &&
// // don't try to handle Date value 0, let a 3 or 4-part format take care of it
// ((Double)cellValueO).doubleValue() != 0.0) {
// cellValueO = DateUtil.getJavaDate(cellValue, use1904Windowing);
// }
// // Wrap and return (non-cachable - CellFormat does that)
// return new DataFormatter.CellFormatResultWrapper( cfmt.apply(cellValueO) );
// } catch (Exception e) {
// logger.log(POILogger.WARN, "Formatting failed for format " + formatStr + ", falling back", e);
// }
// }
//
// // Excel's # with value 0 will output empty where Java will output 0. This hack removes the # from the format.
// if (emulateCSV && cellValue == 0.0 && formatStr.contains("#") && !formatStr.contains("0")) {
// formatStr = formatStr.replaceAll("#", "");
// }
//
// // See if we already have it cached
// Format format = formats.get(formatStr);
// if (format != null) {
// return format;
// }
//
// // Is it one of the special built in types, General or @?
// if ("General".equalsIgnoreCase(formatStr) || "@".equals(formatStr)) {
// return generalNumberFormat;
// }
//
// // Build a formatter, and cache it
// format = createFormat(cellValue, formatIndex, formatStr);
// formats.put(formatStr, format);
// return format;
// }
//
//}
src/test/java/com/alibaba/easyexcel/test/demo/read/ReadTest.java
浏览文件 @ f065e370
......@@ -33,7 +33,7 @@ public class ReadTest {
* <p>
* 1. 创建excel对应的实体对象 参照{@link DemoData}
* <p>
* 2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
* 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
* <p>
* 3. 直接读即可
*/
......@@ -60,7 +60,7 @@ public class ReadTest {
* <p>
* 1. 创建excel对应的实体对象,并使用{@link ExcelProperty}注解. 参照{@link IndexOrNameData}
* <p>
* 2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link IndexOrNameDataListener}
* 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link IndexOrNameDataListener}
* <p>
* 3. 直接读即可
*/
......@@ -76,7 +76,7 @@ public class ReadTest {
* <p>
* 1. 创建excel对应的实体对象 参照{@link DemoData}
* <p>
* 2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
* 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
* <p>
* 3. 直接读即可
*/
......@@ -108,7 +108,7 @@ public class ReadTest {
* <p>
* 1. 创建excel对应的实体对象 参照{@link ConverterData}.里面可以使用注解{@link DateTimeFormat}、{@link NumberFormat}或者自定义注解
* <p>
* 2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link ConverterDataListener}
* 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link ConverterDataListener}
* <p>
* 3. 直接读即可
*/
......@@ -130,7 +130,7 @@ public class ReadTest {
* <p>
* 1. 创建excel对应的实体对象 参照{@link DemoData}
* <p>
* 2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
* 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
* <p>
* 3. 设置headRowNumber参数，然后读。 这里要注意headRowNumber如果不指定， 会根据你传入的class的{@link ExcelProperty#value()}里面的表头的数量来决定行数，
* 如果不传入class则默认为1.当然你指定了headRowNumber不管是否传入class都是以你传入的为准。
......@@ -150,7 +150,7 @@ public class ReadTest {
* <p>
* 1. 创建excel对应的实体对象 参照{@link DemoData}
* <p>
* 2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoHeadDataListener}
* 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoHeadDataListener}
* <p>
* 3. 直接读即可
*/
......@@ -167,7 +167,7 @@ public class ReadTest {
* <p>
* 1. 创建excel对应的实体对象 参照{@link DemoData}
* <p>
* 2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoHeadDataListener}
* 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoHeadDataListener}
* <p>
* 3. 直接读即可
*/
......@@ -184,7 +184,7 @@ public class ReadTest {
* <p>
* 1. 创建excel对应的实体对象 参照{@link ExceptionDemoData}
* <p>
* 2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoExceptionListener}
* 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoExceptionListener}
* <p>
* 3. 直接读即可
*/
......
src/test/java/com/alibaba/easyexcel/test/demo/web/WebTest.java
浏览文件 @ f065e370
......@@ -85,7 +85,7 @@ public class WebTest {
* <p>
* 1. 创建excel对应的实体对象 参照{@link UploadData}
* <p>
* 2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link UploadDataListener}
* 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link UploadDataListener}
* <p>
* 3. 直接读即可
*/
......
src/test/java/com/alibaba/easyexcel/test/temp/Lock2Test.java
浏览文件 @ f065e370
......@@ -29,7 +29,7 @@ public class Lock2Test {
@Test
public void test() throws Exception {
File file = new File("D:\\test\\000001.xlsx");
File file = new File("D:\\test\\headt1.xlsx");
List<Object> list = EasyExcel.read(file).sheet().headRowNumber(0).doReadSync();
LOGGER.info("数据：{}", list.size());
......
src/test/java/com/alibaba/easyexcel/test/temp/dataformat/DataFormatData.java 0 → 100644
浏览文件 @ f065e370
package com.alibaba.easyexcel.test.temp.dataformat;
import com.alibaba.excel.metadata.CellData;
import lombok.Data;
/**
* TODO
*
* @author 罗成
**/
@Data
public class DataFormatData {
private CellData<String> date;
private CellData<String> num;
}
src/test/java/com/alibaba/easyexcel/test/temp/dataformat/DataFormatTest.java 0 → 100644
浏览文件 @ f065e370
package com.alibaba.easyexcel.test.temp.dataformat;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.Ignore;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.easyexcel.test.temp.Lock2Test;
import com.alibaba.excel.EasyExcel;
import com.alibaba.fastjson.JSON;
/**
* 格式测试
*
* @author Jiaju Zhuang
**/
@Ignore
public class DataFormatTest {
private static final Logger LOGGER = LoggerFactory.getLogger(Lock2Test.class);
@Test
public void test() throws Exception {
File file = new File("D:\\test\\dataformat.xlsx");
List<DataFormatData> list =
EasyExcel.read(file, DataFormatData.class, null).sheet().headRowNumber(0).doReadSync();
LOGGER.info("数据：{}", list.size());
for (DataFormatData data : list) {
Integer dataFormat = data.getDate().getDataFormat();
String dataFormatString = data.getDate().getDataFormatString();
if (dataFormat == null || dataFormatString == null) {
} else {
LOGGER.info("格式化：{};{}：{}", dataFormat, dataFormatString,
DateUtil.isADateFormat(dataFormat, dataFormatString));
}
LOGGER.info("返回数据：{}", JSON.toJSONString(data));
}
}
@Test
public void testxls() throws Exception {
File file = new File("D:\\test\\dataformat.xls");
List<DataFormatData> list =
EasyExcel.read(file, DataFormatData.class, null).sheet().headRowNumber(0).doReadSync();
LOGGER.info("数据：{}", list.size());
for (DataFormatData data : list) {
Integer dataFormat = data.getDate().getDataFormat();
String dataFormatString = data.getDate().getDataFormatString();
if (dataFormat == null || dataFormatString == null) {
} else {
LOGGER.info("格式化：{};{}：{}", dataFormat, dataFormatString,
DateUtil.isADateFormat(dataFormat, dataFormatString));
}
LOGGER.info("返回数据：{}", JSON.toJSONString(data));
}
}
@Test
public void test3() throws IOException {
String file = "D:\\test\\dataformat1.xlsx";
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(file);
Sheet xssfSheet = xssfWorkbook.getSheetAt(0);
Cell cell = xssfSheet.getRow(0).getCell(0);
DataFormatter d = new DataFormatter();
System.out.println(d.formatCellValue(cell));
}
@Test
public void test31() throws IOException {
System.out.println(DateUtil.isADateFormat(181, "[DBNum1][$-404]m\"\u6708\"d\"\u65e5\";@"));
}
@Test
public void test43() throws IOException {
SimpleDateFormat s = new SimpleDateFormat("yyyy'年'm'月'd'日' h'点'mm'哈哈哈m'");
System.out.println(s.format(new Date()));
}
@Test
public void test463() throws IOException {
SimpleDateFormat s = new SimpleDateFormat("[$-804]yyyy年m月");
System.out.println(s.format(new Date()));
}
@Test
public void test1() throws Exception {
System.out.println(DateUtil.isADateFormat(181, "yyyy\"年啊\"m\"月\"d\"日\"\\ h"));
System.out.println(DateUtil.isADateFormat(180, "yyyy\"年\"m\"月\"d\"日\"\\ h\"点\""));
}
@Test
public void test2() throws Exception {
List<String> list1 = new ArrayList<String>(3000);
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
list1.clear();
}
System.out.println("end:" + (System.currentTimeMillis() - start));
start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
list1 = new ArrayList<String>(3000);
}
System.out.println("end:" + (System.currentTimeMillis() - start));
}
}
src/test/java/com/alibaba/easyexcel/test/temp/simple/Wirte.java
浏览文件 @ f065e370
......@@ -64,7 +64,7 @@ public class Wirte {
List<DemoData> list = new ArrayList<DemoData>();
for (int i = 0; i < 10; i++) {
DemoData data = new DemoData();
data.setString("字符串" + i);
data.setString("640121807369666560" + i);
data.setDate(new Date());
data.setDoubleData(null);
list.add(data);
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或