repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/LockDataListener.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/LockDataListener.java | package com.alibaba.easyexcel.test.temp;
import java.util.ArrayList;
import java.util.List;
import com.alibaba.easyexcel.test.demo.read.DemoDataListener;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson2.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 模板的读取类
*
* @author Jiaju Zhuang
*/
public class LockDataListener extends AnalysisEventListener<LockData> {
private static final Logger LOGGER = LoggerFactory.getLogger(DemoDataListener.class);
/**
* 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
*/
private static final int BATCH_COUNT = 5;
List<LockData> list = new ArrayList<LockData>();
@Override
public void invoke(LockData data, AnalysisContext context) {
LOGGER.info("解析到一条数据:{}", JSON.toJSONString(data));
list.add(data);
if (list.size() >= BATCH_COUNT) {
saveData();
list.clear();
}
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
saveData();
LOGGER.info("所有数据解析完成！");
}
/**
* 加上存储数据库
*/
private void saveData() {
LOGGER.info("{}条数据，开始存储数据库！", list.size());
LOGGER.info("存储数据库成功！");
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/DemoData3.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/DemoData3.java | package com.alibaba.easyexcel.test.temp;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* 基础数据类
*
* @author Jiaju Zhuang
**/
@Getter
@Setter
@EqualsAndHashCode
public class DemoData3 {
@ExcelProperty("日期时间标题")
private LocalDateTime localDateTime;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/TempFillData.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/TempFillData.java | package com.alibaba.easyexcel.test.temp;
import com.alibaba.excel.annotation.write.style.ContentRowHeight;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* @author Jiaju Zhuang
*/
@Getter
@Setter
@EqualsAndHashCode
@ContentRowHeight(30)
public class TempFillData {
private String name;
private double number;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/Lock2Test.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/Lock2Test.java | package com.alibaba.easyexcel.test.temp;
import java.io.File;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import com.alibaba.easyexcel.test.demo.write.DemoData;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.util.PositionUtils;
import com.alibaba.excel.write.metadata.style.WriteCellStyle;
import com.alibaba.excel.write.metadata.style.WriteFont;
import com.alibaba.excel.write.style.HorizontalCellStyleStrategy;
import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.poi.ss.util.CellReference;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.FillPatternType;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 临时测试
*
* @author Jiaju Zhuang
**/
@Slf4j
public class Lock2Test {
private static final Logger LOGGER = LoggerFactory.getLogger(Lock2Test.class);
@Test
public void test() throws Exception {
// File file = TestFileUtil.readUserHomeFile("test/test4.xlsx");
// File file = TestFileUtil.readUserHomeFile("test/test6.xls");
File file = new File("/Users/zhuangjiaju/IdeaProjects/easyexcel/src/test/resources/converter/converter07.xlsx");
List<Object> list = EasyExcel.read(
"/Users/zhuangjiaju/Downloads/证券投资基金估值表_外贸信托-稳盈淳享37号集合资金信托计划_2024-07-23(1).xls")
//.useDefaultListener(false)
.sheet(0)
.headRowNumber(0).doReadSync();
LOGGER.info("数据：{}", list.size());
for (Object data : list) {
LOGGER.info("返回数据：{}", CollectionUtils.size(data));
LOGGER.info("返回数据：{}", JSON.toJSONString(data));
}
}
@Test
public void test33() throws Exception {
File file = TestFileUtil.readUserHomeFile("test/test6.xlsx");
EasyExcel.read(file, LockData.class, new LockDataListener()).sheet(0).headRowNumber(0)
.doRead();
}
@Test
public void write() throws Exception {
String fileName = TestFileUtil.getPath() + "styleWrite" + System.currentTimeMillis() + ".xlsx";
// 头的策略
WriteCellStyle headWriteCellStyle = new WriteCellStyle();
// 背景设置为红色
headWriteCellStyle.setFillForegroundColor(IndexedColors.RED.getIndex());
WriteFont headWriteFont = new WriteFont();
headWriteFont.setFontHeightInPoints((short)20);
headWriteCellStyle.setWriteFont(headWriteFont);
// 内容的策略
WriteCellStyle contentWriteCellStyle = new WriteCellStyle();
// 这里需要指定 FillPatternType 为FillPatternType.SOLID_FOREGROUND 不然无法显示背景颜色.头默认了 FillPatternType所以可以不指定
contentWriteCellStyle.setFillPatternType(FillPatternType.SOLID_FOREGROUND);
// 背景绿色
contentWriteCellStyle.setFillForegroundColor(IndexedColors.GREEN.getIndex());
WriteFont contentWriteFont = new WriteFont();
// 字体大小
contentWriteFont.setFontHeightInPoints((short)20);
contentWriteCellStyle.setWriteFont(contentWriteFont);
// 这个策略是 头是头的样式 内容是内容的样式 其他的策略可以自己实现
HorizontalCellStyleStrategy horizontalCellStyleStrategy =
new HorizontalCellStyleStrategy(headWriteCellStyle, contentWriteCellStyle);
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
EasyExcel.write(fileName, DemoData.class).registerWriteHandler(horizontalCellStyleStrategy).sheet("模板")
.doWrite(data());
}
@Test
public void simpleWrite() {
String fileName = TestFileUtil.getPath() + System.currentTimeMillis() + ".xlsx";
System.out.println(fileName);
EasyExcel.write(fileName).head(head()).sheet("模板").doWrite(dataList());
}
private List<List<String>> head() {
List<List<String>> list = new ArrayList<List<String>>();
List<String> head0 = new ArrayList<String>();
head0.add("表头");
list.add(head0);
return list;
}
private List<List<Object>> dataList() {
List<List<Object>> list = new ArrayList<List<Object>>();
List<Object> data = new ArrayList<Object>();
data.add("字符串");
data.add(new Date());
data.add(0.56);
list.add(data);
return list;
}
@Test
public void testc() throws Exception {
LOGGER.info("reslut:{}", JSON.toJSONString(new CellReference("B3")));
}
@Test
public void simpleRead() {
// 写法1：
String fileName = "D:\\test\\珠海 (1).xlsx";
// 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
EasyExcel.read(fileName, LockData.class, new LockDataListener()).useDefaultListener(false).sheet().doRead();
}
@Test
public void test2() throws Exception {
File file = new File("D:\\test\\converter03.xls");
List<Object> list = EasyExcel.read(file).sheet().headRowNumber(0).doReadSync();
LOGGER.info("数据：{}", list.size());
for (Object data : list) {
LOGGER.info("返回数据：{}", JSON.toJSONString(data));
}
LOGGER.info("文件状态：{}", file.exists());
file.delete();
Thread.sleep(500 * 1000);
}
@Test
public void test335() throws Exception {
LOGGER.info("reslut:{}", PositionUtils.getCol("A10", null));
LOGGER.info("reslut:{}", PositionUtils.getRow("A10"));
LOGGER.info("reslut:{}", PositionUtils.getCol("AB10", null));
LOGGER.info("reslut:{}", PositionUtils.getRow("AB10"));
//LOGGER.info("reslut:{}", PositionUtils2.getCol("A10",null));
//LOGGER.info("reslut:{}", PositionUtils2.getRow("A10"));
//LOGGER.info("reslut:{}", PositionUtils2.getCol("AB10",null));
//LOGGER.info("reslut:{}", PositionUtils2.getRow("AB10"));
}
@Test
public void numberforamt() throws Exception {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
//LOGGER.info("date:{}",
// NumberDataFormatterUtils.format(BigDecimal.valueOf(44727.99998842592), (short)200, "yyyy-MM-dd HH:mm:ss",
// null,
// null, null));
//
//LOGGER.info("date:{}",
// NumberDataFormatterUtils.format(BigDecimal.valueOf(44728.99998842592), (short)200, "yyyy-MM-dd HH:mm:ss",
// null,
// null, null));
//
//LOGGER.info("date:{}",
// NumberDataFormatterUtils.format(BigDecimal.valueOf(44729.99998836806), (short)200, "yyyy-MM-dd HH:mm:ss",
// null,
// null, null));
//
//LOGGER.info("date:{}",
// NumberDataFormatterUtils.format(BigDecimal.valueOf(44727.99998842592).setScale(10, RoundingMode
// .HALF_UP), (short)200, "yyyy-MM-dd HH:mm:ss",
// null,
// null, null));
//
//LOGGER.info("date:{}",
// NumberDataFormatterUtils.format(BigDecimal.valueOf(44728.99998842592).setScale(10, RoundingMode
// .HALF_UP), (short)200, "yyyy-MM-dd HH:mm:ss",
// null,
// null, null));
//44729.9999883681
//44729.999988368058
//LOGGER.info("date:{}",
// NumberDataFormatterUtils.format(BigDecimal.valueOf(44729.999988368058).setScale(10, RoundingMode
// .HALF_UP), (short)200, "yyyy-MM-dd HH:mm:ss",
// null,
// null, null));
//LOGGER.info("date:{}",BigDecimal.valueOf(44729.999988368058).setScale(10, RoundingMode.HALF_UP).doubleValue
// ());
// 2022/6/17 23:59:59
// 期望 44729.99998842592
//LOGGER.info("data:{}", DateUtil.getJavaDate(44729.9999883681, true));
LOGGER.info("data4:{}", DateUtil.getJavaDate(BigDecimal.valueOf(44729.999988368058)
.setScale(4, RoundingMode.HALF_UP).doubleValue(), false));
LOGGER.info("data5:{}", DateUtil.getJavaDate(BigDecimal.valueOf(44729.999988368058)
.setScale(5, RoundingMode.HALF_UP).doubleValue(), false));
LOGGER.info("data6:{}", DateUtil.getJavaDate(BigDecimal.valueOf(44729.999988368058)
.setScale(6, RoundingMode.HALF_UP).doubleValue(), false));
LOGGER.info("data7:{}", DateUtil.getJavaDate(BigDecimal.valueOf(44729.999988368058)
.setScale(7, RoundingMode.HALF_UP).doubleValue(), false));
LOGGER.info("data8:{}", DateUtil.getJavaDate(BigDecimal.valueOf(44729.999988368058)
.setScale(8, RoundingMode.HALF_UP).doubleValue(), false));
LOGGER.info("data:{}", format.format(DateUtil.getJavaDate(44729.999988368058, false)));
LOGGER.info("data:{}", format.format(DateUtil.getJavaDate(44729.9999883681, false)));
LOGGER.info("data:{}", DateUtil.getJavaDate(Double.parseDouble("44729.999988368058"), false));
LOGGER.info("data:{}", DateUtil.getJavaDate(Double.parseDouble("44729.9999883681"), false));
// 44729.999976851854
// 44729.999988368058
LOGGER.info("data:{}", DateUtil.getExcelDate(format.parse("2022-06-17 23:59:58")));
// 44729.99998842592
LOGGER.info("data:{}", DateUtil.getExcelDate(format.parse("2022-06-17 23:59:59")));
LOGGER.info("data:{}", DateUtil.getJavaDate(BigDecimal.valueOf(44729.999976851854)
.setScale(10, RoundingMode.HALF_UP).doubleValue(), false));
LOGGER.info("data:{}", DateUtil.getJavaDate(BigDecimal.valueOf(44729.99998842592)
.setScale(10, RoundingMode.HALF_UP).doubleValue(), false));
LOGGER.info("data:{}", DateUtil.getJavaDate(BigDecimal.valueOf(44729.999976851854)
.setScale(5, RoundingMode.HALF_UP).doubleValue(), false));
LOGGER.info("data:{}", DateUtil.getJavaDate(BigDecimal.valueOf(44729.99998842592)
.setScale(5, RoundingMode.HALF_UP).doubleValue(), false));
}
@Test
public void testDate() throws Exception {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
log.info("TT:{}", format.format(new Date(100L)));
log.info("TT:{}", new Date().getTime());
}
@Test
public void testDateAll() throws Exception {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
long dateTime = 0L;
while (true) {
Date date = new Date(dateTime);
double excelDate = DateUtil.getExcelDate(date);
Assertions.assertEquals("测试基本转换错误" + dateTime, format.format(date),
format.format(DateUtil.getJavaDate(excelDate, false)));
Assertions.assertEquals("测试精度5转换错误" + dateTime, format.format(date),
format.format(DateUtil.getJavaDate(BigDecimal.valueOf(excelDate)
.setScale(10, RoundingMode.HALF_UP).doubleValue(), false)));
LOGGER.info("date:{}", format2.format(DateUtil.getJavaDate(BigDecimal.valueOf(excelDate)
.setScale(10, RoundingMode.HALF_UP).doubleValue())));
dateTime += 1000L;
// 30天输出
if (dateTime % (24 * 60 * 60 * 1000) == 0) {
log.info("{}成功", format.format(date));
}
if (dateTime > 1673957544750L) {
log.info("结束啦");
break;
}
}
log.info("结束啦");
}
@Test
public void numberforamt3() throws Exception {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
List<Map<Integer, ReadCellData>> list = EasyExcel.read("/Users/zhuangjiaju/Downloads/date3.xlsx")
.useDefaultListener(false)
.sheet(0)
.headRowNumber(0).doReadSync();
LOGGER.info("数据：{}", list.size());
for (Map<Integer, ReadCellData> readCellDataMap : list) {
ReadCellData data = readCellDataMap.get(0);
LOGGER.info("data:{}", format.format(
DateUtil.getJavaDate(data.getNumberValue().setScale(10, RoundingMode.HALF_UP).doubleValue(), false)));
}
//
//LOGGER.info("data:{}", format.format(DateUtil.getJavaDate(44727.999988425923, false)));
//LOGGER.info("data:{}", format.format(DateUtil.getJavaDate(44729.999988368058, false)));
}
@Test
public void numberforamt4() throws Exception {
String fileName = TestFileUtil.getPath() + "simpleWrite" + System.currentTimeMillis() + ".xlsx";
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
// 如果这里想使用03 则 传入excelType参数即可
EasyExcel.write(fileName, DemoData.class)
.sheet("模板")
.doWrite(() -> {
// 分页查询数据
return data2();
});
}
@Test
public void numberforamt77() throws Exception {
String fileName = TestFileUtil.getPath() + "simpleWrite" + System.currentTimeMillis() + ".xlsx";
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
// 如果这里想使用03 则 传入excelType参数即可
EasyExcel.write(fileName, DemoData3.class)
.sheet("模板")
.doWrite(() -> {
List<DemoData3> list = new ArrayList<>();
DemoData3 demoData3 = new DemoData3();
demoData3.setLocalDateTime(LocalDateTime.of(2023, 1, 1, 0, 0, 0, 400000000));
list.add(demoData3);
demoData3 = new DemoData3();
demoData3.setLocalDateTime(LocalDateTime.of(2023, 1, 1, 0, 0, 0, 499000000));
list.add(demoData3);
demoData3 = new DemoData3();
demoData3.setLocalDateTime(LocalDateTime.of(2023, 1, 1, 0, 0, 0, 500000000));
list.add(demoData3);
demoData3 = new DemoData3();
demoData3.setLocalDateTime(LocalDateTime.of(2023, 1, 1, 0, 0, 0, 501000000));
list.add(demoData3);
demoData3 = new DemoData3();
demoData3.setLocalDateTime(LocalDateTime.of(2023, 1, 1, 0, 0, 0, 995000000));
list.add(demoData3);
return list;
});
}
@Test
public void numberforamt99() throws Exception {
LocalDateTime localDateTime = LocalDateTime.of(2023, 1, 1, 0, 0, 0, 995000000);
log.info("date:{}", localDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")));
}
@Test
public void numberforamt5() throws Exception {
String fileName = TestFileUtil.getPath() + "simpleWrite" + System.currentTimeMillis() + ".xlsx";
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
// 如果这里想使用03 则 传入excelType参数即可
EasyExcel.write(fileName, DemoData.class)
.sheet("模板")
.doWrite(() -> {
// 分页查询数据
return data3();
});
}
@Test
public void numberforamt6() throws Exception {
DecimalFormat decimalFormat = new DecimalFormat("#.#");
BigDecimal bigDecimal = new BigDecimal(3101011021236149800L);
log.info("b:{}", bigDecimal);
log.info("b:{}", bigDecimal.setScale(-4, RoundingMode.HALF_UP));
log.info("b:{}", decimalFormat.format(bigDecimal.setScale(-4, RoundingMode.HALF_UP)));
}
@Test
public void numberforamt7() throws Exception {
DecimalFormat decimalFormat = new DecimalFormat("#.#");
BigDecimal bigDecimal = new BigDecimal(3.1010110212361498E+18).round(new MathContext(15, RoundingMode.HALF_UP));
//bigDecimal.
// bigDecimal
log.info("b:{}", bigDecimal);
log.info("b:{}", bigDecimal.setScale(-4, RoundingMode.HALF_UP));
log.info("b:{}", decimalFormat.format(bigDecimal.setScale(-4, RoundingMode.HALF_UP)));
log.info("b:{}", decimalFormat.format(bigDecimal));
}
private List<DemoData2> data3() {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
List<DemoData2> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
DemoData2 data = new DemoData2();
data.setString("字符串" + i);
data.setDoubleData(0.56);
data.setBigDecimal(BigDecimal.valueOf(3101011021236149800L));
list.add(data);
}
return list;
}
private List<DemoData> data() {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
List<DemoData> list = new ArrayList<DemoData>();
for (int i = 0; i < 10; i++) {
DemoData data = new DemoData();
data.setString("字符串" + i);
try {
data.setDate(format.parse("2032-01-18 09:00:01.995"));
} catch (ParseException e) {
throw new RuntimeException(e);
}
data.setDoubleData(0.56);
list.add(data);
}
return list;
}
private List<DemoData> data2() {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
List<DemoData> list = new ArrayList<DemoData>();
for (int i = 0; i < 10; i++) {
DemoData data = new DemoData();
data.setString("字符串" + i);
try {
data.setDate(format.parse("2032-01-18 09:00:00."));
} catch (ParseException e) {
throw new RuntimeException(e);
}
data.setDoubleData(0.56);
list.add(data);
}
return list;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/WriteV34Test.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/WriteV34Test.java | package com.alibaba.easyexcel.test.temp;
import java.util.ArrayList;
import java.util.List;
import com.alibaba.easyexcel.test.demo.write.DemoData;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.write.metadata.style.WriteCellStyle;
import com.alibaba.excel.write.metadata.style.WriteFont;
import com.alibaba.excel.write.style.HorizontalCellStyleStrategy;
import org.apache.poi.ss.usermodel.FillPatternType;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 临时测试
*
* @author Jiaju Zhuang
**/
public class WriteV34Test {
private static final Logger LOGGER = LoggerFactory.getLogger(WriteV34Test.class);
@Test
public void test() throws Exception {
String fileName = TestFileUtil.getPath() + "handlerStyleWrite" + System.currentTimeMillis() + ".xlsx";
// 头的策略
WriteCellStyle headWriteCellStyle = new WriteCellStyle();
// 背景设置为红色
headWriteCellStyle.setFillForegroundColor(IndexedColors.RED.getIndex());
WriteFont headWriteFont = new WriteFont();
headWriteFont.setFontHeightInPoints((short)20);
headWriteCellStyle.setWriteFont(headWriteFont);
// 内容的策略
WriteCellStyle contentWriteCellStyle = new WriteCellStyle();
// 这里需要指定 FillPatternType 为FillPatternType.SOLID_FOREGROUND 不然无法显示背景颜色.头默认了 FillPatternType所以可以不指定
contentWriteCellStyle.setFillPatternType(FillPatternType.SOLID_FOREGROUND);
// 背景绿色
contentWriteCellStyle.setFillForegroundColor(IndexedColors.GREEN.getIndex());
WriteFont contentWriteFont = new WriteFont();
// 字体大小
contentWriteFont.setFontHeightInPoints((short)20);
contentWriteCellStyle.setWriteFont(contentWriteFont);
// 这个策略是 头是头的样式 内容是内容的样式 其他的策略可以自己实现
HorizontalCellStyleStrategy horizontalCellStyleStrategy =
new HorizontalCellStyleStrategy(headWriteCellStyle, contentWriteCellStyle);
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
EasyExcel.write(fileName, DemoData.class).head(head()).registerWriteHandler(horizontalCellStyleStrategy).sheet(
"模板")
.doWrite(data(1));
}
private List<List<String>> head() {
List<List<String>> list = new ArrayList<List<String>>();
List<String> head0 = new ArrayList<String>();
head0.add("字符串" + System.currentTimeMillis());
head0.add("再找找");
List<String> head1 = new ArrayList<String>();
head1.add("数字" + System.currentTimeMillis());
List<String> head2 = new ArrayList<String>();
head2.add("日期" + System.currentTimeMillis());
List<String> head3 = new ArrayList<String>();
head3.add("日期" + System.currentTimeMillis());
list.add(head0);
list.add(head1);
list.add(head2);
list.add(head3);
return list;
}
private List<DemoData> data(int no) {
List<DemoData> list = new ArrayList<DemoData>();
for (int i = 0; i < 10; i++) {
DemoData data = new DemoData();
data.setString("字符串" + no + "---" + i);
list.add(data);
}
return list;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/LockData.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/LockData.java | package com.alibaba.easyexcel.test.temp;
import com.alibaba.excel.annotation.format.NumberFormat;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* 基础数据类.这里的排序和excel里面的排序一致
*
* @author Jiaju Zhuang
**/
@Getter
@Setter
@EqualsAndHashCode
public class LockData {
@NumberFormat("#.##%")
private Double string0;
private String string1;
private String string2;
private String string3;
private String string4;
private String string5;
private String string6;
private String string7;
private String string8;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/DemoData2.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/DemoData2.java | package com.alibaba.easyexcel.test.temp;
import java.math.BigDecimal;
import java.util.Date;
import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* 基础数据类
*
* @author Jiaju Zhuang
**/
@Getter
@Setter
@EqualsAndHashCode
public class DemoData2 {
@ExcelProperty("字符串标题")
private String string;
@ExcelProperty("日期标题")
private Date date;
@ExcelProperty("数字标题")
private Double doubleData;
@ExcelProperty("数字标题2")
private BigDecimal bigDecimal;
/**
* 忽略这个字段
*/
@ExcelIgnore
private String ignore;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/Xls03Test.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/Xls03Test.java | package com.alibaba.easyexcel.test.temp;
import java.util.List;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.support.cglib.beans.BeanMap;
import com.alibaba.excel.support.cglib.core.DebuggingClassWriter;
import com.alibaba.excel.util.BeanMapUtils;
import com.alibaba.fastjson2.JSON;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 临时测试
*
* @author Jiaju Zhuang
**/
public class Xls03Test {
private static final Logger LOGGER = LoggerFactory.getLogger(Xls03Test.class);
@Test
public void test() {
List<Object> list = EasyExcel.read("D:\\test\\8.xls").sheet().doReadSync();
for (Object data : list) {
LOGGER.info("返回数据：{}", JSON.toJSONString(data));
}
}
@Test
public void test2() {
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,
"/Users/zhuangjiaju/IdeaProjects/easyexcel/target");
CamlData camlData = new CamlData();
//camlData.setTest("test2");
//camlData.setAEst("test3");
//camlData.setTEST("test4");
BeanMap beanMap = BeanMapUtils.create(camlData);
LOGGER.info("test:{}", beanMap.get("test"));
LOGGER.info("test:{}", beanMap.get("Test"));
LOGGER.info("test:{}", beanMap.get("TEst"));
LOGGER.info("test:{}", beanMap.get("TEST"));
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/FillTempTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/FillTempTest.java | package com.alibaba.easyexcel.test.temp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.alibaba.easyexcel.test.demo.fill.FillData;
import com.alibaba.easyexcel.test.temp.fill.FillData2;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.merge.OnceAbsoluteMergeStrategy;
import com.alibaba.excel.write.metadata.WriteSheet;
import org.junit.jupiter.api.Test;
/**
* 写的填充写法
*
* @author Jiaju Zhuang
* @since 2.1.1
*/
public class FillTempTest {
/**
* 复杂的填充
*
* @since 2.1.1
*/
@Test
public void complexFill() {
// 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"\{","\}"代替
// {} 代表普通变量 {.} 代表是list的变量
OnceAbsoluteMergeStrategy onceAbsoluteMergeStrategy = new OnceAbsoluteMergeStrategy(2, 2, 0, 1);
String fileName = TestFileUtil.getPath() + "complexFill" + System.currentTimeMillis() + ".xlsx";
ExcelWriter excelWriter = EasyExcel.write(fileName).registerWriteHandler(onceAbsoluteMergeStrategy)
.withTemplate(TestFileUtil.readUserHomeFile("test/simple.xlsx")).build();
WriteSheet writeSheet0 = EasyExcel.writerSheet(0).build();
WriteSheet writeSheet1 = EasyExcel.writerSheet(1).build();
excelWriter.fill(teamp(), writeSheet0);
excelWriter.fill(teamp(), writeSheet1);
Map<String, Object> map = new HashMap<String, Object>();
map.put("date", "2019年10月9日13:28:28");
map.put("total", 1000);
excelWriter.fill(map, writeSheet0);
excelWriter.finish();
}
/**
* 数据量大的复杂填充
* <p>
* 这里的解决方案是 确保模板list为最后一行，然后再拼接table.还有03版没救，只能刚正面加内存。
*
* @since 2.1.1
*/
@Test
public void complexFillWithTable() {
// 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"\{","\}"代替
// {} 代表普通变量 {.} 代表是list的变量
// 这里模板 删除了list以后的数据，也就是统计的这一行
String templateFileName = "D:\\test\\complex.xlsx";
String fileName = TestFileUtil.getPath() + "complexFillWithTable" + System.currentTimeMillis() + ".xlsx";
ExcelWriter excelWriter = EasyExcel.write(fileName).withTemplate(templateFileName).build();
WriteSheet writeSheet = EasyExcel.writerSheet().build();
// 直接写入数据
excelWriter.fill(data(), writeSheet);
excelWriter.fill(data2(), writeSheet);
// 写入list之前的数据
Map<String, Object> map = new HashMap<String, Object>();
map.put("date", "2019年10月9日13:28:28");
excelWriter.fill(map, writeSheet);
// list 后面还有个统计 想办法手动写入
// 这里偷懒直接用list 也可以用对象
List<List<String>> totalListList = new ArrayList<List<String>>();
List<String> totalList = new ArrayList<String>();
totalListList.add(totalList);
totalList.add(null);
totalList.add(null);
totalList.add(null);
// 第四列
totalList.add("统计:1000");
// 这里是write 别和fill 搞错了
excelWriter.write(totalListList, writeSheet);
excelWriter.finish();
// 总体上写法比较复杂 但是也没有想到好的版本 异步的去写入excel 不支持行的删除和移动，也不支持备注这种的写入，所以也排除了可以
// 新建一个 然后一点点复制过来的方案，最后导致list需要新增行的时候，后面的列的数据没法后移，后续会继续想想解决方案
}
private List<FillData2> data2() {
List<FillData2> list = new ArrayList<FillData2>();
for (int i = 0; i < 10; i++) {
FillData2 fillData = new FillData2();
list.add(fillData);
fillData.setTest("ttttttt" + i);
}
return list;
}
private List<TempFillData> teamp() {
List<TempFillData> list = new ArrayList<TempFillData>();
for (int i = 0; i < 10; i++) {
TempFillData fillData = new TempFillData();
list.add(fillData);
fillData.setName("张三");
fillData.setNumber(5.2);
}
return list;
}
private List<FillData> data() {
List<FillData> list = new ArrayList<FillData>();
for (int i = 0; i < 10; i++) {
FillData fillData = new FillData();
list.add(fillData);
fillData.setName("张三");
fillData.setNumber(5.2);
}
return list;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/CamlData.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/CamlData.java | package com.alibaba.easyexcel.test.temp;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* TODO
*
* @author 是仪
*/
@Getter
@Setter
@EqualsAndHashCode
public class CamlData {
private String string1;
private String String2;
private String sTring3;
private String STring4;
private String STRING5;
private String STRing6;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/LockTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/LockTest.java | package com.alibaba.easyexcel.test.temp;
import java.io.FileInputStream;
import java.util.List;
import java.util.Map;
import com.alibaba.excel.EasyExcel;
import com.alibaba.fastjson2.JSON;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 临时测试
*
* @author Jiaju Zhuang
**/
public class LockTest {
private static final Logger LOGGER = LoggerFactory.getLogger(LockTest.class);
@Test
public void test() throws Exception {
List<Object> list =
EasyExcel.read(new FileInputStream("/Users/zhuangjiaju/Downloads/-0304.2.xlsx")).useDefaultListener(false)
.doReadAllSync();
for (Object data : list) {
LOGGER.info("返回数据：{}", JSON.toJSONString(data));
}
}
@Test
public void test2() throws Exception {
List<Object> list =
EasyExcel.read(new FileInputStream("D:\\test\\开发部.xls")).sheet().headRowNumber(0).doReadSync();
for (Object data : list) {
LOGGER.info("返回数据：{}", ((Map)data).size());
LOGGER.info("返回数据：{}", JSON.toJSONString(data));
}
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue1663/FillData.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue1663/FillData.java | package com.alibaba.easyexcel.test.temp.issue1663;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode
public class FillData {
private String name;
private double number;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue1663/FillTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue1663/FillTest.java | package com.alibaba.easyexcel.test.temp.issue1663;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.alibaba.easyexcel.test.demo.fill.FillData;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.enums.WriteDirectionEnum;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.excel.write.metadata.fill.FillConfig;
import com.alibaba.excel.write.metadata.fill.FillWrapper;
import org.junit.jupiter.api.Test;
public class FillTest {
@Test
public void TestFillNullPoint() {
String templateFileName =
TestFileUtil.getPath() + "temp/issue1663" + File.separator + "template.xlsx";
String fileName = TestFileUtil.getPath() + "temp/issue1663" + File.separator + "issue1663.xlsx";
ExcelWriter excelWriter = EasyExcel.write(fileName).withTemplate(templateFileName).build();
WriteSheet writeSheet = EasyExcel.writerSheet().build();
FillConfig fillConfig = FillConfig.builder().direction(WriteDirectionEnum.VERTICAL).build();
excelWriter.fill(new FillWrapper("data1", data()), fillConfig, writeSheet);
Map<String, Object> map = new HashMap<String, Object>();
// Variable {date} does not exist in the template.xlsx, which should be ignored instead of reporting an error.
map.put("date", "2019年10月9日13:28:28");
excelWriter.fill(map, writeSheet);
excelWriter.finish();
}
private List<com.alibaba.easyexcel.test.demo.fill.FillData> data() {
List<com.alibaba.easyexcel.test.demo.fill.FillData> list
= new ArrayList<com.alibaba.easyexcel.test.demo.fill.FillData>();
for (int i = 0; i < 10; i++) {
com.alibaba.easyexcel.test.demo.fill.FillData fillData = new FillData();
list.add(fillData);
fillData.setName("张三");
fillData.setNumber(5.2);
}
return list;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/cache/CacheTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/cache/CacheTest.java | package com.alibaba.easyexcel.test.temp.cache;
import java.io.File;
import java.util.HashMap;
import java.util.UUID;
import com.alibaba.easyexcel.test.temp.poi.Poi2Test;
import com.alibaba.excel.util.FileUtils;
import com.alibaba.fastjson2.JSON;
import org.ehcache.Cache;
import org.ehcache.PersistentCacheManager;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.CacheManagerBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;
import org.ehcache.config.units.MemoryUnit;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Jiaju Zhuang
**/
public class CacheTest {
private static final Logger LOGGER = LoggerFactory.getLogger(Poi2Test.class);
@Test
public void cache() throws Exception {
File readTempFile = FileUtils.createCacheTmpFile();
File cacheFile = new File(readTempFile.getPath(), UUID.randomUUID().toString());
PersistentCacheManager persistentCacheManager =
CacheManagerBuilder.newCacheManagerBuilder().with(CacheManagerBuilder.persistence(cacheFile))
.withCache("cache", CacheConfigurationBuilder.newCacheConfigurationBuilder(Integer.class, HashMap.class,
ResourcePoolsBuilder.newResourcePoolsBuilder().disk(10, MemoryUnit.GB)))
.build(true);
Cache<Integer, HashMap> cache = persistentCacheManager.getCache("cache", Integer.class, HashMap.class);
HashMap<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "test");
cache.put(1, map);
LOGGER.info("dd1:{}", JSON.toJSONString(cache.get(1)));
cache.clear();
LOGGER.info("dd2:{}", JSON.toJSONString(cache.get(1)));
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/bug/ExcelCreat.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/bug/ExcelCreat.java | package com.alibaba.easyexcel.test.temp.bug;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.Collections;
import java.util.List;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
/**
* @author jiaosong
* @desc
* @date 2020/4/6
*/
public class ExcelCreat {
public static void main(String[] args) throws FileNotFoundException {
List<DataType> data = getData();
ExcelWriter excelWriter = null;
excelWriter = EasyExcel.write(new FileOutputStream("all.xlsx")).build();
WriteSheet writeSheet = EasyExcel.writerSheet(1, "test")
.head(HeadType.class)
.build();
excelWriter.write(data, writeSheet);
excelWriter.finish();
}
private static List<DataType> getData() {
DataType vo = new DataType();
vo.setId(738);
vo.setFirstRemark("1222");
vo.setSecRemark("22222");
return Collections.singletonList(vo);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/bug/HeadType.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/bug/HeadType.java | package com.alibaba.easyexcel.test.temp.bug;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* @author jiaosong
* @desc
* @date 2021/4/6
*/
@Getter
@Setter
@EqualsAndHashCode
public class HeadType {
/**
* 任务id
*/
@ExcelProperty("任务ID")
private Integer id;
@ExcelProperty(value = "备注1")
private String firstRemark;
@ExcelProperty(value = "备注2")
private String secRemark;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/bug/DataType.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/bug/DataType.java | package com.alibaba.easyexcel.test.temp.bug;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* @author jiaosong
* @desc
* @date 2021/4/6
*/
@Getter
@Setter
@EqualsAndHashCode
public class DataType {
/**
* 任务id
*/
@ExcelProperty("任务ID")
private Integer id;
@ExcelProperty("多余字段1")
private String firstSurplus;
@ExcelProperty("多余字段2")
private String secSurplus;
@ExcelProperty("多余字段3")
private String thirdSurplus;
@ExcelProperty(value = "备注1")
private String firstRemark;
@ExcelProperty(value = "备注2")
private String secRemark;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/dataformat/DataFormatTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/dataformat/DataFormatTest.java | 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 java.util.Locale;
import java.util.regex.Pattern;
import com.alibaba.easyexcel.test.core.dataformat.DateFormatData;
import com.alibaba.easyexcel.test.temp.Lock2Test;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.fastjson2.JSON;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
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.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 格式测试
*
* @author Jiaju Zhuang
**/
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) {
Short dataFormat = data.getDate().getDataFormatData().getIndex();
String dataFormatString = data.getDate().getFormulaData().getFormulaValue();
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) {
Short dataFormat = data.getDate().getDataFormatData().getIndex();
String dataFormatString = data.getDate().getFormulaData().getFormulaValue();
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));
}
@Test
public void test355() throws IOException, InvalidFormatException {
File file = TestFileUtil.readFile("dataformat" + File.separator + "dataformat.xlsx");
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(file);
Sheet xssfSheet = xssfWorkbook.getSheetAt(0);
DataFormatter d = new DataFormatter(Locale.CHINA);
for (int i = 0; i < xssfSheet.getLastRowNum(); i++) {
Row row = xssfSheet.getRow(i);
System.out.println(d.formatCellValue(row.getCell(0)));
}
}
@Test
public void test3556() throws IOException, InvalidFormatException {
String file = "D://test/dataformat1.xlsx";
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(file);
Sheet xssfSheet = xssfWorkbook.getSheetAt(0);
DataFormatter d = new DataFormatter(Locale.CHINA);
for (int i = 0; i < xssfSheet.getLastRowNum(); i++) {
Row row = xssfSheet.getRow(i);
System.out.println(d.formatCellValue(row.getCell(0)));
}
}
@Test
public void tests() throws IOException, InvalidFormatException {
SimpleDateFormat s1 = new SimpleDateFormat("yyyy\"5E74\"m\"6708\"d\"65E5\"");
System.out.println(s1.format(new Date()));
s1 = new SimpleDateFormat("yyyy年m月d日");
System.out.println(s1.format(new Date()));
}
@Test
public void tests1() throws IOException, InvalidFormatException {
String file = "D://test/dataformat1.xlsx";
List<DateFormatData> list = EasyExcel.read(file, DateFormatData.class, null).sheet().doReadSync();
for (DateFormatData data : list) {
LOGGER.info("返回:{}", JSON.toJSONString(data));
}
}
@Test
public void tests3() throws IOException, InvalidFormatException {
SimpleDateFormat s1 = new SimpleDateFormat("ah\"时\"mm\"分\"");
System.out.println(s1.format(new Date()));
}
private static final Pattern date_ptrn6 = Pattern.compile("^.*(年|月|日|时|分|秒)+.*$");
@Test
public void tests34() throws IOException, InvalidFormatException {
System.out.println(date_ptrn6.matcher("2017但是").matches());
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/dataformat/DataFormatData.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/dataformat/DataFormatData.java | package com.alibaba.easyexcel.test.temp.dataformat;
import com.alibaba.excel.metadata.data.ReadCellData;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* TODO
*
* @author 罗成
**/
@Getter
@Setter
@EqualsAndHashCode
public class DataFormatData {
private ReadCellData<String> date;
private ReadCellData<String> num;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/dataformat/DataFormatter1.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/dataformat/DataFormatter1.java | /*
* ==================================================================== Licensed to the Apache Software Foundation (ASF)
* under one or more contributor license agreements. See the NOTICE file distributed with this work for additional
* information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the
* License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*
* 2012 - Alfresco Software, Ltd. Alfresco Software has modified source of this file The details of changes as svn diff
* can be found in svn at location root/projects/3rd-party/src
* ====================================================================
*/
package com.alibaba.easyexcel.test.temp.dataformat;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DateFormat;
import java.text.DateFormatSymbols;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.FieldPosition;
import java.text.Format;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Observable;
import java.util.Observer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.alibaba.excel.analysis.ExcelAnalyserImpl;
import org.apache.poi.ss.format.CellFormat;
import org.apache.poi.ss.format.CellFormatResult;
import org.apache.poi.ss.formula.ConditionalFormattingEvaluator;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.ExcelGeneralNumberFormat;
import org.apache.poi.ss.usermodel.ExcelNumberFormat;
import org.apache.poi.ss.usermodel.ExcelStyleDateFormatter;
import org.apache.poi.ss.usermodel.FormulaError;
import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.FractionFormat;
import org.apache.poi.ss.util.DateFormatConverter;
import org.apache.poi.ss.util.NumberToTextConverter;
import org.apache.poi.util.LocaleUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* DataFormatter contains methods for formatting the value stored in an Cell. This can be useful for reports and GUI
* presentations when you need to display data exactly as it appears in Excel. Supported formats include currency, SSN,
* percentages, decimals, dates, phone numbers, zip codes, etc.
* <p>
* Internally, formats will be implemented using subclasses of {@link Format} such as {@link DecimalFormat} and
* {@link java.text.SimpleDateFormat}. Therefore the formats used by this class must obey the same pattern rules as
* these Format subclasses. This means that only legal number pattern characters ("0", "#", ".", "," etc.) may appear in
* number formats. Other characters can be inserted <em>before</em> or <em> after</em> the number pattern to form a
* prefix or suffix.
* </p>
* <p>
* For example the Excel pattern <code>"$#,##0.00 "USD"_);($#,##0.00 "USD")"
* </code> will be correctly formatted as "$1,000.00 USD" or "($1,000.00 USD)". However the pattern
* <code>"00-00-00"</code> is incorrectly formatted by DecimalFormat as "000000--". For Excel formats that are not
* compatible with DecimalFormat, you can provide your own custom {@link Format} implementation via
* <code>DataFormatter.addFormat(String,Format)</code>. The following custom formats are already provided by this class:
* </p>
*
* <pre>
* <ul><li>SSN "000-00-0000"</li>
* <li>Phone Number "(###) ###-####"</li>
* <li>Zip plus 4 "00000-0000"</li>
* </ul>
* </pre>
* <p>
* If the Excel format pattern cannot be parsed successfully, then a default format will be used. The default number
* format will mimic the Excel General format: "#" for whole numbers and "#.##########" for decimal numbers. You can
* override the default format pattern with <code>
* DataFormatter.setDefaultNumberFormat(Format)</code>. <b>Note:</b> the default format will only be used when a Format
* cannot be created from the cell's data format string.
*
* <p>
* Note that by default formatted numeric values are trimmed. Excel formats can contain spacers and padding and the
* default behavior is to strip them off.
* </p>
* <p>
* Example:
* </p>
* <p>
* Consider a numeric cell with a value <code>12.343</code> and format <code>"##.##_ "</code>. The trailing underscore
* and space ("_ ") in the format adds a space to the end and Excel formats this cell as <code>"12.34 "</code>, but
* <code>DataFormatter</code> trims the formatted value and returns <code>"12.34"</code>.
* </p>
* You can enable spaces by passing the <code>emulateCSV=true</code> flag in the <code>DateFormatter</code> cosntructor.
* If set to true, then the output tries to conform to what you get when you take an xls or xlsx in Excel and Save As
* CSV file:
* <ul>
* <li>returned values are not trimmed</li>
* <li>Invalid dates are formatted as 255 pound signs ("#")</li>
* <li>simulate Excel's handling of a format string of all # when the value is 0. Excel will output "",
* <code>DataFormatter</code> will output "0".
* </ul>
* <p>
* Some formats are automatically "localized" by Excel, eg show as mm/dd/yyyy when loaded in Excel in some Locales but
* as dd/mm/yyyy in others. These are always returned in the "default" (US) format, as stored in the file. Some format
* strings request an alternate locale, eg <code>[$-809]d/m/yy h:mm AM/PM</code> which explicitly requests UK locale.
* These locale directives are (currently) ignored. You can use {@link DateFormatConverter} to do some of this
* localisation if you need it.
*/
public class DataFormatter1 implements Observer {
private static final String defaultFractionWholePartFormat = "#";
private static final String defaultFractionFractionPartFormat = "#/##";
/**
* Pattern to find a number format: "0" or "#"
*/
private static final Pattern numPattern = Pattern.compile("[0#]+");
/**
* Pattern to find days of week as text "ddd...."
*/
private static final Pattern daysAsText = Pattern.compile("([d]{3,})", Pattern.CASE_INSENSITIVE);
/**
* Pattern to find "AM/PM" marker
*/
private static final Pattern amPmPattern = Pattern.compile("((A|P)[M/P]*)", Pattern.CASE_INSENSITIVE);
/**
* Pattern to find formats with condition ranges e.g. [>=100]
*/
private static final Pattern rangeConditionalPattern =
Pattern.compile(".*\\[\\s*(>|>=|<|<=|=)\\s*[0-9]*\\.*[0-9].*");
/**
* A regex to find locale patterns like [$$-1009] and [$?-452]. Note that we don't currently process these into
* locales
*/
private static final Pattern localePatternGroup = Pattern.compile("(\\[\\$[^-\\]]*-[0-9A-Z]+\\])");
/**
* A regex to match the colour formattings rules. Allowed colours are: Black, Blue, Cyan, Green, Magenta, Red,
* White, Yellow, "Color n" (1<=n<=56)
*/
private static final Pattern colorPattern = Pattern.compile("(\\[BLACK\\])|(\\[BLUE\\])|(\\[CYAN\\])|(\\[GREEN\\])|"
+ "(\\[MAGENTA\\])|(\\[RED\\])|(\\[WHITE\\])|(\\[YELLOW\\])|"
+ "(\\[COLOR\\s*\\d\\])|(\\[COLOR\\s*[0-5]\\d\\])", Pattern.CASE_INSENSITIVE);
/**
* A regex to identify a fraction pattern. This requires that replaceAll("\\?", "#") has already been called
*/
private static final Pattern fractionPattern = Pattern.compile("(?:([#\\d]+)\\s+)?(#+)\\s*\\/\\s*([#\\d]+)");
/**
* A regex to strip junk out of fraction formats
*/
private static final Pattern fractionStripper = Pattern.compile("(\"[^\"]*\")|([^ \\?#\\d\\/]+)");
/**
* A regex to detect if an alternate grouping character is used in a numeric format
*/
private static final Pattern alternateGrouping = Pattern.compile("([#0]([^.#0])[#0]{3})");
/**
* Cells formatted with a date or time format and which contain invalid date or time values show 255 pound signs
* ("#").
*/
private static final String invalidDateTimeString;
static {
StringBuilder buf = new StringBuilder();
for (int i = 0; i < 255; i++) {buf.append('#');}
invalidDateTimeString = buf.toString();
}
/**
* The decimal symbols of the locale used for formatting values.
*/
private DecimalFormatSymbols decimalSymbols;
/**
* The date symbols of the locale used for formatting values.
*/
private DateFormatSymbols dateSymbols;
/**
* A default date format, if no date format was given
*/
private DateFormat defaultDateformat;
/**
* <em>General</em> format for numbers.
*/
private Format generalNumberFormat;
/**
* A default format to use when a number pattern cannot be parsed.
*/
private Format defaultNumFormat;
/**
* A map to cache formats. Map<String,Format> formats
*/
private final Map<String, Format> formats = new HashMap<String, Format>();
private final boolean emulateCSV;
/**
* stores the locale valid it the last formatting call
*/
private Locale locale;
/**
* stores if the locale should change according to {@link LocaleUtil#getUserLocale()}
*/
private boolean localeIsAdapting;
private class LocaleChangeObservable extends Observable {
void checkForLocaleChange() {
checkForLocaleChange(LocaleUtil.getUserLocale());
}
void checkForLocaleChange(Locale newLocale) {
if (!localeIsAdapting) {return;}
if (newLocale.equals(locale)) {return;}
super.setChanged();
notifyObservers(newLocale);
}
}
/**
* the Observable to notify, when the locale has been changed
*/
private final LocaleChangeObservable localeChangedObservable = new LocaleChangeObservable();
/**
* For logging any problems we find
*/
private static final Logger logger = LoggerFactory.getLogger(ExcelAnalyserImpl.class);
/**
* Creates a formatter using the {@link Locale#getDefault() default locale}.
*/
public DataFormatter1() {
this(false);
}
/**
* Creates a formatter using the {@link Locale#getDefault() default locale}.
*
* @param emulateCSV whether to emulate CSV output.
*/
public DataFormatter1(boolean emulateCSV) {
this(LocaleUtil.getUserLocale(), true, emulateCSV);
}
/**
* Creates a formatter using the given locale.
*/
public DataFormatter1(Locale locale) {
this(locale, false);
}
/**
* Creates a formatter using the given locale.
*
* @param emulateCSV whether to emulate CSV output.
*/
public DataFormatter1(Locale locale, boolean emulateCSV) {
this(locale, false, emulateCSV);
}
/**
* Creates a formatter using the given locale.
*
* @param localeIsAdapting (true only if locale is not user-specified)
* @param emulateCSV whether to emulate CSV output.
*/
private DataFormatter1(Locale locale, boolean localeIsAdapting, boolean emulateCSV) {
this.localeIsAdapting = true;
localeChangedObservable.addObserver(this);
// localeIsAdapting must be true prior to this first checkForLocaleChange call.
localeChangedObservable.checkForLocaleChange(locale);
// set localeIsAdapting so subsequent checks perform correctly
// (whether a specific locale was provided to this DataFormatter or DataFormatter should
// adapt to the current user locale as the locale changes)
this.localeIsAdapting = localeIsAdapting;
this.emulateCSV = emulateCSV;
}
/**
* 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);
}
private Format getFormat(double cellValue, int formatIndex, String formatStrIn) {
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);
}
// Wrap and return (non-cachable - CellFormat does that)
return new CellFormatResultWrapper(cfmt.apply(cellValueO));
} catch (Exception e) {
logger.warn("Formatting failed for format {}, falling back", formatStr, 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;
}
/**
* Create and return a Format based on the format string from a cell's style. If the pattern cannot be parsed,
* return a default pattern.
*
* @param cell The Excel cell
* @return A Format representing the excel format. May return null.
*/
public Format createFormat(Cell cell) {
int formatIndex = cell.getCellStyle().getDataFormat();
String formatStr = cell.getCellStyle().getDataFormatString();
return createFormat(cell.getNumericCellValue(), formatIndex, formatStr);
}
private Format createFormat(double cellValue, int formatIndex, String sFormat) {
localeChangedObservable.checkForLocaleChange();
String formatStr = sFormat;
// Remove colour formatting if present
Matcher colourM = colorPattern.matcher(formatStr);
while (colourM.find()) {
String colour = colourM.group();
// Paranoid replacement...
int at = formatStr.indexOf(colour);
if (at == -1) {break;}
String nFormatStr = formatStr.substring(0, at) + formatStr.substring(at + colour.length());
if (nFormatStr.equals(formatStr)) {break;}
// Try again in case there's multiple
formatStr = nFormatStr;
colourM = colorPattern.matcher(formatStr);
}
// Strip off the locale information, we use an instance-wide locale for everything
Matcher m = localePatternGroup.matcher(formatStr);
while (m.find()) {
String match = m.group();
String symbol = match.substring(match.indexOf('$') + 1, match.indexOf('-'));
if (symbol.indexOf('$') > -1) {
symbol = symbol.substring(0, symbol.indexOf('$')) + '\\'
+ symbol.substring(symbol.indexOf('$'), symbol.length());
}
formatStr = m.replaceAll(symbol);
m = localePatternGroup.matcher(formatStr);
}
// Check for special cases
if (formatStr == null || formatStr.trim().length() == 0) {
return getDefaultFormat(cellValue);
}
if ("General".equalsIgnoreCase(formatStr) || "@".equals(formatStr)) {
return generalNumberFormat;
}
if ("".equals("") || (DateUtil.isADateFormat(formatIndex, formatStr) && DateUtil.isValidExcelDate(cellValue))) {
return createDateFormat(formatStr, cellValue);
}
// Excel supports fractions in format strings, which Java doesn't
if (formatStr.contains("#/") || formatStr.contains("?/")) {
String[] chunks = formatStr.split(";");
for (String chunk1 : chunks) {
String chunk = chunk1.replaceAll("\\?", "#");
Matcher matcher = fractionStripper.matcher(chunk);
chunk = matcher.replaceAll(" ");
chunk = chunk.replaceAll(" +", " ");
Matcher fractionMatcher = fractionPattern.matcher(chunk);
// take the first match
if (fractionMatcher.find()) {
String wholePart = (fractionMatcher.group(1) == null) ? "" : defaultFractionWholePartFormat;
return new FractionFormat(wholePart, fractionMatcher.group(3));
}
}
// Strip custom text in quotes and escaped characters for now as it can cause performance problems in
// fractions.
// String strippedFormatStr = formatStr.replaceAll("\\\\ ", " ").replaceAll("\\\\.",
// "").replaceAll("\"[^\"]*\"", " ").replaceAll("\\?", "#");
// System.out.println("formatStr: "+strippedFormatStr);
return new FractionFormat(defaultFractionWholePartFormat, defaultFractionFractionPartFormat);
}
if (numPattern.matcher(formatStr).find()) {
return createNumberFormat(formatStr, cellValue);
}
if (emulateCSV) {
return new ConstantStringFormat(cleanFormatForNumber(formatStr));
}
// TODO - when does this occur?
return null;
}
private Format createDateFormat(String pFormatStr, double cellValue) {
String formatStr = pFormatStr;
formatStr = formatStr.replaceAll("\\\\-", "-");
formatStr = formatStr.replaceAll("\\\\,", ",");
formatStr = formatStr.replaceAll("\\\\\\.", "."); // . is a special regexp char
formatStr = formatStr.replaceAll("\\\\ ", " ");
formatStr = formatStr.replaceAll("\\\\/", "/"); // weird: m\\/d\\/yyyy
formatStr = formatStr.replaceAll(";@", "");
formatStr = formatStr.replaceAll("\"/\"", "/"); // "/" is escaped for no reason in: mm"/"dd"/"yyyy
formatStr = formatStr.replace("\"\"", "'"); // replace Excel quoting with Java style quoting
formatStr = formatStr.replaceAll("\\\\T", "'T'"); // Quote the T is iso8601 style dates
boolean hasAmPm = false;
Matcher amPmMatcher = amPmPattern.matcher(formatStr);
while (amPmMatcher.find()) {
formatStr = amPmMatcher.replaceAll("@");
hasAmPm = true;
amPmMatcher = amPmPattern.matcher(formatStr);
}
formatStr = formatStr.replaceAll("@", "a");
Matcher dateMatcher = daysAsText.matcher(formatStr);
if (dateMatcher.find()) {
String match = dateMatcher.group(0).toUpperCase(Locale.ROOT).replaceAll("D", "E");
formatStr = dateMatcher.replaceAll(match);
}
// Convert excel date format to SimpleDateFormat.
// Excel uses lower and upper case 'm' for both minutes and months.
// From Excel help:
/*
The "m" or "mm" code must appear immediately after the "h" or"hh"
code or immediately before the "ss" code; otherwise, Microsoft
Excel displays the month instead of minutes."
*/
StringBuilder sb = new StringBuilder();
char[] chars = formatStr.toCharArray();
boolean mIsMonth = true;
List<Integer> ms = new ArrayList<Integer>();
boolean isElapsed = false;
for (int j = 0; j < chars.length; j++) {
char c = chars[j];
if (c == '\'') {
sb.append(c);
j++;
// skip until the next quote
while (j < chars.length) {
c = chars[j];
sb.append(c);
if (c == '\'') {
break;
}
j++;
}
} else if (c == '[' && !isElapsed) {
isElapsed = true;
mIsMonth = false;
sb.append(c);
} else if (c == ']' && isElapsed) {
isElapsed = false;
sb.append(c);
} else if (isElapsed) {
if (c == 'h' || c == 'H') {
sb.append('H');
} else if (c == 'm' || c == 'M') {
sb.append('m');
} else if (c == 's' || c == 'S') {
sb.append('s');
} else {
sb.append(c);
}
} else if (c == 'h' || c == 'H') {
mIsMonth = false;
if (hasAmPm) {
sb.append('h');
} else {
sb.append('H');
}
} else if (c == 'm' || c == 'M') {
if (mIsMonth) {
sb.append('M');
ms.add(Integer.valueOf(sb.length() - 1));
} else {
sb.append('m');
}
} else if (c == 's' || c == 'S') {
sb.append('s');
// if 'M' precedes 's' it should be minutes ('m')
for (int index : ms) {
if (sb.charAt(index) == 'M') {
sb.replace(index, index + 1, "m");
}
}
mIsMonth = true;
ms.clear();
} else if (Character.isLetter(c)) {
mIsMonth = true;
ms.clear();
if (c == 'y' || c == 'Y') {
sb.append('y');
} else if (c == 'd' || c == 'D') {
sb.append('d');
} else {
sb.append(c);
}
} else {
if (Character.isWhitespace(c)) {
ms.clear();
}
sb.append(c);
}
}
formatStr = sb.toString();
try {
return new ExcelStyleDateFormatter(formatStr, dateSymbols);
} catch (IllegalArgumentException iae) {
logger.debug("Formatting failed for format {}, falling back", formatStr, iae);
// the pattern could not be parsed correctly,
// so fall back to the default number format
return getDefaultFormat(cellValue);
}
}
private String cleanFormatForNumber(String formatStr) {
StringBuilder sb = new StringBuilder(formatStr);
if (emulateCSV) {
// Requested spacers with "_" are replaced by a single space.
// Full-column-width padding "*" are removed.
// Not processing fractions at this time. Replace ? with space.
// This matches CSV output.
for (int i = 0; i < sb.length(); i++) {
char c = sb.charAt(i);
if (c == '_' || c == '*' || c == '?') {
if (i > 0 && sb.charAt((i - 1)) == '\\') {
// It's escaped, don't worry
continue;
}
if (c == '?') {
sb.setCharAt(i, ' ');
} else if (i < sb.length() - 1) {
// Remove the character we're supposed
// to match the space of / pad to the
// column width with
if (c == '_') {
sb.setCharAt(i + 1, ' ');
} else {
sb.deleteCharAt(i + 1);
}
// Remove the character too
sb.deleteCharAt(i);
i--;
}
}
}
} else {
// If they requested spacers, with "_",
// remove those as we don't do spacing
// If they requested full-column-width
// padding, with "*", remove those too
for (int i = 0; i < sb.length(); i++) {
char c = sb.charAt(i);
if (c == '_' || c == '*') {
if (i > 0 && sb.charAt((i - 1)) == '\\') {
// It's escaped, don't worry
continue;
}
if (i < sb.length() - 1) {
// Remove the character we're supposed
// to match the space of / pad to the
// column width with
sb.deleteCharAt(i + 1);
}
// Remove the _ too
sb.deleteCharAt(i);
i--;
}
}
}
// Now, handle the other aspects like
// quoting and scientific notation
for (int i = 0; i < sb.length(); i++) {
char c = sb.charAt(i);
// remove quotes and back slashes
if (c == '\\' || c == '"') {
sb.deleteCharAt(i);
i--;
// for scientific/engineering notation
} else if (c == '+' && i > 0 && sb.charAt(i - 1) == 'E') {
sb.deleteCharAt(i);
i--;
}
}
return sb.toString();
}
private static class InternalDecimalFormatWithScale extends Format {
private static final Pattern endsWithCommas = Pattern.compile("(,+)$");
private BigDecimal divider;
private static final BigDecimal ONE_THOUSAND = new BigDecimal(1000);
private final DecimalFormat df;
private static final String trimTrailingCommas(String s) {
return s.replaceAll(",+$", "");
}
public InternalDecimalFormatWithScale(String pattern, DecimalFormatSymbols symbols) {
df = new DecimalFormat(trimTrailingCommas(pattern), symbols);
setExcelStyleRoundingMode(df);
Matcher endsWithCommasMatcher = endsWithCommas.matcher(pattern);
if (endsWithCommasMatcher.find()) {
String commas = (endsWithCommasMatcher.group(1));
BigDecimal temp = BigDecimal.ONE;
for (int i = 0; i < commas.length(); ++i) {
temp = temp.multiply(ONE_THOUSAND);
}
divider = temp;
} else {
divider = null;
}
}
private Object scaleInput(Object obj) {
if (divider != null) {
if (obj instanceof BigDecimal) {
obj = ((BigDecimal)obj).divide(divider, RoundingMode.HALF_UP);
} else if (obj instanceof Double) {
obj = (Double)obj / divider.doubleValue();
} else {
throw new UnsupportedOperationException();
}
}
return obj;
}
@Override
public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
obj = scaleInput(obj);
return df.format(obj, toAppendTo, pos);
}
@Override
public Object parseObject(String source, ParsePosition pos) {
throw new UnsupportedOperationException();
}
}
private Format createNumberFormat(String formatStr, double cellValue) {
String format = cleanFormatForNumber(formatStr);
DecimalFormatSymbols symbols = decimalSymbols;
// Do we need to change the grouping character?
// eg for a format like #'##0 which wants 12'345 not 12,345
Matcher agm = alternateGrouping.matcher(format);
if (agm.find()) {
char grouping = agm.group(2).charAt(0);
// Only replace the grouping character if it is not the default
// grouping character for the US locale (',') in order to enable
// correct grouping for non-US locales.
if (grouping != ',') {
symbols = DecimalFormatSymbols.getInstance(locale);
symbols.setGroupingSeparator(grouping);
String oldPart = agm.group(1);
String newPart = oldPart.replace(grouping, ',');
format = format.replace(oldPart, newPart);
}
}
try {
return new InternalDecimalFormatWithScale(format, symbols);
} catch (IllegalArgumentException iae) {
logger.debug("Formatting failed for format {}, falling back", formatStr, iae);
// the pattern could not be parsed correctly,
// so fall back to the default number format
return getDefaultFormat(cellValue);
}
}
/**
* Returns a default format for a cell.
*
* @param cell The cell
* @return a default format
*/
public Format getDefaultFormat(Cell cell) {
return getDefaultFormat(cell.getNumericCellValue());
}
private Format getDefaultFormat(double cellValue) {
localeChangedObservable.checkForLocaleChange();
// for numeric cells try user supplied default
if (defaultNumFormat != null) {
return defaultNumFormat;
// otherwise use general format
}
return generalNumberFormat;
}
/**
* Performs Excel-style date formatting, using the supplied Date and format
*/
private String performDateFormatting(Date d, Format dateFormat) {
return (dateFormat != null ? dateFormat : defaultDateformat).format(d);
}
/**
* Returns the formatted value of an Excel date as a <tt>String</tt> based on the cell's <code>DataFormat</code>.
* i.e. "Thursday, January 02, 2003" , "01/02/2003" , "02-Jan" , etc.
* <p>
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | true |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/write/TempWriteTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/write/TempWriteTest.java | package com.alibaba.easyexcel.test.temp.write;
import java.io.File;
import java.io.FileOutputStream;
import java.util.HashMap;
import java.util.Map;
import com.alibaba.easyexcel.test.demo.read.CustomStringStringConverter;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.support.cglib.beans.BeanMap;
import com.alibaba.excel.util.BeanMapUtils;
import com.alibaba.excel.util.FileUtils;
import com.alibaba.excel.util.ListUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.ClientAnchor;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.Picture;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.streaming.SXSSFCell;
import org.apache.poi.xssf.streaming.SXSSFDrawing;
import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.jupiter.api.Test;
@Slf4j
public class TempWriteTest {
@Test
public void write() {
TempWriteData tempWriteData = new TempWriteData();
tempWriteData.setName("zs\r\n \\ \r\n t4");
EasyExcel.write(TestFileUtil.getPath() + "TempWriteTest" + System.currentTimeMillis() + ".xlsx",
TempWriteData.class)
.sheet()
.registerConverter(new CustomStringStringConverter())
.doWrite(ListUtils.newArrayList(tempWriteData));
EasyExcel.write(TestFileUtil.getPath() + "TempWriteTest" + System.currentTimeMillis() + ".xlsx",
TempWriteData.class)
.sheet()
.doWrite(ListUtils.newArrayList(tempWriteData));
}
@Test
public void cglib() {
TempWriteData tempWriteData = new TempWriteData();
tempWriteData.setName("1");
tempWriteData.setName1("2");
BeanMap beanMap = BeanMapUtils.create(tempWriteData);
log.info("d1{}", beanMap.get("name"));
log.info("d2{}", beanMap.get("name1"));
TempWriteData tempWriteData2 = new TempWriteData();
Map<String, String> map = new HashMap<>();
map.put("name", "zs");
BeanMap beanMap2 = BeanMapUtils.create(tempWriteData2);
beanMap2.putAll(map);
log.info("3{}", tempWriteData2.getName());
}
@Test
public void imageWrite() throws Exception {
//String fileName = TestFileUtil.getPath() + "imageWrite" + System.currentTimeMillis() + ".xlsx";
//
//// 这里 需要指定写用哪个class去写
//try (ExcelWriter excelWriter = EasyExcel.write(fileName, DemoData.class).build()) {
// // 这里注意 如果同一个sheet只要创建一次
// WriteSheet writeSheet = EasyExcel.writerSheet("模板").build();
// // 去调用写入,这里我调用了五次，实际使用时根据数据库分页的总的页数来
// for (int i = 0; i < 5; i++) {
// // 分页去数据库查询数据 这里可以去数据库查询每一页的数据
// List<DemoData> data = data();
// excelWriter.write(data, writeSheet);
// }
//}
}
@Test
public void imageWritePoi() throws Exception {
String file = "/Users/zhuangjiaju/test/imagetest" + System.currentTimeMillis() + ".xlsx";
SXSSFWorkbook workbook = new SXSSFWorkbook();
SXSSFSheet sheet = workbook.createSheet("测试");
CreationHelper helper = workbook.getCreationHelper();
SXSSFDrawing sxssfDrawin = sheet.createDrawingPatriarch();
byte[] imagebyte = FileUtils.readFileToByteArray(new File("/Users/zhuangjiaju/Documents/demo.jpg"));
for (int i = 0; i < 1 * 10000; i++) {
SXSSFRow row = sheet.createRow(i);
SXSSFCell cell = row.createCell(0);
cell.setCellValue(i);
int pictureIdx = workbook.addPicture(imagebyte, Workbook.PICTURE_TYPE_JPEG);
ClientAnchor anchor = helper.createClientAnchor();
anchor.setCol1(0);
anchor.setRow1(i);
// 插入图片
Picture pict = sxssfDrawin.createPicture(anchor, pictureIdx);
pict.resize();
log.info("新增行:{}", i);
}
FileOutputStream fileOutputStream = new FileOutputStream(file);
workbook.write(fileOutputStream);
fileOutputStream.flush();
workbook.close();
}
@Test
public void tep() throws Exception {
String file = "/Users/zhuangjiaju/test/imagetest" + System.currentTimeMillis() + ".xlsx";
SXSSFWorkbook workbook = new SXSSFWorkbook();
SXSSFSheet sheet = workbook.createSheet("测试");
CreationHelper helper = workbook.getCreationHelper();
SXSSFDrawing sxssfDrawin = sheet.createDrawingPatriarch();
byte[] imagebyte = FileUtils.readFileToByteArray(new File("/Users/zhuangjiaju/Documents/demo.jpg"));
for (int i = 0; i < 1 * 10000; i++) {
SXSSFRow row = sheet.createRow(i);
SXSSFCell cell = row.createCell(0);
cell.setCellValue(i);
int pictureIdx = workbook.addPicture(imagebyte, Workbook.PICTURE_TYPE_JPEG);
ClientAnchor anchor = helper.createClientAnchor();
anchor.setCol1(0);
anchor.setRow1(i);
// 插入图片
Picture pict = sxssfDrawin.createPicture(anchor, pictureIdx);
pict.resize();
log.info("新增行:{}", i);
}
FileOutputStream fileOutputStream = new FileOutputStream(file);
workbook.write(fileOutputStream);
fileOutputStream.flush();
workbook.close();
}
@Test
public void large() throws Exception {
String file = "/Users/zhuangjiaju/test/imagetest" + System.currentTimeMillis() + ".xlsx";
SXSSFWorkbook workbook = new SXSSFWorkbook(new XSSFWorkbook(
new File(
"/Users/zhuangjiaju/IdeaProjects/easyexcel/easyexcel-test/src/test/resources/large/large07.xlsx")));
SXSSFSheet sheet = workbook.createSheet("测试");
SXSSFRow row = sheet.createRow(500000);
SXSSFCell cell = row.createCell(0);
cell.setCellValue("test");
FileOutputStream fileOutputStream = new FileOutputStream(file);
workbook.write(fileOutputStream);
fileOutputStream.flush();
workbook.close();
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/write/TempWriteData.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/write/TempWriteData.java | package com.alibaba.easyexcel.test.temp.write;
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.write.style.ContentStyle;
import com.alibaba.excel.annotation.write.style.HeadStyle;
import com.alibaba.excel.enums.BooleanEnum;
import lombok.Data;
@Data
//@Accessors(chain = true)
public class TempWriteData {
private String name1;
@ExcelProperty(" 换行\r\n \\ \r\n的名字")
@HeadStyle(wrapped = BooleanEnum.TRUE)
@ContentStyle(wrapped = BooleanEnum.TRUE)
private String name;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/Poi2Test.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/Poi2Test.java | package com.alibaba.easyexcel.test.temp.poi;
import java.io.IOException;
import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 测试poi
*
* @author Jiaju Zhuang
**/
public class Poi2Test {
private static final Logger LOGGER = LoggerFactory.getLogger(Poi2Test.class);
@Test
public void test() throws IOException {
String file = "D:\\test\\珠海.xlsx";
SXSSFWorkbook xssfWorkbook = new SXSSFWorkbook(new XSSFWorkbook(file));
SXSSFSheet xssfSheet = xssfWorkbook.getSheetAt(0);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
SXSSFRow row = xssfSheet.getRow(0);
LOGGER.info("第一行数据:{}", row);
}
@Test
public void lastRowNumXSSF() throws IOException {
String file = "D:\\test\\珠海.xlsx";
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(file);
LOGGER.info("一共:{}个sheet", xssfWorkbook.getNumberOfSheets());
XSSFSheet xssfSheet = xssfWorkbook.getSheetAt(0);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
XSSFRow row = xssfSheet.getRow(0);
LOGGER.info("第一行数据:{}", row);
xssfSheet.createRow(20);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/PoiWriteTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/PoiWriteTest.java | package com.alibaba.easyexcel.test.temp.poi;
import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.net.URL;
import java.util.regex.Pattern;
import com.alibaba.fastjson2.JSON;
import org.apache.poi.xssf.streaming.SXSSFCell;
import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 测试poi
*
* @author Jiaju Zhuang
**/
public class PoiWriteTest {
private static final Logger LOGGER = LoggerFactory.getLogger(PoiWriteTest.class);
@Test
public void write0() throws IOException {
FileOutputStream fileOutputStream =
new FileOutputStream("D://test//tt132" + System.currentTimeMillis() + ".xlsx");
SXSSFWorkbook sxxsFWorkbook = new SXSSFWorkbook();
SXSSFSheet sheet = sxxsFWorkbook.createSheet("t1");
SXSSFRow row = sheet.createRow(0);
SXSSFCell cell1 = row.createCell(0);
cell1.setCellValue(999999999999999L);
SXSSFCell cell2 = row.createCell(1);
cell2.setCellValue(1000000000000001L);
SXSSFCell cell32 = row.createCell(2);
cell32.setCellValue(300.35f);
sxxsFWorkbook.write(fileOutputStream);
}
@Test
public void write01() throws IOException {
float ff = 300.35f;
BigDecimal bd = new BigDecimal(Float.toString(ff));
System.out.println(bd.doubleValue());
System.out.println(bd.floatValue());
}
@Test
public void write() throws IOException {
FileOutputStream fileOutputStream =
new FileOutputStream("D://test//tt132" + System.currentTimeMillis() + ".xlsx");
SXSSFWorkbook sxxsFWorkbook = new SXSSFWorkbook();
SXSSFSheet sheet = sxxsFWorkbook.createSheet("t1");
SXSSFRow row = sheet.createRow(0);
SXSSFCell cell1 = row.createCell(0);
cell1.setCellValue(Long.toString(999999999999999L));
SXSSFCell cell2 = row.createCell(1);
cell2.setCellValue(Long.toString(1000000000000001L));
sxxsFWorkbook.write(fileOutputStream);
}
@Test
public void write1() throws IOException {
System.out.println(JSON.toJSONString(long2Bytes(-999999999999999L)));
System.out.println(JSON.toJSONString(long2Bytes(-9999999999999999L)));
}
public static byte[] long2Bytes(long num) {
byte[] byteNum = new byte[8];
for (int ix = 0; ix < 8; ++ix) {
int offset = 64 - (ix + 1) * 8;
byteNum[ix] = (byte)((num >> offset) & 0xff);
}
return byteNum;
}
private static final Pattern FILL_PATTERN = Pattern.compile("^.*?\\$\\{[^}]+}.*?$");
@Test
public void part() throws IOException {
LOGGER.info("test:{}", FILL_PATTERN.matcher("${name今年${number}岁了").matches());
LOGGER.info("test:{}", FILL_PATTERN.matcher("${name}今年${number}岁了").matches());
LOGGER.info("test:{}", FILL_PATTERN.matcher("${name}").matches());
LOGGER.info("test:{}", FILL_PATTERN.matcher("${number}").matches());
LOGGER.info("test:{}", FILL_PATTERN.matcher("${name}今年").matches());
LOGGER.info("test:{}", FILL_PATTERN.matcher("今年${number}岁了").matches());
LOGGER.info("test:{}", FILL_PATTERN.matcher("今年${number岁了").matches());
LOGGER.info("test:{}", FILL_PATTERN.matcher("${}").matches());
LOGGER.info("test:{}", FILL_PATTERN.matcher("胜多负少").matches());
}
private static final Pattern FILL_PATTERN2 = Pattern.compile("测试");
@Test
public void part2() throws IOException {
LOGGER.info("test:{}", FILL_PATTERN.matcher("我是测试呀").find());
LOGGER.info("test:{}", FILL_PATTERN.matcher("测试u").matches());
LOGGER.info("test:{}", FILL_PATTERN.matcher("我是测试").matches());
}
@Test
public void part4() throws IOException {
//URL url=new URL("http://120.55.161.4/group1/M00/00/00/i8QJ8WFfwMiAXKYrAAACqC1MFiY641.png");
URL url = new URL(
"https://img-blog.csdn.net/20160729002743309?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T"
+ "/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center");
InputStream in = new BufferedInputStream(url.openStream());
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/PoiFormatTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/PoiFormatTest.java | package com.alibaba.easyexcel.test.temp.poi;
import java.io.IOException;
import java.util.Locale;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 测试poi
*
* @author Jiaju Zhuang
**/
public class PoiFormatTest {
private static final Logger LOGGER = LoggerFactory.getLogger(PoiFormatTest.class);
@Test
public void lastRowNum() throws IOException {
String file = "D:\\test\\原文件.xlsx";
SXSSFWorkbook xssfWorkbook = new SXSSFWorkbook(new XSSFWorkbook(file));
SXSSFSheet xssfSheet = xssfWorkbook.getSheetAt(0);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
SXSSFRow row = xssfSheet.getRow(0);
LOGGER.info("第一行数据:{}", row);
xssfSheet.createRow(20);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
}
@Test
public void lastRowNumXSSF() throws IOException {
String file = "/Users/zhuangjiaju/Downloads/测试格式.xlsx";
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(file);
LOGGER.info("一共:{}个sheet", xssfWorkbook.getNumberOfSheets());
XSSFSheet xssfSheet = xssfWorkbook.getSheetAt(0);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
XSSFRow row = xssfSheet.getRow(1);
XSSFCell xssfCell = row.getCell(0);
DataFormatter d = new DataFormatter(Locale.CHINA);
LOGGER.info("fo:{}", d.formatCellValue(xssfCell));
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/TestCell.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/TestCell.java | package com.alibaba.easyexcel.test.temp.poi;
import java.util.List;
import com.alibaba.excel.metadata.data.CellData;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* TODO
*
* @author 罗成
**/
@Getter
@Setter
@EqualsAndHashCode
public class TestCell {
private CellData<?> c1;
private CellData<List<String>> c2;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/Poi3Test.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/Poi3Test.java | package com.alibaba.easyexcel.test.temp.poi;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import org.apache.poi.hssf.record.crypto.Biff8EncryptionKey;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.openxml4j.opc.PackageAccess;
import org.apache.poi.poifs.crypt.EncryptionInfo;
import org.apache.poi.poifs.crypt.EncryptionMode;
import org.apache.poi.poifs.crypt.Encryptor;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 测试poi
*
* @author Jiaju Zhuang
**/
public class Poi3Test {
private static final Logger LOGGER = LoggerFactory.getLogger(Poi3Test.class);
@Test
public void Encryption() throws Exception {
String file = TestFileUtil.getPath() + "large" + File.separator + "large07.xlsx";
POIFSFileSystem fs = new POIFSFileSystem();
EncryptionInfo info = new EncryptionInfo(EncryptionMode.agile);
Encryptor enc = info.getEncryptor();
enc.confirmPassword("foobaa");
OPCPackage opc = OPCPackage.open(new File(file), PackageAccess.READ_WRITE);
OutputStream os = enc.getDataStream(fs);
opc.save(os);
opc.close();
// Write out the encrypted version
FileOutputStream fos = new FileOutputStream("D:\\test\\99999999999.xlsx");
fs.writeFilesystem(fos);
fos.close();
fs.close();
}
@Test
public void Encryption2() throws Exception {
Biff8EncryptionKey.setCurrentUserPassword("123456");
POIFSFileSystem fs = new POIFSFileSystem(new File("d:/test/simple03.xls"), true);
HSSFWorkbook hwb = new HSSFWorkbook(fs.getRoot(), true);
Biff8EncryptionKey.setCurrentUserPassword(null);
System.out.println(hwb.getSheetAt(0).getSheetName());
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/PoiEncryptTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/PoiEncryptTest.java | package com.alibaba.easyexcel.test.temp.poi;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import com.alibaba.easyexcel.test.core.encrypt.EncryptData;
import com.alibaba.easyexcel.test.core.simple.SimpleData;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import org.apache.poi.poifs.crypt.EncryptionInfo;
import org.apache.poi.poifs.crypt.EncryptionMode;
import org.apache.poi.poifs.crypt.Encryptor;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.jupiter.api.Test;
/**
* TODO
*
* @author Jiaju Zhuang
*/
public class PoiEncryptTest {
@Test
public void encrypt() throws Exception {
XSSFWorkbook workbook = new XSSFWorkbook();
SXSSFWorkbook sxssfWorkbook = new SXSSFWorkbook(workbook);
Sheet sheet = sxssfWorkbook.createSheet("sheet1");
sheet.createRow(0).createCell(0).setCellValue("T2");
POIFSFileSystem fs = new POIFSFileSystem();
EncryptionInfo info = new EncryptionInfo(EncryptionMode.agile);
Encryptor enc = info.getEncryptor();
enc.confirmPassword("123456");
// write the workbook into the encrypted OutputStream
OutputStream encos = enc.getDataStream(fs);
sxssfWorkbook.write(encos);
sxssfWorkbook.dispose();
sxssfWorkbook.close();
encos.close(); // this is necessary before writing out the FileSystem
OutputStream os = new FileOutputStream(
TestFileUtil.createNewFile("encrypt" + System.currentTimeMillis() + ".xlsx"));
fs.writeFilesystem(os);
os.close();
fs.close();
}
@Test
public void encryptExcel() throws Exception {
EasyExcel.write(TestFileUtil.createNewFile("encryptv2" + System.currentTimeMillis() + ".xlsx"),
EncryptData.class).password("123456")
.sheet().doWrite(data());
}
private List<SimpleData> data() {
List<SimpleData> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
SimpleData simpleData = new SimpleData();
simpleData.setName("姓名" + i);
list.add(simpleData);
}
return list;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/PoiTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/PoiTest.java | package com.alibaba.easyexcel.test.temp.poi;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Date;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.util.FileUtils;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
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.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFColor;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 测试poi
*
* @author Jiaju Zhuang
**/
public class PoiTest {
private static final Logger LOGGER = LoggerFactory.getLogger(PoiTest.class);
@Test
public void lastRowNum() throws IOException {
String file = "/Users/zhuangjiaju/test/test3.xlsx";
SXSSFWorkbook xssfWorkbook = new SXSSFWorkbook(new XSSFWorkbook(file));
SXSSFSheet xssfSheet = xssfWorkbook.getSheetAt(0);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
SXSSFRow row = xssfSheet.getRow(0);
LOGGER.info("dd{}", row.getCell(0).getColumnIndex());
Date date = row.getCell(1).getDateCellValue();
}
@Test
public void lastRowNumXSSF() throws IOException {
String file = "/Users/zhuangjiaju/test/test3 copy 10.xlsx";
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(new FileInputStream(file));
LOGGER.info("一共:{}个sheet", xssfWorkbook.getNumberOfSheets());
XSSFSheet xssfSheet = xssfWorkbook.getSheetAt(0);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
XSSFRow row = xssfSheet.getRow(1);
LOGGER.info("dd{}", row.getCell(0).getRow().getRowNum());
LOGGER.info("dd{}", xssfSheet.getLastRowNum());
XSSFCellStyle cellStyle = row.getCell(0).getCellStyle();
LOGGER.info("size1:{}", cellStyle.getFontIndexAsInt());
XSSFCellStyle cellStyle1 = xssfWorkbook.createCellStyle();
LOGGER.info("size2:{}", cellStyle1.getFontIndexAsInt());
cellStyle1.cloneStyleFrom(cellStyle);
LOGGER.info("size3:{}", cellStyle1.getFontIndexAsInt());
LOGGER.info("bbb:{}", cellStyle1.getFont().getXSSFColor().getIndex());
LOGGER.info("bbb:{}", cellStyle1.getFont().getXSSFColor().getIndexed());
XSSFColor myColor = new XSSFColor(cellStyle1.getFont().getXSSFColor().getRGB(), null);
LOGGER.info("bbb:{}", cellStyle1.getFont().getXSSFColor().getRGB());
LOGGER.info("bbb:{}", cellStyle1.getFont().getXSSFColor().getARGBHex());
LOGGER.info("bbb:{}", cellStyle1.getFont().getBold());
LOGGER.info("bbb:{}", cellStyle1.getFont().getFontName());
XSSFFont xssfFont = xssfWorkbook.createFont();
xssfFont.setColor(myColor);
xssfFont.setFontHeightInPoints((short)50);
xssfFont.setBold(Boolean.TRUE);
cellStyle1.setFont(xssfFont);
cellStyle1.setFillForegroundColor(IndexedColors.PINK.getIndex());
LOGGER.info("aaa:{}", cellStyle1.getFont().getColor());
row.getCell(1).setCellStyle(cellStyle1);
row.getCell(1).setCellValue(3334l);
XSSFCellStyle cellStyle2 = xssfWorkbook.createCellStyle();
cellStyle2.cloneStyleFrom(cellStyle);
cellStyle2.setFillForegroundColor(IndexedColors.BLUE.getIndex());
//cellStyle2.setFont(cellStyle1.getFont());
row.getCell(2).setCellStyle(cellStyle2);
row.getCell(2).setCellValue(3334l);
//LOGGER.info("date1:{}", row.getCell(0).getStringCellValue());
//LOGGER.info("date2:{}", ((XSSFColor) cellStyle.getFillForegroundColorColor()).getIndex());
//LOGGER.info("date2:{}", ((XSSFColor) cellStyle.getFillForegroundColorColor()).isRGB());
//LOGGER.info("date4:{}", ((XSSFColor) cellStyle.getFillForegroundColorColor()).isIndexed());
//LOGGER.info("date3:{}", cellStyle.getFont().getXSSFColor().getRGB());
//LOGGER.info("date4:{}", cellStyle.getFont().getCTFont().getColorArray(0).getRgb());
FileOutputStream fileOutputStream = new FileOutputStream(file);
xssfWorkbook.write(fileOutputStream);
fileOutputStream.flush();
xssfWorkbook.close();
}
@Test
public void lastRowNumXSSFv22() throws IOException {
String file = "/Users/zhuangjiaju/test/test3 copy 2.xls";
HSSFWorkbook xssfWorkbook = new HSSFWorkbook(new FileInputStream(file));
LOGGER.info("一共:{}个sheet", xssfWorkbook.getNumberOfSheets());
HSSFSheet xssfSheet = xssfWorkbook.getSheetAt(0);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
HSSFRow row = xssfSheet.getRow(1);
LOGGER.info("dd{}", row.getCell(0).getRow().getRowNum());
LOGGER.info("dd{}", xssfSheet.getLastRowNum());
HSSFCellStyle cellStyle = row.getCell(0).getCellStyle();
LOGGER.info("单元格1的字体:{}", cellStyle.getFontIndexAsInt());
HSSFCellStyle cellStyle1 = xssfWorkbook.createCellStyle();
LOGGER.info("size2:{}", cellStyle1.getFontIndexAsInt());
cellStyle1.cloneStyleFrom(cellStyle);
LOGGER.info("单元格2的字体:{}", cellStyle1.getFontIndexAsInt());
LOGGER.info("bbb:{}", cellStyle1.getFont(xssfWorkbook).getColor());
HSSFFont xssfFont = xssfWorkbook.createFont();
xssfFont.setColor(cellStyle1.getFont(xssfWorkbook).getColor());
xssfFont.setFontHeightInPoints((short)50);
xssfFont.setBold(Boolean.TRUE);
cellStyle1.setFont(xssfFont);
cellStyle1.setFillForegroundColor(IndexedColors.PINK.getIndex());
LOGGER.info("aaa:{}", cellStyle1.getFont(xssfWorkbook).getColor());
row.getCell(1).setCellStyle(cellStyle1);
row.getCell(1).setCellValue(3334l);
HSSFCellStyle cellStyle2 = xssfWorkbook.createCellStyle();
cellStyle2.cloneStyleFrom(cellStyle);
cellStyle2.setFillForegroundColor(IndexedColors.BLUE.getIndex());
//cellStyle2.setFont(cellStyle1.getFont());
row.getCell(2).setCellStyle(cellStyle2);
row.getCell(2).setCellValue(3334l);
//LOGGER.info("date1:{}", row.getCell(0).getStringCellValue());
//LOGGER.info("date2:{}", ((XSSFColor) cellStyle.getFillForegroundColorColor()).getIndex());
//LOGGER.info("date2:{}", ((XSSFColor) cellStyle.getFillForegroundColorColor()).isRGB());
//LOGGER.info("date4:{}", ((XSSFColor) cellStyle.getFillForegroundColorColor()).isIndexed());
//LOGGER.info("date3:{}", cellStyle.getFont().getXSSFColor().getRGB());
//LOGGER.info("date4:{}", cellStyle.getFont().getCTFont().getColorArray(0).getRgb());
FileOutputStream fileOutputStream = new FileOutputStream(file);
xssfWorkbook.write(fileOutputStream);
fileOutputStream.flush();
xssfWorkbook.close();
}
@Test
public void lastRowNum233() throws IOException {
String file = TestFileUtil.getPath() + "fill" + File.separator + "simple.xlsx";
Workbook xx = new XSSFWorkbook(file);
System.out.println(new File(file).exists());
SXSSFWorkbook xssfWorkbook = new SXSSFWorkbook();
Sheet xssfSheet = xssfWorkbook.getXSSFWorkbook().getSheetAt(0);
Cell cell = xssfSheet.getRow(0).createCell(9);
cell.setCellValue("testssdf是士大夫否t");
FileOutputStream fileout = new FileOutputStream("d://test/r2" + System.currentTimeMillis() + ".xlsx");
xssfWorkbook.write(fileout);
xssfWorkbook.close();
}
@Test
public void lastRowNum255() throws IOException, InvalidFormatException {
String file = "D:\\test\\complex.xlsx";
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(new File(file));
SXSSFWorkbook sxssfWorkbook = new SXSSFWorkbook(xssfWorkbook);
Sheet xssfSheet = xssfWorkbook.getSheetAt(0);
xssfSheet.shiftRows(1, 4, 10, true, true);
FileOutputStream fileout = new FileOutputStream("d://test/r2" + System.currentTimeMillis() + ".xlsx");
sxssfWorkbook.write(fileout);
sxssfWorkbook.dispose();
sxssfWorkbook.close();
xssfWorkbook.close();
}
@Test
public void cp() throws IOException, InvalidFormatException {
String file = "d://test/tt.xlsx";
SXSSFWorkbook xssfWorkbook = new SXSSFWorkbook(new XSSFWorkbook(file));
SXSSFSheet xssfSheet = xssfWorkbook.getSheetAt(0);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
SXSSFRow row = xssfSheet.getRow(0);
LOGGER.info("第一行数据:{}", row);
xssfSheet.createRow(20);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
}
@Test
public void lastRowNum233443() throws IOException, InvalidFormatException {
String file = "d://test/em0.xlsx";
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(new File(file));
XSSFSheet xssfSheet = xssfWorkbook.getSheetAt(0);
System.out.println(xssfSheet.getLastRowNum());
System.out.println(xssfSheet.getRow(0));
}
@Test
public void lastRowNum2333() throws IOException, InvalidFormatException {
String file = TestFileUtil.getPath() + "fill" + File.separator + "simple.xlsx";
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(new File(file));
SXSSFWorkbook sxssfWorkbook = new SXSSFWorkbook(xssfWorkbook);
Sheet xssfSheet = xssfWorkbook.getSheetAt(0);
Cell cell = xssfSheet.getRow(0).createCell(9);
cell.setCellValue("testssdf是士大夫否t");
FileOutputStream fileout = new FileOutputStream("d://test/r2" + System.currentTimeMillis() + ".xlsx");
sxssfWorkbook.write(fileout);
sxssfWorkbook.dispose();
sxssfWorkbook.close();
xssfWorkbook.close();
}
@Test
public void testread() throws IOException {
String file = TestFileUtil.getPath() + "fill" + File.separator + "simple.xlsx";
SXSSFWorkbook xssfWorkbook = new SXSSFWorkbook(new XSSFWorkbook(file));
Sheet xssfSheet = xssfWorkbook.getXSSFWorkbook().getSheetAt(0);
//
// Cell cell = xssfSheet.getRow(0).createCell(9);
String file1 = TestFileUtil.getPath() + "fill" + File.separator + "simple.xlsx";
SXSSFWorkbook xssfWorkbook1 = new SXSSFWorkbook(new XSSFWorkbook(file1));
Sheet xssfSheet1 = xssfWorkbook1.getXSSFWorkbook().getSheetAt(0);
// Cell cell1 = xssfSheet1.getRow(0).createCell(9);
xssfWorkbook.close();
xssfWorkbook1.close();
}
@Test
public void testreadRead() throws IOException {
String file = TestFileUtil.getPath() + "fill" + File.separator + "simple.xlsx";
FileUtils.readFileToByteArray(new File(file));
}
@Test
public void lastRowNum2332222() throws IOException {
String file = TestFileUtil.getPath() + "fill" + File.separator + "simple.xlsx";
SXSSFWorkbook xssfWorkbook = new SXSSFWorkbook(new XSSFWorkbook(file));
Sheet xssfSheet = xssfWorkbook.getXSSFWorkbook().getSheetAt(0);
Cell cell = xssfSheet.getRow(0).createCell(9);
cell.setCellValue("testssdf是士大夫否t");
FileOutputStream fileout = new FileOutputStream("d://test/r2" + System.currentTimeMillis() + ".xlsx");
xssfWorkbook.write(fileout);
}
@Test
public void lastRowNum23443() throws IOException {
String file = TestFileUtil.getPath() + "fill" + File.separator + "simple.xlsx";
SXSSFWorkbook xssfWorkbook = new SXSSFWorkbook(new XSSFWorkbook(file));
Sheet xssfSheet = xssfWorkbook.getSheetAt(0);
FileOutputStream fileout = new FileOutputStream("d://test/r2" + System.currentTimeMillis() + ".xlsx");
xssfWorkbook.write(fileout);
xssfWorkbook.close();
}
@Test
public void lastRowNum2() throws IOException {
String file = TestFileUtil.getPath() + "fill" + File.separator + "simple.xlsx";
SXSSFWorkbook xssfWorkbook = new SXSSFWorkbook(new XSSFWorkbook(file));
Sheet xssfSheet = xssfWorkbook.getXSSFWorkbook().getSheetAt(0);
LOGGER.info("一共行数:{}", xssfSheet.getPhysicalNumberOfRows());
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
LOGGER.info("一共行数:{}", xssfSheet.getFirstRowNum());
}
@Test
public void lastRowNumXSSF2() throws IOException {
String file = TestFileUtil.getPath() + "fill" + File.separator + "simple.xlsx";
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(file);
LOGGER.info("一共:{}个sheet", xssfWorkbook.getNumberOfSheets());
XSSFSheet xssfSheet = xssfWorkbook.getSheetAt(0);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
XSSFRow row = xssfSheet.getRow(0);
LOGGER.info("第一行数据:{}", row);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/PoiDateFormatTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/poi/PoiDateFormatTest.java | package com.alibaba.easyexcel.test.temp.poi;
import java.io.IOException;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 测试poi
*
* @author Jiaju Zhuang
**/
public class PoiDateFormatTest {
private static final Logger LOGGER = LoggerFactory.getLogger(PoiDateFormatTest.class);
@Test
public void read() throws IOException {
String file
= "/Users/zhuangjiaju/IdeaProjects/easyexcel/easyexcel-test/src/test/resources/dataformat/dataformat.xlsx";
XSSFWorkbook xssfWorkbook = new XSSFWorkbook( file);
XSSFSheet xssfSheet = xssfWorkbook.getSheetAt(0);
LOGGER.info("一共行数:{}", xssfSheet.getLastRowNum());
XSSFRow row = xssfSheet.getRow(7);
XSSFCell cell = row.getCell(0);
LOGGER.info("dd{}", cell.getDateCellValue());
LOGGER.info("dd{}", cell.getNumericCellValue());
LOGGER.info("dd{}", DateUtil.isCellDateFormatted(cell));
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/fill/FillData2.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/fill/FillData2.java | package com.alibaba.easyexcel.test.temp.fill;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* @author Jiaju Zhuang
*/
@Getter
@Setter
@EqualsAndHashCode
public class FillData2 {
private String test;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/fill/FillTempTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/fill/FillTempTest.java | package com.alibaba.easyexcel.test.temp.fill;
import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.alibaba.easyexcel.test.demo.fill.FillData;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.enums.WriteDirectionEnum;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.excel.write.metadata.fill.FillConfig;
import com.alibaba.excel.write.metadata.fill.FillWrapper;
import org.junit.jupiter.api.Test;
/**
* 写的填充写法
*
* @author Jiaju Zhuang
* @since 2.1.1
*/
public class FillTempTest {
/**
* 最简单的填充
*
* @since 2.1.1
*/
@Test
public void simpleFill() {
// 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"\{","\}"代替
String templateFileName = "/Users/zhuangjiaju/Downloads/simple.xlsx";
// 方案1 根据对象填充
String fileName = TestFileUtil.getPath() + "simpleFill" + System.currentTimeMillis() + ".xlsx";
// 这里 会填充到第一个sheet， 然后文件流会自动关闭
FillData fillData = new FillData();
fillData.setName("张三");
fillData.setNumber(5.2);
EasyExcel.write(fileName).withTemplate(templateFileName).sheet().doFill(fillData);
//// 方案2 根据Map填充
//fileName = TestFileUtil.getPath() + "simpleFill" + System.currentTimeMillis() + ".xlsx";
//// 这里 会填充到第一个sheet， 然后文件流会自动关闭
//Map<String, Object> map = new HashMap<String, Object>();
//map.put("name", "张三");
//map.put("number", 5.2);
//EasyExcel.write(fileName).withTemplate(templateFileName).sheet().doFill(map);
}
/**
* 填充列表
*
* @since 2.1.1
*/
@Test
public void listFill() {
// 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"\{","\}"代替
// 填充list 的时候还要注意 模板中{.} 多了个点 表示list
String templateFileName =
TestFileUtil.getPath() + "demo" + File.separator + "fill" + File.separator + "list.xlsx";
// 方案1 一下子全部放到内存里面 并填充
String fileName = TestFileUtil.getPath() + "listFill" + System.currentTimeMillis() + ".xlsx";
// 这里 会填充到第一个sheet， 然后文件流会自动关闭
EasyExcel.write(fileName).withTemplate(templateFileName).sheet().doFill(data());
// 方案2 分多次 填充 会使用文件缓存（省内存）
fileName = TestFileUtil.getPath() + "listFill" + System.currentTimeMillis() + ".xlsx";
ExcelWriter excelWriter = EasyExcel.write(fileName).withTemplate(templateFileName).build();
WriteSheet writeSheet = EasyExcel.writerSheet().build();
excelWriter.fill(data(), writeSheet);
excelWriter.fill(data(), writeSheet);
// 千万别忘记关闭流
excelWriter.finish();
}
/**
* 复杂的填充
*
* @since 2.1.1
*/
@Test
public void complexFill() {
// 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"\{","\}"代替
// {} 代表普通变量 {.} 代表是list的变量
String templateFileName =
TestFileUtil.getPath() + "demo" + File.separator + "fill" + File.separator + "complex.xlsx";
String fileName = TestFileUtil.getPath() + "complexFill" + System.currentTimeMillis() + ".xlsx";
ExcelWriter excelWriter = EasyExcel.write(fileName).withTemplate(templateFileName).build();
WriteSheet writeSheet = EasyExcel.writerSheet().build();
// 这里注意 入参用了forceNewRow 代表在写入list的时候不管list下面有没有空行 都会创建一行，然后下面的数据往后移动。默认 是false，会直接使用下一行，如果没有则创建。
// forceNewRow 如果设置了true,有个缺点 就是他会把所有的数据都放到内存了，所以慎用
// 简单的说 如果你的模板有list,且list不是最后一行，下面还有数据需要填充 就必须设置 forceNewRow=true 但是这个就会把所有数据放到内存 会很耗内存
// 如果数据量大 list不是最后一行 参照下一个
FillConfig fillConfig = FillConfig.builder().forceNewRow(Boolean.TRUE).build();
excelWriter.fill(data(), fillConfig, writeSheet);
excelWriter.fill(data(), fillConfig, writeSheet);
Map<String, Object> map = new HashMap<String, Object>();
map.put("date", "2019年10月9日13:28:28");
map.put("total", 1000);
excelWriter.fill(map, writeSheet);
excelWriter.finish();
}
/**
* 数据量大的复杂填充
* <p>
* 这里的解决方案是 确保模板list为最后一行，然后再拼接table.还有03版没救，只能刚正面加内存。
*
* @since 2.1.1
*/
@Test
public void complexFillWithTable() {
// 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"\{","\}"代替
// {} 代表普通变量 {.} 代表是list的变量
// 这里模板 删除了list以后的数据，也就是统计的这一行
String templateFileName =
TestFileUtil.getPath() + "demo" + File.separator + "fill" + File.separator + "complexFillWithTable.xlsx";
String fileName = TestFileUtil.getPath() + "complexFillWithTable" + System.currentTimeMillis() + ".xlsx";
ExcelWriter excelWriter = EasyExcel.write(fileName).withTemplate(templateFileName).build();
WriteSheet writeSheet = EasyExcel.writerSheet().build();
// 直接写入数据
excelWriter.fill(data(), writeSheet);
excelWriter.fill(data(), writeSheet);
// 写入list之前的数据
Map<String, Object> map = new HashMap<String, Object>();
map.put("date", "2019年10月9日13:28:28");
excelWriter.fill(map, writeSheet);
// list 后面还有个统计 想办法手动写入
// 这里偷懒直接用list 也可以用对象
List<List<String>> totalListList = new ArrayList<List<String>>();
List<String> totalList = new ArrayList<String>();
totalListList.add(totalList);
totalList.add(null);
totalList.add(null);
totalList.add(null);
// 第四列
totalList.add("统计:1000");
// 这里是write 别和fill 搞错了
excelWriter.write(totalListList, writeSheet);
excelWriter.finish();
// 总体上写法比较复杂 但是也没有想到好的版本 异步的去写入excel 不支持行的删除和移动，也不支持备注这种的写入，所以也排除了可以
// 新建一个 然后一点点复制过来的方案，最后导致list需要新增行的时候，后面的列的数据没法后移，后续会继续想想解决方案
}
/**
* 横向的填充
*
* @since 2.1.1
*/
@Test
public void horizontalFill() {
// 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"\{","\}"代替
// {} 代表普通变量 {.} 代表是list的变量
String templateFileName =
TestFileUtil.getPath() + "demo" + File.separator + "fill" + File.separator + "horizontal.xlsx";
String fileName = TestFileUtil.getPath() + "horizontalFill" + System.currentTimeMillis() + ".xlsx";
ExcelWriter excelWriter = EasyExcel.write(fileName).withTemplate(templateFileName).build();
WriteSheet writeSheet = EasyExcel.writerSheet().build();
FillConfig fillConfig = FillConfig.builder().direction(WriteDirectionEnum.HORIZONTAL).build();
excelWriter.fill(data(), fillConfig, writeSheet);
excelWriter.fill(data(), fillConfig, writeSheet);
Map<String, Object> map = new HashMap<String, Object>();
map.put("date", "2019年10月9日13:28:28");
excelWriter.fill(map, writeSheet);
// 别忘记关闭流
excelWriter.finish();
}
/**
* 多列表组合填充填充
*
* @since 2.2.0-beta1
*/
@Test
public void compositeFill() {
// 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"\{","\}"代替
// {} 代表普通变量 {.} 代表是list的变量 {前缀.} 前缀可以区分不同的list
String templateFileName =
TestFileUtil.getPath() + "demo" + File.separator + "fill" + File.separator + "composite.xlsx";
String fileName = TestFileUtil.getPath() + "compositeFill" + System.currentTimeMillis() + ".xlsx";
ExcelWriter excelWriter = EasyExcel.write(fileName).withTemplate(templateFileName).build();
WriteSheet writeSheet = EasyExcel.writerSheet().build();
FillConfig fillConfig = FillConfig.builder().direction(WriteDirectionEnum.HORIZONTAL).build();
// 如果有多个list 模板上必须有{前缀.} 这里的前缀就是 data1，然后多个list必须用 FillWrapper包裹
excelWriter.fill(new FillWrapper("data1", data()), fillConfig, writeSheet);
excelWriter.fill(new FillWrapper("data1", data()), fillConfig, writeSheet);
excelWriter.fill(new FillWrapper("data2", data()), writeSheet);
excelWriter.fill(new FillWrapper("data2", data()), writeSheet);
excelWriter.fill(new FillWrapper("data3", data()), writeSheet);
excelWriter.fill(new FillWrapper("data3", data()), writeSheet);
Map<String, Object> map = new HashMap<String, Object>();
//map.put("date", "2019年10月9日13:28:28");
map.put("date", new Date());
excelWriter.fill(map, writeSheet);
// 别忘记关闭流
excelWriter.finish();
}
private List<FillData> data() {
List<FillData> list = new ArrayList<FillData>();
for (int i = 0; i < 10; i++) {
FillData fillData = new FillData();
list.add(fillData);
fillData.setName("张三");
fillData.setNumber(5.2);
}
return list;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/large/NoModelLargeDataListener.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/large/NoModelLargeDataListener.java | package com.alibaba.easyexcel.test.temp.large;
import java.util.Map;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson2.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Jiaju Zhuang
*/
public class NoModelLargeDataListener extends AnalysisEventListener<Map<Integer, String>> {
private static final Logger LOGGER = LoggerFactory.getLogger(NoModelLargeDataListener.class);
private int count = 0;
@Override
public void invoke(Map<Integer, String> data, AnalysisContext context) {
if (count == 0) {
LOGGER.info("First row:{}", JSON.toJSONString(data));
}
count++;
if (count % 100000 == 0) {
LOGGER.info("Already read:{}", count);
}
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
LOGGER.info("Large row count:{}", count);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/large/LargeDataListener.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/large/LargeDataListener.java | package com.alibaba.easyexcel.test.temp.large;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson2.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Jiaju Zhuang
*/
public class LargeDataListener extends AnalysisEventListener<LargeData> {
private static final Logger LOGGER = LoggerFactory.getLogger(LargeDataListener.class);
private int count = 0;
@Override
public void invoke(LargeData data, AnalysisContext context) {
if (count == 0) {
LOGGER.info("First row:{}", JSON.toJSONString(data));
}
count++;
if (count % 100000 == 0) {
LOGGER.info("Already read:{}", count);
}
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
LOGGER.info("Large row count:{}", count);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/large/TempLargeDataTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/large/TempLargeDataTest.java | package com.alibaba.easyexcel.test.temp.large;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import org.apache.poi.openxml4j.util.ZipSecureFile;
import org.apache.poi.xssf.streaming.SXSSFCell;
import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Jiaju Zhuang
*/
public class TempLargeDataTest {
private static final Logger LOGGER = LoggerFactory.getLogger(TempLargeDataTest.class);
private int i = 0;
private static File fileFill07;
private static File template07;
private static File fileCsv;
private static File fileWrite07;
private static File fileWriteTemp07;
private static File fileWritePoi07;
@BeforeAll
public static void init() {
fileFill07 = TestFileUtil.createNewFile("largefill07.xlsx");
fileWrite07 = TestFileUtil.createNewFile("large" + File.separator + "fileWrite07.xlsx");
fileWriteTemp07 = TestFileUtil.createNewFile("large" + File.separator + "fileWriteTemp07.xlsx");
fileWritePoi07 = TestFileUtil.createNewFile("large" + File.separator + "fileWritePoi07.xlsx");
template07 = TestFileUtil.readFile("large" + File.separator + "fill.xlsx");
fileCsv = TestFileUtil.createNewFile("largefileCsv.csv");
}
@Test
public void read() throws Exception {
long start = System.currentTimeMillis();
EasyExcel.read(new FileInputStream("D:\\test\\MRP生产视图(1).xlsx"), LargeData.class, new LargeDataListener())
.headRowNumber(2).sheet().doRead();
LOGGER.info("Large data total time spent:{}", System.currentTimeMillis() - start);
}
@Test
public void noModelRead() throws Exception {
ZipSecureFile.setMaxEntrySize(Long.MAX_VALUE);
long start = System.currentTimeMillis();
EasyExcel.read(TestFileUtil.readUserHomeFile("test/ld.xlsx"), new NoModelLargeDataListener())
.sheet().doRead();
LOGGER.info("Large data total time spent:{}", System.currentTimeMillis() - start);
}
@Test
public void noModelRead2() throws Exception {
Field field = ZipSecureFile.class.getDeclaredField("MAX_ENTRY_SIZE");
field.setAccessible(true);
field.set(null, Long.MAX_VALUE);
long start = System.currentTimeMillis();
EasyExcel.read(
new File("/Users/zhuangjiaju/IdeaProjects/easyexcel/target/test-classes/large1617887262709.xlsx"),
new NoModelLargeDataListener())
.sheet().doRead();
LOGGER.info("Large data total time spent:{}", System.currentTimeMillis() - start);
}
@Test
public void t04Write() throws Exception {
ExcelWriter excelWriter = EasyExcel.write(fileWriteTemp07,
com.alibaba.easyexcel.test.core.large.LargeData.class).build();
WriteSheet writeSheet = EasyExcel.writerSheet().build();
for (int j = 0; j < 2; j++) {
excelWriter.write(data(), writeSheet);
}
excelWriter.finish();
long start = System.currentTimeMillis();
excelWriter = EasyExcel.write(fileWrite07, com.alibaba.easyexcel.test.core.large.LargeData.class).build();
writeSheet = EasyExcel.writerSheet().build();
for (int j = 0; j < 5000; j++) {
excelWriter.write(data(), writeSheet);
LOGGER.info("{} write success.", j);
}
excelWriter.finish();
long cost = System.currentTimeMillis() - start;
LOGGER.info("write cost:{}", cost);
start = System.currentTimeMillis();
try (FileOutputStream fileOutputStream = new FileOutputStream(fileWritePoi07)) {
SXSSFWorkbook workbook = new SXSSFWorkbook();
SXSSFSheet sheet = workbook.createSheet("sheet1");
for (int i = 0; i < 100 * 5000; i++) {
SXSSFRow row = sheet.createRow(i);
for (int j = 0; j < 25; j++) {
SXSSFCell cell = row.createCell(j);
cell.setCellValue("str-" + j + "-" + i);
}
if (i % 5000 == 0) {
LOGGER.info("{} write success.", i);
}
}
workbook.write(fileOutputStream);
workbook.dispose();
workbook.close();
}
long costPoi = System.currentTimeMillis() - start;
LOGGER.info("poi write cost:{}", System.currentTimeMillis() - start);
LOGGER.info("{} vs {}", cost, costPoi);
Assertions.assertTrue(costPoi * 2 > cost);
}
@Test
public void t04WriteExcel() throws Exception {
IntStream.rangeClosed(0, 100).forEach(index -> {
ExcelWriter excelWriter = EasyExcel.write(fileWriteTemp07,
com.alibaba.easyexcel.test.core.large.LargeData.class).build();
WriteSheet writeSheet = EasyExcel.writerSheet().build();
for (int j = 0; j < 5000; j++) {
excelWriter.write(data(), writeSheet);
}
excelWriter.finish();
LOGGER.info("{} 完成", index);
});
}
@Test
public void t04WriteExcelNo() throws Exception {
IntStream.rangeClosed(0, 10000).forEach(index -> {
ExcelWriter excelWriter = EasyExcel.write(fileWriteTemp07,
com.alibaba.easyexcel.test.core.large.LargeData.class).build();
WriteSheet writeSheet = EasyExcel.writerSheet().build();
for (int j = 0; j < 50; j++) {
excelWriter.write(data(), writeSheet);
}
excelWriter.finish();
LOGGER.info("{} 完成", index);
});
}
@Test
public void t04WriteExcelPoi() throws Exception {
IntStream.rangeClosed(0, 10000).forEach(index -> {
try (FileOutputStream fileOutputStream = new FileOutputStream(fileWritePoi07)) {
SXSSFWorkbook workbook = new SXSSFWorkbook(500);
//workbook.setCompressTempFiles(true);
SXSSFSheet sheet = workbook.createSheet("sheet1");
for (int i = 0; i < 100 * 50; i++) {
SXSSFRow row = sheet.createRow(i);
for (int j = 0; j < 25; j++) {
String str = "str-" + j + "-" + i;
//if (i + 10000 == j) {
SXSSFCell cell = row.createCell(j);
cell.setCellValue(str);
//System.out.println(str);
//}
}
if (i % 5000 == 0) {
LOGGER.info("{} write success.", i);
}
}
workbook.write(fileOutputStream);
workbook.dispose();
workbook.close();
} catch (Exception e) {
e.printStackTrace();
}
LOGGER.info("{} 完成", index);
});
}
private List<LargeData> data() {
List<LargeData> list = new ArrayList<>();
int size = i + 100;
for (; i < size; i++) {
LargeData largeData = new LargeData();
list.add(largeData);
largeData.setStr1("str1-" + i);
largeData.setStr2("str2-" + i);
largeData.setStr3("str3-" + i);
largeData.setStr4("str4-" + i);
largeData.setStr5("str5-" + i);
largeData.setStr6("str6-" + i);
largeData.setStr7("str7-" + i);
largeData.setStr8("str8-" + i);
largeData.setStr9("str9-" + i);
largeData.setStr10("str10-" + i);
largeData.setStr11("str11-" + i);
largeData.setStr12("str12-" + i);
largeData.setStr13("str13-" + i);
largeData.setStr14("str14-" + i);
largeData.setStr15("str15-" + i);
largeData.setStr16("str16-" + i);
largeData.setStr17("str17-" + i);
largeData.setStr18("str18-" + i);
largeData.setStr19("str19-" + i);
largeData.setStr20("str20-" + i);
largeData.setStr21("str21-" + i);
largeData.setStr22("str22-" + i);
largeData.setStr23("str23-" + i);
largeData.setStr24("str24-" + i);
largeData.setStr25("str25-" + i);
}
return list;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/large/LargeData.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/large/LargeData.java | package com.alibaba.easyexcel.test.temp.large;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
/**
* @author Jiaju Zhuang
*/
@Getter
@Setter
@EqualsAndHashCode
@NoArgsConstructor
public class LargeData {
private String str1;
private String str2;
private String str3;
private String str4;
private String str5;
private String str6;
private String str7;
private String str8;
private String str9;
private String str10;
private String str11;
private String str12;
private String str13;
private String str14;
private String str15;
private String str16;
private String str17;
private String str18;
private String str19;
private String str20;
private String str21;
private String str22;
private String str23;
private String str24;
private String str25;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/WriteData.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/WriteData.java | package com.alibaba.easyexcel.test.temp.simple;
import java.util.Date;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* write data
*
* @author Jiaju Zhuang
**/
@Getter
@Setter
@EqualsAndHashCode
public class WriteData {
// @ContentStyle(locked = true)
private Date dd;
// @ContentStyle(locked = false)
private float f1;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/HgListener.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/HgListener.java | package com.alibaba.easyexcel.test.temp.simple;
import java.util.Map;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson2.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 模板的读取类
*
* @author Jiaju Zhuang
*/
public class HgListener extends AnalysisEventListener<Map<Integer, String>> {
private static final Logger LOGGER = LoggerFactory.getLogger(HgListener.class);
/**
* 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
*/
private static final int BATCH_COUNT = 5;
@Override
public void invoke(Map<Integer, String> data, AnalysisContext context) {
LOGGER.info("index:{}", context.readRowHolder().getRowIndex());
LOGGER.info("解析到一条数据:{}", JSON.toJSONString(data));
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
LOGGER.info("所有数据解析完成！");
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/JsonData.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/JsonData.java | package com.alibaba.easyexcel.test.temp.simple;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* TODO
*
* @author Jiaju Zhuang
**/
@Getter
@Setter
@EqualsAndHashCode
public class JsonData {
private String SS1;
private String sS2;
private String ss3;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/DemoData1.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/DemoData1.java | package com.alibaba.easyexcel.test.temp.simple;
import java.util.Date;
import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.write.style.HeadStyle;
import com.alibaba.excel.enums.poi.FillPatternTypeEnum;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode
public class DemoData1 {
@ExcelProperty("字符串标题")
@HeadStyle(fillPatternType = FillPatternTypeEnum.SOLID_FOREGROUND, fillForegroundColor = 42)
private String string;
@ExcelProperty("日期标题")
private Date date;
@ExcelProperty("数字标题")
private Double doubleData;
/**
* 忽略这个字段
*/
@ExcelIgnore
private String ignore;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/RepeatListener.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/RepeatListener.java | package com.alibaba.easyexcel.test.temp.simple;
import java.util.ArrayList;
import java.util.List;
import com.alibaba.easyexcel.test.demo.read.DemoDataListener;
import com.alibaba.easyexcel.test.temp.LockData;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson2.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 模板的读取类
*
* @author Jiaju Zhuang
*/
public class RepeatListener extends AnalysisEventListener<LockData> {
private static final Logger LOGGER = LoggerFactory.getLogger(DemoDataListener.class);
/**
* 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
*/
private static final int BATCH_COUNT = 5;
List<LockData> list = new ArrayList<LockData>();
@Override
public void invoke(LockData data, AnalysisContext context) {
LOGGER.info("解析到一条数据:{}", JSON.toJSONString(data));
list.add(data);
if (list.size() >= BATCH_COUNT) {
saveData();
list.clear();
}
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
saveData();
LOGGER.info("所有数据解析完成！");
}
/**
* 加上存储数据库
*/
private void saveData() {
LOGGER.info("{}条数据，开始存储数据库！", list.size());
LOGGER.info("存储数据库成功！");
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/Write.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/Write.java | package com.alibaba.easyexcel.test.temp.simple;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import com.alibaba.easyexcel.test.core.large.LargeData;
import com.alibaba.easyexcel.test.demo.write.DemoData;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.util.BeanMapUtils;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.excel.write.metadata.WriteTable;
import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 测试poi
*
* @author Jiaju Zhuang
**/
@Slf4j
public class Write {
private static final Logger LOGGER = LoggerFactory.getLogger(Write.class);
@Test
public void simpleWrite1() {
LargeData ss = new LargeData();
ss.setStr23("ttt");
Map map = BeanMapUtils.create(ss);
System.out.println(map.containsKey("str23"));
System.out.println(map.containsKey("str22"));
System.out.println(map.get("str23"));
System.out.println(map.get("str22"));
}
@Test
public void simpleWrite() {
log.info("t5");
// 写法1
String fileName = TestFileUtil.getPath() + "t22" + System.currentTimeMillis() + ".xlsx";
// 这里 需要指定写用哪个class去读，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
// 如果这里想使用03 则 传入excelType参数即可
EasyExcel.write(fileName, DemoData.class).relativeHeadRowIndex(10).sheet("模板").doWrite(data());
}
@Test
public void simpleWrite2() {
// 写法1
String fileName = TestFileUtil.getPath() + "t22" + System.currentTimeMillis() + ".xlsx";
// 这里 需要指定写用哪个class去读，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
// 如果这里想使用03 则 传入excelType参数即可
EasyExcel.write(fileName, WriteData.class).sheet("模板").registerWriteHandler(new WriteHandler()).doWrite(
data1());
}
@Test
public void simpleWrite3() {
// 写法1
String fileName = TestFileUtil.getPath() + "t33" + System.currentTimeMillis() + ".xlsx";
// 这里 需要指定写用哪个class去读，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
// 如果这里想使用03 则 传入excelType参数即可
EasyExcel.write(fileName).head(head()).inMemory(true).sheet("模板").registerWriteHandler(new WriteCellHandler())
.doWrite(
data1());
}
@Test
public void json() {
JsonData jsonData = new JsonData();
jsonData.setSS1("11");
jsonData.setSS2("22");
jsonData.setSs3("33");
System.out.println(JSON.toJSONString(jsonData));
}
@Test
public void json3() {
String json = "{\"SS1\":\"11\",\"sS2\":\"22\",\"ss3\":\"33\"}";
JsonData jsonData = JSON.parseObject(json, JsonData.class);
System.out.println(JSON.toJSONString(jsonData));
}
@Test
public void tableWrite() {
String fileName = TestFileUtil.getPath() + "tableWrite" + System.currentTimeMillis() + ".xlsx";
// 这里直接写多个table的案例了，如果只有一个 也可以直一行代码搞定，参照其他案例
// 这里 需要指定写用哪个class去写
ExcelWriter excelWriter = EasyExcel.write(fileName).build();
// 把sheet设置为不需要头 不然会输出sheet的头 这样看起来第一个table 就有2个头了
WriteSheet writeSheet = EasyExcel.writerSheet("模板").build();
// 这里必须指定需要头，table 会继承sheet的配置，sheet配置了不需要，table 默认也是不需要
WriteTable writeTable0 = EasyExcel.writerTable(0).head(DemoData1.class).build();
// 第一次写入会创建头
excelWriter.write(data(), writeSheet, writeTable0);
// 第二次写如也会创建头，然后在第一次的后面写入数据
/// 千万别忘记close 会帮忙关闭流
excelWriter.finish();
}
private List<List<String>> head() {
List<List<String>> list = new ArrayList<List<String>>();
List<String> head0 = new ArrayList<String>();
head0.add("字符串" + System.currentTimeMillis());
List<String> head1 = new ArrayList<String>();
head1.add("数字" + System.currentTimeMillis());
List<String> head2 = new ArrayList<String>();
head2.add("日期" + System.currentTimeMillis());
list.add(head0);
list.add(head1);
list.add(head2);
return list;
}
private List<DemoData> data() {
List<DemoData> list = new ArrayList<DemoData>();
for (int i = 0; i < 10; i++) {
DemoData data = new DemoData();
data.setString("640121807369666560" + i);
data.setDate(new Date());
data.setDoubleData(null);
list.add(data);
}
return list;
}
private List<WriteData> data1() {
List<WriteData> list = new ArrayList<WriteData>();
for (int i = 0; i < 10; i++) {
WriteData data = new WriteData();
data.setDd(new Date());
data.setF1(33f);
list.add(data);
}
return list;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/WriteHandler.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/WriteHandler.java | package com.alibaba.easyexcel.test.temp.simple;
import com.alibaba.excel.write.handler.SheetWriteHandler;
import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
import com.alibaba.excel.write.metadata.holder.WriteWorkbookHolder;
import lombok.extern.slf4j.Slf4j;
/**
* @author Jiaju Zhuang
*/
@Slf4j
public class WriteHandler implements SheetWriteHandler {
@Override
public void afterSheetCreate(WriteWorkbookHolder writeWorkbookHolder,
WriteSheetHolder writeSheetHolder) {
log.info("锁住");
writeSheetHolder.getSheet().protectSheet("edit");
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/DemoData2.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/DemoData2.java | package com.alibaba.easyexcel.test.temp.simple;
import java.util.Date;
import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.write.style.HeadStyle;
import com.alibaba.excel.enums.poi.FillPatternTypeEnum;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode
public class DemoData2 {
@ExcelProperty("字符串标题")
@HeadStyle(fillPatternType = FillPatternTypeEnum.SOLID_FOREGROUND, fillForegroundColor = 42)
private String string;
@ExcelProperty("日期标题")
private Date date;
@ExcelProperty("数字标题")
private Double doubleData;
/**
* 忽略这个字段
*/
@ExcelIgnore
private String ignore;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/HgTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/HgTest.java | package com.alibaba.easyexcel.test.temp.simple;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.List;
import com.alibaba.excel.EasyExcel;
import com.alibaba.fastjson2.JSON;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 测试poi
*
* @author Jiaju Zhuang
**/
public class HgTest {
private static final Logger LOGGER = LoggerFactory.getLogger(HgTest.class);
@Test
public void hh() throws IOException {
List<Object> list =
EasyExcel.read(new FileInputStream("D:\\test\\201909301017rule.xlsx")).headRowNumber(2).sheet()
.doReadSync();
for (Object data : list) {
LOGGER.info("返回数据：{}", JSON.toJSONString(data));
}
}
@Test
public void hh5() throws IOException {
URL url = new URL(
"http://hotelcontractfil.oss-cn-beijing.aliyuncs"
+ ".com/2019/%E5%98%89%E6%83%A0-%E4%B8%AD%E4%BA%A4%E5%BB%BA_2019-09-01_2019-09-30_1569055677522"
+ ".xlsx?Expires=1884415681&OSSAccessKeyId=LTAIGZDkqZfPArBr&Signature=Rf0gbO8vl3l%2Brj1KdyzHHMsUhCE"
+ "%3D");
InputStream is = url.openStream();
List<Object> list =
EasyExcel.read(is).headRowNumber(0).sheet().doReadSync();
for (Object data : list) {
LOGGER.info("返回数据：{}", JSON.toJSONString(data));
}
}
@Test
public void hh2() throws IOException {
EasyExcel.read(new FileInputStream("D:\\test\\商户不匹配工单信息收集表格.xlsx")).registerReadListener(
new HgListener())
.headRowNumber(0).sheet().doRead();
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/WriteCellHandler.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/WriteCellHandler.java | package com.alibaba.easyexcel.test.temp.simple;
import com.alibaba.excel.metadata.Head;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.write.handler.CellWriteHandler;
import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
import com.alibaba.excel.write.metadata.holder.WriteTableHolder;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.DataFormat;
import org.apache.poi.ss.usermodel.IndexedColors;
/**
* @author Jiaju Zhuang
*/
@Slf4j
public class WriteCellHandler implements CellWriteHandler {
@Override
public void afterCellDataConverted(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder,
WriteCellData<?> cellData, Cell cell, Head head, Integer integer, Boolean isHead) {
if (!isHead) {
CreationHelper createHelper = writeSheetHolder.getSheet().getWorkbook().getCreationHelper();
CellStyle cellStyle = writeSheetHolder.getSheet().getWorkbook().createCellStyle();
if (cellStyle != null) {
DataFormat dataFormat = createHelper.createDataFormat();
cellStyle.setWrapText(true);
cellStyle.setFillBackgroundColor(IndexedColors.RED.getIndex());
cellStyle.setBottomBorderColor(IndexedColors.RED.getIndex());
cellStyle.setDataFormat(dataFormat.getFormat("yyyy-MM-dd"));
cell.setCellStyle(cellStyle);
}
}
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/RepeatTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/simple/RepeatTest.java | package com.alibaba.easyexcel.test.temp.simple;
import java.io.FileInputStream;
import java.io.IOException;
import com.alibaba.easyexcel.test.temp.LockData;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelReader;
import com.alibaba.excel.read.metadata.ReadSheet;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 测试poi
*
* @author Jiaju Zhuang
**/
public class RepeatTest {
private static final Logger LOGGER = LoggerFactory.getLogger(RepeatTest.class);
@Test
public void hh() throws IOException {
ExcelReader reader =
EasyExcel.read(new FileInputStream("D:\\test\\hg2.xls"), LockData.class, new RepeatListener())
.headRowNumber(0).build();
ReadSheet r1 = EasyExcel.readSheet(0).build();
ReadSheet r2 = EasyExcel.readSheet(2).build();
reader.read(r1);
reader.read(r2);
reader.finish();
}
@Test
public void hh2() throws IOException {
ExcelReader reader =
EasyExcel.read(new FileInputStream("D:\\test\\sheet.xls"), LockData.class, new RepeatListener())
.headRowNumber(0).build();
ReadSheet r2 = EasyExcel.readSheet(1).build();
reader.read(r2);
reader.finish();
}
@Test
public void hh1() throws IOException {
ExcelReader reader =
EasyExcel.read(new FileInputStream("D:\\test\\hg2.xls"), LockData.class, new RepeatListener())
.headRowNumber(0).build();
ReadSheet r2 = EasyExcel.readSheet(0).build();
reader.read(r2);
reader.finish();
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/data/HeadType.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/data/HeadType.java | package com.alibaba.easyexcel.test.temp.data;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode
public class HeadType {
/**
* 任务id
*/
@ExcelProperty("任务ID")
private Integer id;
@ExcelProperty(value = "备注1")
private String firstRemark;
@ExcelProperty(value = "备注2")
private String secRemark;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/data/DataType.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/data/DataType.java | package com.alibaba.easyexcel.test.temp.data;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode
public class DataType {
/**
* 任务id
*/
@ExcelProperty("任务ID")
private Integer id;
@ExcelProperty("多余字段1")
private String firstSurplus;
@ExcelProperty("多余字段2")
private String secSurplus;
@ExcelProperty("多余字段3")
private String thirdSurplus;
@ExcelProperty(value = "备注1")
private String firstRemark;
@ExcelProperty(value = "备注2")
private String secRemark;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/csv/CsvDataListeer.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/csv/CsvDataListeer.java | package com.alibaba.easyexcel.test.temp.csv;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class CsvDataListeer extends AnalysisEventListener<CsvData> {
@Override
public void invoke(CsvData data, AnalysisContext context) {
log.info("data:{}", JSON.toJSONString(data));
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/csv/CsvData.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/csv/CsvData.java | package com.alibaba.easyexcel.test.temp.csv;
import java.util.Date;
import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* TODO
*
* @author Jiaju Zhuang
*/
@Getter
@Setter
@EqualsAndHashCode
public class CsvData {
@ExcelProperty("字符串标题")
private String string;
@ExcelProperty("日期标题")
private Date date;
@ExcelProperty("数字标题")
private Double doubleData;
/**
* 忽略这个字段
*/
@ExcelIgnore
private String ignore;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/csv/CsvReadTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/csv/CsvReadTest.java | package com.alibaba.easyexcel.test.temp.csv;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVPrinter;
import org.apache.commons.csv.CSVRecord;
import org.apache.poi.poifs.filesystem.FileMagic;
import org.junit.jupiter.api.Test;
@Slf4j
public class CsvReadTest {
@Test
public void write() throws Exception {
Appendable out = new PrintWriter(
new OutputStreamWriter(new FileOutputStream(TestFileUtil.createNewFile("csvWrite1.csv"))));
CSVPrinter printer = CSVFormat.DEFAULT.withHeader("userId", "userName")
.print(out);
for (int i = 0; i < 10; i++) {
printer.printRecord("userId" + i, "userName" + i);
}
printer.flush();
printer.close();
}
@Test
public void read1() throws Exception {
Iterable<CSVRecord> records = CSVFormat.DEFAULT.withNullString("").parse(
new FileReader("/Users/zhuangjiaju/IdeaProjects/easyexcel/target/test-classes/t1.csv"));
for (CSVRecord record : records) {
String lastName = record.get(0);
String firstName = record.get(1);
log.info("row:{},{}", lastName, firstName);
}
}
@Test
public void csvWrite() throws Exception {
// 写法1
String fileName = TestFileUtil.getPath() + "simpleWrite" + System.currentTimeMillis() + ".csv";
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
// 如果这里想使用03 则 传入excelType参数即可
EasyExcel.write(fileName, CsvData.class).sheet().doWrite(data());
// 读
List<Object> list = EasyExcel.read(fileName).sheet(0).headRowNumber(0).doReadSync();
log.info("数据：{}", list.size());
for (Object data : list) {
log.info("返回数据：{}", JSON.toJSONString(data));
}
}
@Test
public void writev2() throws Exception {
// 写法1
String fileName = TestFileUtil.getPath() + "simpleWrite" + System.currentTimeMillis() + ".csv";
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
// 如果这里想使用03 则 传入excelType参数即可
EasyExcel.write(fileName, CsvData.class).sheet().doWrite(data());
EasyExcel.read(fileName, CsvData.class, new CsvDataListeer()).sheet().doRead();
}
@Test
public void writeFile() throws Exception {
FileInputStream fileInputStream = new FileInputStream(new File("/Users/zhuangjiaju/test/test1.csv"));
FileMagic fileMagic = FileMagic.valueOf(fileInputStream);
log.info("{}", fileMagic);
}
private List<CsvData> data() {
List<CsvData> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
CsvData data = new CsvData();
data.setString("字符,串" + i);
//data.setDate(new Date());
data.setDoubleData(0.56);
data.setIgnore("忽略" + i);
list.add(data);
}
return list;
}
@Test
public void read() {
//
//Iterable<CSVRecord> records = CSVFormat.DEFAULT.withFirstRecordAsHeader().parse(in);
//for (CSVRecord record : records) {
// String lastName = record.get("id");
// String firstName = record.get("name");
// System.out.println(lastName);
// System.out.println(firstName);
//}
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue1662/Data1662.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue1662/Data1662.java | package com.alibaba.easyexcel.test.temp.issue1662;
import java.util.Date;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode
@AllArgsConstructor
@NoArgsConstructor
public class Data1662 {
@ExcelProperty(index = 0)
private String str;
@ExcelProperty(index = 1)
private Date date;
@ExcelProperty(index = 2)
private double r;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue1662/Issue1662Test.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue1662/Issue1662Test.java | package com.alibaba.easyexcel.test.temp.issue1662;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import org.junit.jupiter.api.Test;
public class Issue1662Test {
@Test
public void test1662() {
String fileName = TestFileUtil.getPath() + "Test1939" + ".xlsx";
System.out.println(fileName);
EasyExcel.write(fileName).head(head()).sheet("模板").doWrite(dataList());
}
private List<List<String>> head() {
List<List<String>> list = new ArrayList<List<String>>();
List<String> head0 = new ArrayList<String>();
List<String> head1 = new ArrayList<String>();
head0.add("xx");
head0.add("日期");
list.add(head0);
head1.add("日期");
list.add(head1);
return list;
}
private List<List<Object>> dataList() {
List<List<Object>> list = new ArrayList<List<Object>>();
List<Object> data = new ArrayList<Object>();
data.add("字符串");
data.add(new Date());
data.add(0.56);
list.add(data);
return list;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/HeadReadTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/HeadReadTest.java | package com.alibaba.easyexcel.test.temp.read;
import java.io.File;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.cache.Ehcache;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 临时测试
*
* @author Jiaju Zhuang
**/
public class HeadReadTest {
private static final Logger LOGGER = LoggerFactory.getLogger(HeadReadTest.class);
@Test
public void test() throws Exception {
File file = TestFileUtil.readUserHomeFile("test/t2.xlsx");
EasyExcel.read(file, HeadReadData.class, new HeadListener()).ignoreEmptyRow(false).sheet(0).doRead();
}
@Test
public void testCache() throws Exception {
File file = new File("D:\\test\\headt1.xls");
EasyExcel.read(file, HeadReadData.class, new HDListener()).readCache(new Ehcache(20)).sheet(0).doRead();
LOGGER.info("------------------");
EasyExcel.read(file, HeadReadData.class, new HDListener()).readCache(new Ehcache(20)).sheet(0).doRead();
LOGGER.info("------------------");
EasyExcel.read(file, HeadReadData.class, new HDListener()).readCache(new Ehcache(20)).sheet(0).doRead();
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/CommentTest.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/CommentTest.java | package com.alibaba.easyexcel.test.temp.read;
import java.io.File;
import java.util.List;
import java.util.Map;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.metadata.data.CellData;
import com.alibaba.fastjson2.JSON;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 临时测试
*
* @author Jiaju Zhuang
**/
public class CommentTest {
private static final Logger LOGGER = LoggerFactory.getLogger(CommentTest.class);
@Test
public void comment() throws Exception {
File file = new File("D:\\test\\d1.xlsx");
List<Map<Integer, CellData>> datas = EasyExcel.read(file).doReadAllSync();
for (Map<Integer, CellData> data : datas) {
LOGGER.info("数据:{}", JSON.toJSONString(data));
}
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/TestListener.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/TestListener.java | package com.alibaba.easyexcel.test.temp.read;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
/**
* TODO
*
* @author JiaJu Zhuang
* @date 2020/4/9 16:33
**/
@Slf4j
public class TestListener extends AnalysisEventListener {
@Override
public void invoke(Object o, AnalysisContext analysisContext) {
log.info("解析一条:{}", JSON.toJSONString(o));
}
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/HeadListener.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/HeadListener.java | package com.alibaba.easyexcel.test.temp.read;
import java.util.Map;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson2.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 模板的读取类
*
* @author Jiaju Zhuang
*/
public class HeadListener extends AnalysisEventListener<HeadReadData> {
private static final Logger LOGGER = LoggerFactory.getLogger(HeadListener.class);
/**
* 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
*/
private static final int BATCH_COUNT = 5;
@Override
public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
LOGGER.info("HEAD:{}", JSON.toJSONString(headMap));
LOGGER.info("total:{}", context.readSheetHolder().getTotal());
}
@Override
public void invoke(HeadReadData data, AnalysisContext context) {
LOGGER.info("index:{}", context.readRowHolder().getRowIndex());
LOGGER.info("解析到一条数据:{}", JSON.toJSONString(data));
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
LOGGER.info("所有数据解析完成！");
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/HDListener.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/HDListener.java | package com.alibaba.easyexcel.test.temp.read;
import java.util.Map;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson2.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 模板的读取类
*
* @author Jiaju Zhuang
*/
public class HDListener extends AnalysisEventListener<HeadReadData> {
private static final Logger LOGGER = LoggerFactory.getLogger(HDListener.class);
/**
* 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
*/
private static final int BATCH_COUNT = 5;
@Override
public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
LOGGER.info("HEAD:{}", JSON.toJSONString(headMap));
LOGGER.info("total:{}", context.readSheetHolder().getTotal());
}
@Override
public void invoke(HeadReadData data, AnalysisContext context) {
LOGGER.info("index:{}", context.readRowHolder().getRowIndex());
LOGGER.info("解析到一条数据:{}", JSON.toJSONString(data));
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
LOGGER.info("所有数据解析完成！");
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/HeadReadData.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/read/HeadReadData.java | package com.alibaba.easyexcel.test.temp.read;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* 临时测试
*
* @author Jiaju Zhuang
**/
@Getter
@Setter
@EqualsAndHashCode
public class HeadReadData {
@ExcelProperty({"主标题", "数据1"})
private String h1;
@ExcelProperty({"主标题", "数据2"})
private String h2;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue2443/Issue2443.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue2443/Issue2443.java | package com.alibaba.easyexcel.test.temp.issue2443;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode
public class Issue2443 {
private int a;
private int b;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue2443/Issue2443Test.java | easyexcel-test/src/test/java/com/alibaba/easyexcel/test/temp/issue2443/Issue2443Test.java | package com.alibaba.easyexcel.test.temp.issue2443;
import java.io.File;
import java.text.ParseException;
import com.alibaba.easyexcel.test.util.TestFileUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.read.listener.PageReadListener;
import com.alibaba.excel.util.NumberUtils;
import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
@Slf4j
public class Issue2443Test {
//CS304 (manually written) Issue link: https://github.com/alibaba/easyexcel/issues/2443
@Test
public void IssueTest1() {
String fileName = TestFileUtil.getPath() + "temp/issue2443" + File.separator + "date1.xlsx";
EasyExcel.read(fileName, Issue2443.class, new PageReadListener<Issue2443>(dataList -> {
for (Issue2443 issueData : dataList) {
log.info("读取到一条数据{}", JSON.toJSONString(issueData));
}
})).sheet().doRead();
}
//CS304 (manually written) Issue link: https://github.com/alibaba/easyexcel/issues/2443
@Test
public void IssueTest2() {
String fileName = TestFileUtil.getPath() + "temp/issue2443" + File.separator + "date2.xlsx";
EasyExcel.read(fileName, Issue2443.class, new PageReadListener<Issue2443>(dataList -> {
for (Issue2443 issueData : dataList) {
log.info("读取到一条数据{}", JSON.toJSONString(issueData));
}
})).sheet().doRead();
}
@Test
public void parseIntegerTest1() throws ParseException {
String string = "1.00";
ExcelContentProperty contentProperty = null;
int Int = NumberUtils.parseInteger(string, contentProperty);
Assertions.assertEquals(1, Int);
}
@Test
public void parseIntegerTest2() throws ParseException {
String string = "2.00";
ExcelContentProperty contentProperty = null;
int Int = NumberUtils.parseInteger(string, contentProperty);
Assertions.assertEquals(2, Int);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/src/test/java/com/alibaba/easyexcel/test/demo/write/WriteTest.java | src/test/java/com/alibaba/easyexcel/test/demo/write/WriteTest.java | /**
* Documents have been migrated to <a href="https://github.com/alibaba/easyexcel/blob/master/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/write/WriteTest.java">https://github.com/alibaba/easyexcel/blob/master/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/write/WriteTest.java</a>
*/
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/src/test/java/com/alibaba/easyexcel/test/demo/fill/FillTest.java | src/test/java/com/alibaba/easyexcel/test/demo/fill/FillTest.java | /**
* Documents have been migrated to <a href="https://github.com/alibaba/easyexcel/blob/master/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/fill/FillTest.java">https://github.com/alibaba/easyexcel/blob/master/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/fill/FillTest.java</a>
*/
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/src/test/java/com/alibaba/easyexcel/test/demo/read/ReadTest.java | src/test/java/com/alibaba/easyexcel/test/demo/read/ReadTest.java | /**
* Documents have been migrated to <a href="https://github.com/alibaba/easyexcel/blob/master/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/read/ReadTest.java">https://github.com/alibaba/easyexcel/blob/master/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/read/ReadTest.java</a>
*/
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/src/test/java/com/alibaba/easyexcel/test/demo/web/WebTest.java | src/test/java/com/alibaba/easyexcel/test/demo/web/WebTest.java | /**
* Documents have been migrated to <a href="https://github.com/alibaba/easyexcel/blob/master/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/web/WebTest.java">https://github.com/alibaba/easyexcel/blob/master/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/web/WebTest.java</a>
*/
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel/src/main/java/com/alibaba/excel/Empty.java | easyexcel/src/main/java/com/alibaba/excel/Empty.java | package com.alibaba.excel;
/**
* empty
*
* @author Jiaju Zhuang
*/
public class Empty {
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-support/src/main/java/com/alibaba/excel/support/Empty.java | easyexcel-support/src/main/java/com/alibaba/excel/support/Empty.java | package com.alibaba.excel.support;
/**
* empty
*
* @author Jiaju Zhuang
*/
public class Empty {
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/EasyExcel.java | easyexcel-core/src/main/java/com/alibaba/excel/EasyExcel.java | package com.alibaba.excel;
/**
* This is actually {@link EasyExcelFactory}, and short names look better.
*
* @author jipengfei
*/
public class EasyExcel extends EasyExcelFactory {}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/EasyExcelFactory.java | easyexcel-core/src/main/java/com/alibaba/excel/EasyExcelFactory.java | package com.alibaba.excel;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import com.alibaba.excel.read.builder.ExcelReaderBuilder;
import com.alibaba.excel.read.builder.ExcelReaderSheetBuilder;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.excel.write.builder.ExcelWriterBuilder;
import com.alibaba.excel.write.builder.ExcelWriterSheetBuilder;
import com.alibaba.excel.write.builder.ExcelWriterTableBuilder;
/**
* Reader and writer factory class
*
* @author jipengfei
*/
public class EasyExcelFactory {
/**
* Build excel the write
*
* @return
*/
public static ExcelWriterBuilder write() {
return new ExcelWriterBuilder();
}
/**
* Build excel the write
*
* @param file File to write
* @return Excel writer builder
*/
public static ExcelWriterBuilder write(File file) {
return write(file, null);
}
/**
* Build excel the write
*
* @param file File to write
* @param head Annotate the class for configuration information
* @return Excel writer builder
*/
public static ExcelWriterBuilder write(File file, Class head) {
ExcelWriterBuilder excelWriterBuilder = new ExcelWriterBuilder();
excelWriterBuilder.file(file);
if (head != null) {
excelWriterBuilder.head(head);
}
return excelWriterBuilder;
}
/**
* Build excel the write
*
* @param pathName File path to write
* @return Excel writer builder
*/
public static ExcelWriterBuilder write(String pathName) {
return write(pathName, null);
}
/**
* Build excel the write
*
* @param pathName File path to write
* @param head Annotate the class for configuration information
* @return Excel writer builder
*/
public static ExcelWriterBuilder write(String pathName, Class head) {
ExcelWriterBuilder excelWriterBuilder = new ExcelWriterBuilder();
excelWriterBuilder.file(pathName);
if (head != null) {
excelWriterBuilder.head(head);
}
return excelWriterBuilder;
}
/**
* Build excel the write
*
* @param outputStream Output stream to write
* @return Excel writer builder
*/
public static ExcelWriterBuilder write(OutputStream outputStream) {
return write(outputStream, null);
}
/**
* Build excel the write
*
* @param outputStream Output stream to write
* @param head Annotate the class for configuration information.
* @return Excel writer builder
*/
public static ExcelWriterBuilder write(OutputStream outputStream, Class head) {
ExcelWriterBuilder excelWriterBuilder = new ExcelWriterBuilder();
excelWriterBuilder.file(outputStream);
if (head != null) {
excelWriterBuilder.head(head);
}
return excelWriterBuilder;
}
/**
* Build excel the <code>writerSheet</code>
*
* @return Excel sheet writer builder
*/
public static ExcelWriterSheetBuilder writerSheet() {
return writerSheet(null, null);
}
/**
* Build excel the <code>writerSheet</code>
*
* @param sheetNo Index of sheet,0 base.
* @return Excel sheet writer builder.
*/
public static ExcelWriterSheetBuilder writerSheet(Integer sheetNo) {
return writerSheet(sheetNo, null);
}
/**
* Build excel the 'writerSheet'
*
* @param sheetName The name of sheet.
* @return Excel sheet writer builder.
*/
public static ExcelWriterSheetBuilder writerSheet(String sheetName) {
return writerSheet(null, sheetName);
}
/**
* Build excel the 'writerSheet'
*
* @param sheetNo Index of sheet,0 base.
* @param sheetName The name of sheet.
* @return Excel sheet writer builder.
*/
public static ExcelWriterSheetBuilder writerSheet(Integer sheetNo, String sheetName) {
ExcelWriterSheetBuilder excelWriterSheetBuilder = new ExcelWriterSheetBuilder();
if (sheetNo != null) {
excelWriterSheetBuilder.sheetNo(sheetNo);
}
if (sheetName != null) {
excelWriterSheetBuilder.sheetName(sheetName);
}
return excelWriterSheetBuilder;
}
/**
* Build excel the <code>writerTable</code>
*
* @return Excel table writer builder.
*/
public static ExcelWriterTableBuilder writerTable() {
return writerTable(null);
}
/**
* Build excel the 'writerTable'
*
* @param tableNo Index of table,0 base.
* @return Excel table writer builder.
*/
public static ExcelWriterTableBuilder writerTable(Integer tableNo) {
ExcelWriterTableBuilder excelWriterTableBuilder = new ExcelWriterTableBuilder();
if (tableNo != null) {
excelWriterTableBuilder.tableNo(tableNo);
}
return excelWriterTableBuilder;
}
/**
* Build excel the read
*
* @return Excel reader builder.
*/
public static ExcelReaderBuilder read() {
return new ExcelReaderBuilder();
}
/**
* Build excel the read
*
* @param file File to read.
* @return Excel reader builder.
*/
public static ExcelReaderBuilder read(File file) {
return read(file, null, null);
}
/**
* Build excel the read
*
* @param file File to read.
* @param readListener Read listener.
* @return Excel reader builder.
*/
public static ExcelReaderBuilder read(File file, ReadListener readListener) {
return read(file, null, readListener);
}
/**
* Build excel the read
*
* @param file File to read.
* @param head Annotate the class for configuration information.
* @param readListener Read listener.
* @return Excel reader builder.
*/
public static ExcelReaderBuilder read(File file, Class head, ReadListener readListener) {
ExcelReaderBuilder excelReaderBuilder = new ExcelReaderBuilder();
excelReaderBuilder.file(file);
if (head != null) {
excelReaderBuilder.head(head);
}
if (readListener != null) {
excelReaderBuilder.registerReadListener(readListener);
}
return excelReaderBuilder;
}
/**
* Build excel the read
*
* @param pathName File path to read.
* @return Excel reader builder.
*/
public static ExcelReaderBuilder read(String pathName) {
return read(pathName, null, null);
}
/**
* Build excel the read
*
* @param pathName File path to read.
* @param readListener Read listener.
* @return Excel reader builder.
*/
public static ExcelReaderBuilder read(String pathName, ReadListener readListener) {
return read(pathName, null, readListener);
}
/**
* Build excel the read
*
* @param pathName File path to read.
* @param head Annotate the class for configuration information.
* @param readListener Read listener.
* @return Excel reader builder.
*/
public static ExcelReaderBuilder read(String pathName, Class head, ReadListener readListener) {
ExcelReaderBuilder excelReaderBuilder = new ExcelReaderBuilder();
excelReaderBuilder.file(pathName);
if (head != null) {
excelReaderBuilder.head(head);
}
if (readListener != null) {
excelReaderBuilder.registerReadListener(readListener);
}
return excelReaderBuilder;
}
/**
* Build excel the read
*
* @param inputStream Input stream to read.
* @return Excel reader builder.
*/
public static ExcelReaderBuilder read(InputStream inputStream) {
return read(inputStream, null, null);
}
/**
* Build excel the read
*
* @param inputStream Input stream to read.
* @param readListener Read listener.
* @return Excel reader builder.
*/
public static ExcelReaderBuilder read(InputStream inputStream, ReadListener readListener) {
return read(inputStream, null, readListener);
}
/**
* Build excel the read
*
* @param inputStream Input stream to read.
* @param head Annotate the class for configuration information.
* @param readListener Read listener.
* @return Excel reader builder.
*/
public static ExcelReaderBuilder read(InputStream inputStream, Class head, ReadListener readListener) {
ExcelReaderBuilder excelReaderBuilder = new ExcelReaderBuilder();
excelReaderBuilder.file(inputStream);
if (head != null) {
excelReaderBuilder.head(head);
}
if (readListener != null) {
excelReaderBuilder.registerReadListener(readListener);
}
return excelReaderBuilder;
}
/**
* Build excel the 'readSheet'
*
* @return Excel sheet reader builder.
*/
public static ExcelReaderSheetBuilder readSheet() {
return readSheet(null, null);
}
/**
* Build excel the 'readSheet'
*
* @param sheetNo Index of sheet,0 base.
* @return Excel sheet reader builder.
*/
public static ExcelReaderSheetBuilder readSheet(Integer sheetNo) {
return readSheet(sheetNo, null);
}
/**
* Build excel the 'readSheet'
*
* @param sheetName The name of sheet.
* @return Excel sheet reader builder.
*/
public static ExcelReaderSheetBuilder readSheet(String sheetName) {
return readSheet(null, sheetName);
}
/**
* Build excel the 'readSheet'
*
* @param sheetNo Index of sheet,0 base.
* @param sheetName The name of sheet.
* @return Excel sheet reader builder.
*/
public static ExcelReaderSheetBuilder readSheet(Integer sheetNo, String sheetName) {
ExcelReaderSheetBuilder excelReaderSheetBuilder = new ExcelReaderSheetBuilder();
if (sheetNo != null) {
excelReaderSheetBuilder.sheetNo(sheetNo);
}
if (sheetName != null) {
excelReaderSheetBuilder.sheetName(sheetName);
}
return excelReaderSheetBuilder;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/ExcelWriter.java | easyexcel-core/src/main/java/com/alibaba/excel/ExcelWriter.java | package com.alibaba.excel;
import java.io.Closeable;
import java.util.Collection;
import java.util.function.Supplier;
import com.alibaba.excel.context.WriteContext;
import com.alibaba.excel.write.ExcelBuilder;
import com.alibaba.excel.write.ExcelBuilderImpl;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.excel.write.metadata.WriteTable;
import com.alibaba.excel.write.metadata.WriteWorkbook;
import com.alibaba.excel.write.metadata.fill.FillConfig;
import lombok.extern.slf4j.Slf4j;
/**
* Excel Writer This tool is used to write value out to Excel via POI. This object can perform the following two
* functions.
*
* <pre>
* 1. Create a new empty Excel workbook, write the value to the stream after the value is filled.
* 2. Edit existing Excel, write the original Excel file, or write it to other places.}
* </pre>
*
* @author jipengfei
*/
@Slf4j
public class ExcelWriter implements Closeable {
private final ExcelBuilder excelBuilder;
/**
* Create new writer
*
* @param writeWorkbook
*/
public ExcelWriter(WriteWorkbook writeWorkbook) {
excelBuilder = new ExcelBuilderImpl(writeWorkbook);
}
/**
* Write data to a sheet
*
* @param data Data to be written
* @param writeSheet Write to this sheet
* @return this current writer
*/
public ExcelWriter write(Collection<?> data, WriteSheet writeSheet) {
return write(data, writeSheet, null);
}
/**
* Write data to a sheet
*
* @param supplier Data to be written
* @param writeSheet Write to this sheet
* @return this current writer
*/
public ExcelWriter write(Supplier<Collection<?>> supplier, WriteSheet writeSheet) {
return write(supplier.get(), writeSheet, null);
}
/**
* Write value to a sheet
*
* @param data Data to be written
* @param writeSheet Write to this sheet
* @param writeTable Write to this table
* @return this
*/
public ExcelWriter write(Collection<?> data, WriteSheet writeSheet, WriteTable writeTable) {
excelBuilder.addContent(data, writeSheet, writeTable);
return this;
}
/**
* Write value to a sheet
*
* @param supplier Data to be written
* @param writeSheet Write to this sheet
* @param writeTable Write to this table
* @return this
*/
public ExcelWriter write(Supplier<Collection<?>> supplier, WriteSheet writeSheet, WriteTable writeTable) {
excelBuilder.addContent(supplier.get(), writeSheet, writeTable);
return this;
}
/**
* Fill value to a sheet
*
* @param data
* @param writeSheet
* @return
*/
public ExcelWriter fill(Object data, WriteSheet writeSheet) {
return fill(data, null, writeSheet);
}
/**
* Fill value to a sheet
*
* @param data
* @param fillConfig
* @param writeSheet
* @return
*/
public ExcelWriter fill(Object data, FillConfig fillConfig, WriteSheet writeSheet) {
excelBuilder.fill(data, fillConfig, writeSheet);
return this;
}
/**
* Fill value to a sheet
*
* @param supplier
* @param writeSheet
* @return
*/
public ExcelWriter fill(Supplier<Object> supplier, WriteSheet writeSheet) {
return fill(supplier.get(), null, writeSheet);
}
/**
* Fill value to a sheet
*
* @param supplier
* @param fillConfig
* @param writeSheet
* @return
*/
public ExcelWriter fill(Supplier<Object> supplier, FillConfig fillConfig, WriteSheet writeSheet) {
excelBuilder.fill(supplier.get(), fillConfig, writeSheet);
return this;
}
/**
* Close IO
*/
public void finish() {
if (excelBuilder != null) {
excelBuilder.finish(false);
}
}
/**
* The context of the entire writing process
*
* @return
*/
public WriteContext writeContext() {
return excelBuilder.writeContext();
}
@Override
public void close() {
finish();
}
/**
* Prevents calls to {@link #finish} from freeing the cache
*/
@Override
protected void finalize() {
try {
finish();
} catch (Throwable e) {
log.warn("Destroy object failed", e);
}
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/ExcelReader.java | easyexcel-core/src/main/java/com/alibaba/excel/ExcelReader.java | package com.alibaba.excel;
import java.io.Closeable;
import java.util.Arrays;
import java.util.List;
import com.alibaba.excel.analysis.ExcelAnalyser;
import com.alibaba.excel.analysis.ExcelAnalyserImpl;
import com.alibaba.excel.analysis.ExcelReadExecutor;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.metadata.ReadSheet;
import com.alibaba.excel.read.metadata.ReadWorkbook;
import lombok.extern.slf4j.Slf4j;
/**
* Excel readers are all read in event mode.
*
* @author jipengfei
*/
@Slf4j
public class ExcelReader implements Closeable {
/**
* Analyser
*/
private final ExcelAnalyser excelAnalyser;
public ExcelReader(ReadWorkbook readWorkbook) {
excelAnalyser = new ExcelAnalyserImpl(readWorkbook);
}
/**
* Parse all sheet content by default
*
* @deprecated lease use {@link #readAll()}
*/
@Deprecated
public void read() {
readAll();
}
/***
* Parse all sheet content by default
*/
public void readAll() {
excelAnalyser.analysis(null, Boolean.TRUE);
}
/**
* Parse the specified sheet，SheetNo start from 0
*
* @param readSheet Read sheet
*/
public ExcelReader read(ReadSheet... readSheet) {
return read(Arrays.asList(readSheet));
}
/**
* Read multiple sheets.
*
* @param readSheetList
* @return
*/
public ExcelReader read(List<ReadSheet> readSheetList) {
excelAnalyser.analysis(readSheetList, Boolean.FALSE);
return this;
}
/**
* Context for the entire execution process
*
* @return
*/
public AnalysisContext analysisContext() {
return excelAnalyser.analysisContext();
}
/**
* Current executor
*
* @return
*/
public ExcelReadExecutor excelExecutor() {
return excelAnalyser.excelExecutor();
}
/**
* @return
* @deprecated please use {@link #analysisContext()}
*/
@Deprecated
public AnalysisContext getAnalysisContext() {
return analysisContext();
}
/**
* Complete the entire read file.Release the cache and close stream.
*/
public void finish() {
if (excelAnalyser != null) {
excelAnalyser.finish();
}
}
@Override
public void close() {
finish();
}
/**
* Prevents calls to {@link #finish} from freeing the cache
*
*/
@Override
protected void finalize() {
try {
finish();
} catch (Throwable e) {
log.warn("Destroy object failed", e);
}
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/ConverterKeyBuild.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/ConverterKeyBuild.java | package com.alibaba.excel.converters;
import java.util.Map;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.util.MapUtils;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* Converter unique key.Consider that you can just use class as the key.
*
* @author Jiaju Zhuang
*/
public class ConverterKeyBuild {
private static final Map<Class<?>, Class<?>> BOXING_MAP = MapUtils.newHashMap();
static {
BOXING_MAP.put(int.class, Integer.class);
BOXING_MAP.put(byte.class, Byte.class);
BOXING_MAP.put(long.class, Long.class);
BOXING_MAP.put(double.class, Double.class);
BOXING_MAP.put(float.class, Float.class);
BOXING_MAP.put(char.class, Character.class);
BOXING_MAP.put(short.class, Short.class);
BOXING_MAP.put(boolean.class, Boolean.class);
}
public static ConverterKey buildKey(Class<?> clazz) {
return buildKey(clazz, null);
}
public static ConverterKey buildKey(Class<?> clazz, CellDataTypeEnum cellDataTypeEnum) {
Class<?> boxingClass = BOXING_MAP.get(clazz);
if (boxingClass != null) {
return new ConverterKey(boxingClass, cellDataTypeEnum);
}
return new ConverterKey(clazz, cellDataTypeEnum);
}
@Getter
@Setter
@EqualsAndHashCode
@AllArgsConstructor
public static class ConverterKey {
private Class<?> clazz;
private CellDataTypeEnum cellDataTypeEnum;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/DefaultConverterLoader.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/DefaultConverterLoader.java | package com.alibaba.excel.converters;
import java.util.Map;
import com.alibaba.excel.converters.ConverterKeyBuild.ConverterKey;
import com.alibaba.excel.converters.bigdecimal.BigDecimalBooleanConverter;
import com.alibaba.excel.converters.bigdecimal.BigDecimalNumberConverter;
import com.alibaba.excel.converters.bigdecimal.BigDecimalStringConverter;
import com.alibaba.excel.converters.biginteger.BigIntegerBooleanConverter;
import com.alibaba.excel.converters.biginteger.BigIntegerNumberConverter;
import com.alibaba.excel.converters.biginteger.BigIntegerStringConverter;
import com.alibaba.excel.converters.booleanconverter.BooleanBooleanConverter;
import com.alibaba.excel.converters.booleanconverter.BooleanNumberConverter;
import com.alibaba.excel.converters.booleanconverter.BooleanStringConverter;
import com.alibaba.excel.converters.bytearray.BoxingByteArrayImageConverter;
import com.alibaba.excel.converters.bytearray.ByteArrayImageConverter;
import com.alibaba.excel.converters.byteconverter.ByteBooleanConverter;
import com.alibaba.excel.converters.byteconverter.ByteNumberConverter;
import com.alibaba.excel.converters.byteconverter.ByteStringConverter;
import com.alibaba.excel.converters.date.DateDateConverter;
import com.alibaba.excel.converters.date.DateNumberConverter;
import com.alibaba.excel.converters.date.DateStringConverter;
import com.alibaba.excel.converters.doubleconverter.DoubleBooleanConverter;
import com.alibaba.excel.converters.doubleconverter.DoubleNumberConverter;
import com.alibaba.excel.converters.doubleconverter.DoubleStringConverter;
import com.alibaba.excel.converters.file.FileImageConverter;
import com.alibaba.excel.converters.floatconverter.FloatBooleanConverter;
import com.alibaba.excel.converters.floatconverter.FloatNumberConverter;
import com.alibaba.excel.converters.floatconverter.FloatStringConverter;
import com.alibaba.excel.converters.inputstream.InputStreamImageConverter;
import com.alibaba.excel.converters.integer.IntegerBooleanConverter;
import com.alibaba.excel.converters.integer.IntegerNumberConverter;
import com.alibaba.excel.converters.integer.IntegerStringConverter;
import com.alibaba.excel.converters.localdate.LocalDateDateConverter;
import com.alibaba.excel.converters.localdate.LocalDateNumberConverter;
import com.alibaba.excel.converters.localdate.LocalDateStringConverter;
import com.alibaba.excel.converters.localdatetime.LocalDateTimeNumberConverter;
import com.alibaba.excel.converters.localdatetime.LocalDateTimeDateConverter;
import com.alibaba.excel.converters.localdatetime.LocalDateTimeStringConverter;
import com.alibaba.excel.converters.longconverter.LongBooleanConverter;
import com.alibaba.excel.converters.longconverter.LongNumberConverter;
import com.alibaba.excel.converters.longconverter.LongStringConverter;
import com.alibaba.excel.converters.shortconverter.ShortBooleanConverter;
import com.alibaba.excel.converters.shortconverter.ShortNumberConverter;
import com.alibaba.excel.converters.shortconverter.ShortStringConverter;
import com.alibaba.excel.converters.string.StringBooleanConverter;
import com.alibaba.excel.converters.string.StringErrorConverter;
import com.alibaba.excel.converters.string.StringNumberConverter;
import com.alibaba.excel.converters.string.StringStringConverter;
import com.alibaba.excel.converters.url.UrlImageConverter;
import com.alibaba.excel.util.MapUtils;
/**
* Load default handler
*
* @author Jiaju Zhuang
*/
public class DefaultConverterLoader {
private static Map<ConverterKey, Converter<?>> defaultWriteConverter;
private static Map<ConverterKey, Converter<?>> allConverter;
static {
initDefaultWriteConverter();
initAllConverter();
}
private static void initAllConverter() {
allConverter = MapUtils.newHashMapWithExpectedSize(40);
putAllConverter(new BigDecimalBooleanConverter());
putAllConverter(new BigDecimalNumberConverter());
putAllConverter(new BigDecimalStringConverter());
putAllConverter(new BigIntegerBooleanConverter());
putAllConverter(new BigIntegerNumberConverter());
putAllConverter(new BigIntegerStringConverter());
putAllConverter(new BooleanBooleanConverter());
putAllConverter(new BooleanNumberConverter());
putAllConverter(new BooleanStringConverter());
putAllConverter(new ByteBooleanConverter());
putAllConverter(new ByteNumberConverter());
putAllConverter(new ByteStringConverter());
putAllConverter(new DateNumberConverter());
putAllConverter(new DateStringConverter());
putAllConverter(new LocalDateNumberConverter());
putAllConverter(new LocalDateStringConverter());
putAllConverter(new LocalDateTimeNumberConverter());
putAllConverter(new LocalDateTimeStringConverter());
putAllConverter(new DoubleBooleanConverter());
putAllConverter(new DoubleNumberConverter());
putAllConverter(new DoubleStringConverter());
putAllConverter(new FloatBooleanConverter());
putAllConverter(new FloatNumberConverter());
putAllConverter(new FloatStringConverter());
putAllConverter(new IntegerBooleanConverter());
putAllConverter(new IntegerNumberConverter());
putAllConverter(new IntegerStringConverter());
putAllConverter(new LongBooleanConverter());
putAllConverter(new LongNumberConverter());
putAllConverter(new LongStringConverter());
putAllConverter(new ShortBooleanConverter());
putAllConverter(new ShortNumberConverter());
putAllConverter(new ShortStringConverter());
putAllConverter(new StringBooleanConverter());
putAllConverter(new StringNumberConverter());
putAllConverter(new StringStringConverter());
putAllConverter(new StringErrorConverter());
}
private static void initDefaultWriteConverter() {
defaultWriteConverter = MapUtils.newHashMapWithExpectedSize(40);
putWriteConverter(new BigDecimalNumberConverter());
putWriteConverter(new BigIntegerNumberConverter());
putWriteConverter(new BooleanBooleanConverter());
putWriteConverter(new ByteNumberConverter());
putWriteConverter(new DateDateConverter());
putWriteConverter(new LocalDateTimeDateConverter());
putWriteConverter(new LocalDateDateConverter());
putWriteConverter(new DoubleNumberConverter());
putWriteConverter(new FloatNumberConverter());
putWriteConverter(new IntegerNumberConverter());
putWriteConverter(new LongNumberConverter());
putWriteConverter(new ShortNumberConverter());
putWriteConverter(new StringStringConverter());
putWriteConverter(new FileImageConverter());
putWriteConverter(new InputStreamImageConverter());
putWriteConverter(new ByteArrayImageConverter());
putWriteConverter(new BoxingByteArrayImageConverter());
putWriteConverter(new UrlImageConverter());
// In some cases, it must be converted to string
putWriteStringConverter(new BigDecimalStringConverter());
putWriteStringConverter(new BigIntegerStringConverter());
putWriteStringConverter(new BooleanStringConverter());
putWriteStringConverter(new ByteStringConverter());
putWriteStringConverter(new DateStringConverter());
putWriteStringConverter(new LocalDateStringConverter());
putWriteStringConverter(new LocalDateTimeStringConverter());
putWriteStringConverter(new DoubleStringConverter());
putWriteStringConverter(new FloatStringConverter());
putWriteStringConverter(new IntegerStringConverter());
putWriteStringConverter(new LongStringConverter());
putWriteStringConverter(new ShortStringConverter());
putWriteStringConverter(new StringStringConverter());
}
/**
* Load default write converter
*
* @return
*/
public static Map<ConverterKey, Converter<?>> loadDefaultWriteConverter() {
return defaultWriteConverter;
}
private static void putWriteConverter(Converter<?> converter) {
defaultWriteConverter.put(ConverterKeyBuild.buildKey(converter.supportJavaTypeKey()), converter);
}
private static void putWriteStringConverter(Converter<?> converter) {
defaultWriteConverter.put(
ConverterKeyBuild.buildKey(converter.supportJavaTypeKey(), converter.supportExcelTypeKey()), converter);
}
/**
* Load default read converter
*
* @return
*/
public static Map<ConverterKey, Converter<?>> loadDefaultReadConverter() {
return loadAllConverter();
}
/**
* Load all converter
*
* @return
*/
public static Map<ConverterKey, Converter<?>> loadAllConverter() {
return allConverter;
}
private static void putAllConverter(Converter<?> converter) {
allConverter.put(ConverterKeyBuild.buildKey(converter.supportJavaTypeKey(), converter.supportExcelTypeKey()),
converter);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/Converter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/Converter.java | package com.alibaba.excel.converters;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
/**
* Convert between Java objects and excel objects
*
* @param <T>
* @author Dan Zheng
*/
public interface Converter<T> {
/**
* Back to object types in Java
*
* @return Support for Java class
*/
default Class<?> supportJavaTypeKey() {
throw new UnsupportedOperationException("The current operation is not supported by the current converter.");
}
/**
* Back to object enum in excel
*
* @return Support for {@link CellDataTypeEnum}
*/
default CellDataTypeEnum supportExcelTypeKey() {
throw new UnsupportedOperationException("The current operation is not supported by the current converter.");
}
/**
* Convert excel objects to Java objects
*
* @param cellData Excel cell data.NotNull.
* @param contentProperty Content property.Nullable.
* @param globalConfiguration Global configuration.NotNull.
* @return Data to put into a Java object
* @throws Exception Exception.
*/
default T convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) throws Exception {
throw new UnsupportedOperationException("The current operation is not supported by the current converter.");
}
/**
* Convert excel objects to Java objects
*
* @param context read converter context
* @return Data to put into a Java object
* @throws Exception Exception.
*/
default T convertToJavaData(ReadConverterContext<?> context) throws Exception {
return convertToJavaData(context.getReadCellData(), context.getContentProperty(),
context.getAnalysisContext().currentReadHolder().globalConfiguration());
}
/**
* Convert Java objects to excel objects
*
* @param value Java Data.NotNull.
* @param contentProperty Content property.Nullable.
* @param globalConfiguration Global configuration.NotNull.
* @return Data to put into a Excel
* @throws Exception Exception.
*/
default WriteCellData<?> convertToExcelData(T value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) throws Exception {
throw new UnsupportedOperationException("The current operation is not supported by the current converter.");
}
/**
* Convert Java objects to excel objects
*
* @param context write context
* @return Data to put into a Excel
* @throws Exception Exception.
*/
default WriteCellData<?> convertToExcelData(WriteConverterContext<T> context) throws Exception {
return convertToExcelData(context.getValue(), context.getContentProperty(),
context.getWriteContext().currentWriteHolder().globalConfiguration());
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/ReadConverterContext.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/ReadConverterContext.java | package com.alibaba.excel.converters;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* read converter context
*
* @author Jiaju Zhuang
*/
@Getter
@Setter
@EqualsAndHashCode
@AllArgsConstructor
public class ReadConverterContext<T> {
/**
* Excel cell data.NotNull.
*/
private ReadCellData<T> readCellData;
/**
* Content property.Nullable.
*/
private ExcelContentProperty contentProperty;
/**
* context.NotNull.
*/
private AnalysisContext analysisContext;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/WriteConverterContext.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/WriteConverterContext.java | package com.alibaba.excel.converters;
import com.alibaba.excel.context.WriteContext;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
/**
* write converter context
*
* @author Jiaju Zhuang
*/
@Getter
@Setter
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class WriteConverterContext<T> {
/**
* Java Data.NotNull.
*/
private T value;
/**
* Content property.Nullable.
*/
private ExcelContentProperty contentProperty;
/**
* write context
*/
private WriteContext writeContext;
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/NullableObjectConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/NullableObjectConverter.java | package com.alibaba.excel.converters;
/**
* When implementing <code>convertToExcelData</code> method, pay attention to the reference <code>value</code> may be
* null
*
* @author JiaJu Zhuang
**/
public interface NullableObjectConverter<T> extends Converter<T> {
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/AutoConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/AutoConverter.java | package com.alibaba.excel.converters;
/**
* An empty converter.It's automatically converted by type.
*
* @author Jiaju Zhuang
*/
public class AutoConverter implements Converter<Object> {
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/string/StringStringConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/string/StringStringConverter.java | package com.alibaba.excel.converters.string;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
/**
* String and string converter
*
* @author Jiaju Zhuang
*/
public class StringStringConverter implements Converter<String> {
@Override
public Class<?> supportJavaTypeKey() {
return String.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.STRING;
}
@Override
public String convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return cellData.getStringValue();
}
@Override
public WriteCellData<?> convertToExcelData(String value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return new WriteCellData<>(value);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/string/StringBooleanConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/string/StringBooleanConverter.java | package com.alibaba.excel.converters.string;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
/**
* String and boolean converter
*
* @author Jiaju Zhuang
*/
public class StringBooleanConverter implements Converter<String> {
@Override
public Class<?> supportJavaTypeKey() {
return String.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.BOOLEAN;
}
@Override
public String convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return cellData.getBooleanValue().toString();
}
@Override
public WriteCellData<?> convertToExcelData(String value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return new WriteCellData<>(Boolean.valueOf(value));
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/string/StringErrorConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/string/StringErrorConverter.java | package com.alibaba.excel.converters.string;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
/**
* String and error converter
*
* @author Jiaju Zhuang
*/
public class StringErrorConverter implements Converter<String> {
@Override
public Class<String> supportJavaTypeKey() {
return String.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.ERROR;
}
@Override
public String convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return cellData.getStringValue();
}
@Override
public WriteCellData<?> convertToExcelData(String value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return new WriteCellData<>(CellDataTypeEnum.ERROR, value);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/string/StringNumberConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/string/StringNumberConverter.java | package com.alibaba.excel.converters.string;
import java.math.BigDecimal;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.DateUtils;
import com.alibaba.excel.util.NumberDataFormatterUtils;
import com.alibaba.excel.util.NumberUtils;
import com.alibaba.excel.util.StringUtils;
import org.apache.poi.ss.usermodel.DateUtil;
/**
* String and number converter
*
* @author Jiaju Zhuang
*/
public class StringNumberConverter implements Converter<String> {
@Override
public Class<?> supportJavaTypeKey() {
return String.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.NUMBER;
}
@Override
public String convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
// If there are "DateTimeFormat", read as date
if (contentProperty != null && contentProperty.getDateTimeFormatProperty() != null) {
return DateUtils.format(cellData.getNumberValue(),
contentProperty.getDateTimeFormatProperty().getUse1904windowing(),
contentProperty.getDateTimeFormatProperty().getFormat());
}
// If there are "NumberFormat", read as number
if (contentProperty != null && contentProperty.getNumberFormatProperty() != null) {
return NumberUtils.format(cellData.getNumberValue(), contentProperty);
}
// Excel defines formatting
boolean hasDataFormatData = cellData.getDataFormatData() != null
&& cellData.getDataFormatData().getIndex() != null && !StringUtils.isEmpty(
cellData.getDataFormatData().getFormat());
if (hasDataFormatData) {
return NumberDataFormatterUtils.format(cellData.getNumberValue(),
cellData.getDataFormatData().getIndex(), cellData.getDataFormatData().getFormat(), globalConfiguration);
}
// Default conversion number
return NumberUtils.format(cellData.getNumberValue(), contentProperty);
}
@Override
public WriteCellData<?> convertToExcelData(String value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return new WriteCellData<>(new BigDecimal(value));
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/string/StringImageConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/string/StringImageConverter.java | package com.alibaba.excel.converters.string;
import java.io.File;
import java.io.IOException;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.FileUtils;
/**
* String and image converter
*
* @author Jiaju Zhuang
*/
public class StringImageConverter implements Converter<String> {
@Override
public Class<?> supportJavaTypeKey() {
return String.class;
}
@Override
public WriteCellData<?> convertToExcelData(String value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) throws IOException {
return new WriteCellData<>(FileUtils.readFileToByteArray(new File(value)));
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/file/FileImageConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/file/FileImageConverter.java | package com.alibaba.excel.converters.file;
import java.io.File;
import java.io.IOException;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.FileUtils;
/**
* File and image converter
*
* @author Jiaju Zhuang
*/
public class FileImageConverter implements Converter<File> {
@Override
public Class<?> supportJavaTypeKey() {
return File.class;
}
@Override
public WriteCellData<?> convertToExcelData(File value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) throws IOException {
return new WriteCellData<>(FileUtils.readFileToByteArray(value));
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/doubleconverter/DoubleBooleanConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/doubleconverter/DoubleBooleanConverter.java | package com.alibaba.excel.converters.doubleconverter;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
/**
* Double and boolean converter
*
* @author Jiaju Zhuang
*/
public class DoubleBooleanConverter implements Converter<Double> {
private static final Double ONE = 1.0;
private static final Double ZERO = 0.0;
@Override
public Class<?> supportJavaTypeKey() {
return Double.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.BOOLEAN;
}
@Override
public Double convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (cellData.getBooleanValue()) {
return ONE;
}
return ZERO;
}
@Override
public WriteCellData<?> convertToExcelData(Double value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (ONE.equals(value)) {
return new WriteCellData<>(Boolean.TRUE);
}
return new WriteCellData<>(Boolean.FALSE);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/doubleconverter/DoubleStringConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/doubleconverter/DoubleStringConverter.java | package com.alibaba.excel.converters.doubleconverter;
import java.text.ParseException;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.NumberUtils;
/**
* Double and string converter
*
* @author Jiaju Zhuang
*/
public class DoubleStringConverter implements Converter<Double> {
@Override
public Class<?> supportJavaTypeKey() {
return Double.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.STRING;
}
@Override
public Double convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) throws ParseException {
return NumberUtils.parseDouble(cellData.getStringValue(), contentProperty);
}
@Override
public WriteCellData<?> convertToExcelData(Double value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return NumberUtils.formatToCellDataString(value, contentProperty);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/doubleconverter/DoubleNumberConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/doubleconverter/DoubleNumberConverter.java | package com.alibaba.excel.converters.doubleconverter;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.NumberUtils;
/**
* Double and number converter
*
* @author Jiaju Zhuang
*/
public class DoubleNumberConverter implements Converter<Double> {
@Override
public Class<?> supportJavaTypeKey() {
return Double.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.NUMBER;
}
@Override
public Double convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return cellData.getNumberValue().doubleValue();
}
@Override
public WriteCellData<?> convertToExcelData(Double value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return NumberUtils.formatToCellData(value, contentProperty);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/localdate/LocalDateDateConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/localdate/LocalDateDateConverter.java | package com.alibaba.excel.converters.localdate;
import java.time.LocalDate;
import java.time.LocalDateTime;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.DateUtils;
import com.alibaba.excel.util.WorkBookUtil;
/**
* LocalDate and date converter
*
* @author Jiaju Zhuang
*/
public class LocalDateDateConverter implements Converter<LocalDate> {
@Override
public Class<?> supportJavaTypeKey() {
return LocalDate.class;
}
@Override
public WriteCellData<?> convertToExcelData(LocalDate value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) throws Exception {
LocalDateTime localDateTime = value == null ? null : value.atTime(0, 0);
WriteCellData<?> cellData = new WriteCellData<>(localDateTime);
String format = null;
if (contentProperty != null && contentProperty.getDateTimeFormatProperty() != null) {
format = contentProperty.getDateTimeFormatProperty().getFormat();
}
WorkBookUtil.fillDataFormat(cellData, format, DateUtils.defaultLocalDateFormat);
return cellData;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/localdate/LocalDateStringConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/localdate/LocalDateStringConverter.java | package com.alibaba.excel.converters.localdate;
import java.text.ParseException;
import java.time.LocalDate;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.DateUtils;
/**
* LocalDate and string converter
*
* @author Jiaju Zhuang
*/
public class LocalDateStringConverter implements Converter<LocalDate> {
@Override
public Class<?> supportJavaTypeKey() {
return LocalDate.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.STRING;
}
@Override
public LocalDate convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) throws ParseException {
if (contentProperty == null || contentProperty.getDateTimeFormatProperty() == null) {
return DateUtils.parseLocalDate(cellData.getStringValue(), null, globalConfiguration.getLocale());
} else {
return DateUtils.parseLocalDate(cellData.getStringValue(),
contentProperty.getDateTimeFormatProperty().getFormat(), globalConfiguration.getLocale());
}
}
@Override
public WriteCellData<?> convertToExcelData(LocalDate value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (contentProperty == null || contentProperty.getDateTimeFormatProperty() == null) {
return new WriteCellData<>(DateUtils.format(value, null, globalConfiguration.getLocale()));
} else {
return new WriteCellData<>(
DateUtils.format(value, contentProperty.getDateTimeFormatProperty().getFormat(),
globalConfiguration.getLocale()));
}
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/localdate/LocalDateNumberConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/localdate/LocalDateNumberConverter.java | package com.alibaba.excel.converters.localdate;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.DateUtils;
import org.apache.poi.ss.usermodel.DateUtil;
/**
* LocalDate and number converter
*
* @author Jiaju Zhuang
*/
public class LocalDateNumberConverter implements Converter<LocalDate> {
@Override
public Class<?> supportJavaTypeKey() {
return LocalDate.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.NUMBER;
}
@Override
public LocalDate convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (contentProperty == null || contentProperty.getDateTimeFormatProperty() == null) {
return DateUtils.getLocalDate(cellData.getNumberValue().doubleValue(),
globalConfiguration.getUse1904windowing());
} else {
return DateUtils.getLocalDate(cellData.getNumberValue().doubleValue(),
contentProperty.getDateTimeFormatProperty().getUse1904windowing());
}
}
@Override
public WriteCellData<?> convertToExcelData(LocalDate value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (contentProperty == null || contentProperty.getDateTimeFormatProperty() == null) {
return new WriteCellData<>(
BigDecimal.valueOf(DateUtil.getExcelDate(value, globalConfiguration.getUse1904windowing())));
} else {
return new WriteCellData<>(BigDecimal.valueOf(
DateUtil.getExcelDate(value, contentProperty.getDateTimeFormatProperty().getUse1904windowing())));
}
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/biginteger/BigIntegerStringConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/biginteger/BigIntegerStringConverter.java | package com.alibaba.excel.converters.biginteger;
import java.math.BigInteger;
import java.text.ParseException;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.NumberUtils;
/**
* BigDecimal and string converter
*
* @author Jiaju Zhuang
*/
public class BigIntegerStringConverter implements Converter<BigInteger> {
@Override
public Class<BigInteger> supportJavaTypeKey() {
return BigInteger.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.STRING;
}
@Override
public BigInteger convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) throws ParseException {
return NumberUtils.parseBigDecimal(cellData.getStringValue(), contentProperty).toBigInteger();
}
@Override
public WriteCellData<?> convertToExcelData(BigInteger value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return NumberUtils.formatToCellDataString(value, contentProperty);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/biginteger/BigIntegerNumberConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/biginteger/BigIntegerNumberConverter.java | package com.alibaba.excel.converters.biginteger;
import java.math.BigInteger;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.NumberUtils;
/**
* BigInteger and number converter
*
* @author Jiaju Zhuang
*/
public class BigIntegerNumberConverter implements Converter<BigInteger> {
@Override
public Class<BigInteger> supportJavaTypeKey() {
return BigInteger.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.NUMBER;
}
@Override
public BigInteger convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return cellData.getNumberValue().toBigInteger();
}
@Override
public WriteCellData<?> convertToExcelData(BigInteger value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return NumberUtils.formatToCellData(value, contentProperty);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/biginteger/BigIntegerBooleanConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/biginteger/BigIntegerBooleanConverter.java | package com.alibaba.excel.converters.biginteger;
import java.math.BigInteger;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
/**
* BigInteger and boolean converter
*
* @author Jiaju Zhuang
*/
public class BigIntegerBooleanConverter implements Converter<BigInteger> {
@Override
public Class<BigInteger> supportJavaTypeKey() {
return BigInteger.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.BOOLEAN;
}
@Override
public BigInteger convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (cellData.getBooleanValue()) {
return BigInteger.ONE;
}
return BigInteger.ZERO;
}
@Override
public WriteCellData<?> convertToExcelData(BigInteger value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (BigInteger.ONE.equals(value)) {
return new WriteCellData<>(Boolean.TRUE);
}
return new WriteCellData<>(Boolean.FALSE);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/bytearray/BoxingByteArrayImageConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/bytearray/BoxingByteArrayImageConverter.java | package com.alibaba.excel.converters.bytearray;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
/**
* Boxing Byte array and image converter
*
* @author Jiaju Zhuang
*/
public class BoxingByteArrayImageConverter implements Converter<Byte[]> {
@Override
public Class<?> supportJavaTypeKey() {
return Byte[].class;
}
@Override
public WriteCellData<?> convertToExcelData(Byte[] value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
byte[] byteValue = new byte[value.length];
for (int i = 0; i < value.length; i++) {
byteValue[i] = value[i];
}
return new WriteCellData<>(byteValue);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/bytearray/ByteArrayImageConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/bytearray/ByteArrayImageConverter.java | package com.alibaba.excel.converters.bytearray;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
/**
* Byte array and image converter
*
* @author Jiaju Zhuang
*/
public class ByteArrayImageConverter implements Converter<byte[]> {
@Override
public Class<byte[]> supportJavaTypeKey() {
return byte[].class;
}
@Override
public WriteCellData<?> convertToExcelData(byte[] value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
return new WriteCellData<>(value);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/date/DateDateConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/date/DateDateConverter.java | package com.alibaba.excel.converters.date;
import java.util.Date;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.DateUtils;
import com.alibaba.excel.util.WorkBookUtil;
/**
* Date and date converter
*
* @author Jiaju Zhuang
*/
public class DateDateConverter implements Converter<Date> {
@Override
public Class<Date> supportJavaTypeKey() {
return Date.class;
}
@Override
public WriteCellData<?> convertToExcelData(Date value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) throws Exception {
WriteCellData<?> cellData = new WriteCellData<>(value);
String format = null;
if (contentProperty != null && contentProperty.getDateTimeFormatProperty() != null) {
format = contentProperty.getDateTimeFormatProperty().getFormat();
}
WorkBookUtil.fillDataFormat(cellData, format, DateUtils.defaultDateFormat);
return cellData;
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/date/DateNumberConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/date/DateNumberConverter.java | package com.alibaba.excel.converters.date;
import java.math.BigDecimal;
import java.util.Date;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.DateUtils;
import org.apache.poi.ss.usermodel.DateUtil;
/**
* Date and number converter
*
* @author Jiaju Zhuang
*/
public class DateNumberConverter implements Converter<Date> {
@Override
public Class<?> supportJavaTypeKey() {
return Date.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.NUMBER;
}
@Override
public Date convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (contentProperty == null || contentProperty.getDateTimeFormatProperty() == null) {
return DateUtils.getJavaDate(cellData.getNumberValue().doubleValue(),
globalConfiguration.getUse1904windowing());
} else {
return DateUtils.getJavaDate(cellData.getNumberValue().doubleValue(),
contentProperty.getDateTimeFormatProperty().getUse1904windowing());
}
}
@Override
public WriteCellData<?> convertToExcelData(Date value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (contentProperty == null || contentProperty.getDateTimeFormatProperty() == null) {
return new WriteCellData<>(
BigDecimal.valueOf(DateUtil.getExcelDate(value, globalConfiguration.getUse1904windowing())));
} else {
return new WriteCellData<>(BigDecimal.valueOf(
DateUtil.getExcelDate(value, contentProperty.getDateTimeFormatProperty().getUse1904windowing())));
}
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/date/DateStringConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/date/DateStringConverter.java | package com.alibaba.excel.converters.date;
import java.text.ParseException;
import java.util.Date;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.alibaba.excel.util.DateUtils;
/**
* Date and string converter
*
* @author Jiaju Zhuang
*/
public class DateStringConverter implements Converter<Date> {
@Override
public Class<?> supportJavaTypeKey() {
return Date.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.STRING;
}
@Override
public Date convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) throws ParseException {
if (contentProperty == null || contentProperty.getDateTimeFormatProperty() == null) {
return DateUtils.parseDate(cellData.getStringValue(), null);
} else {
return DateUtils.parseDate(cellData.getStringValue(),
contentProperty.getDateTimeFormatProperty().getFormat());
}
}
@Override
public WriteCellData<?> convertToExcelData(Date value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (contentProperty == null || contentProperty.getDateTimeFormatProperty() == null) {
return new WriteCellData<>(DateUtils.format(value, null));
} else {
return new WriteCellData<>(DateUtils.format(value, contentProperty.getDateTimeFormatProperty().getFormat()));
}
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
alibaba/easyexcel | https://github.com/alibaba/easyexcel/blob/aae9c61ab603c04331333782eedd2896d7bc5386/easyexcel-core/src/main/java/com/alibaba/excel/converters/integer/IntegerBooleanConverter.java | easyexcel-core/src/main/java/com/alibaba/excel/converters/integer/IntegerBooleanConverter.java | package com.alibaba.excel.converters.integer;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
/**
* Integer and boolean converter
*
* @author Jiaju Zhuang
*/
public class IntegerBooleanConverter implements Converter<Integer> {
private static final Integer ONE = 1;
private static final Integer ZERO = 0;
@Override
public Class<?> supportJavaTypeKey() {
return Integer.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.BOOLEAN;
}
@Override
public Integer convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (cellData.getBooleanValue()) {
return ONE;
}
return ZERO;
}
@Override
public WriteCellData<?> convertToExcelData(Integer value, ExcelContentProperty contentProperty,
GlobalConfiguration globalConfiguration) {
if (ONE.equals(value)) {
return new WriteCellData<>(Boolean.TRUE);
}
return new WriteCellData<>(Boolean.FALSE);
}
}
| java | Apache-2.0 | aae9c61ab603c04331333782eedd2896d7bc5386 | 2026-01-04T14:46:28.604473Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.