valuePair = Pair.of(map.get(key), escape);
52 | final String keyString = Instances.singleton(StringWriteConverter.class)
53 | .handle(keyPair);
54 | final String valueString = Instances.singleton(StringWriteConverter.class)
55 | .handle(valuePair);
56 | final String string = keyString + CsvConst.EQUALS + valueString;
57 | stringList.add(string);
58 | }
59 | return stringList;
60 | }
61 |
62 | }
63 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/convert/write/entry/EntryWriteConverter.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.convert.write.entry;
2 |
3 | import com.github.houbb.csv.annotation.Csv;
4 | import com.github.houbb.csv.api.IWriteConverter;
5 | import com.github.houbb.csv.constant.CsvConst;
6 | import com.github.houbb.csv.constant.CsvOperateType;
7 | import com.github.houbb.csv.support.context.SingleWriteContext;
8 | import com.github.houbb.csv.support.convert.mapping.WriteMappingConverter;
9 | import com.github.houbb.csv.support.convert.write.CommonWriteConverter;
10 | import com.github.houbb.csv.util.CsvFieldUtil;
11 | import com.github.houbb.csv.util.CsvInnerUtil;
12 | import com.github.houbb.heaven.annotation.ThreadSafe;
13 | import com.github.houbb.heaven.reflect.model.FieldBean;
14 | import com.github.houbb.heaven.response.exception.CommonRuntimeException;
15 | import com.github.houbb.heaven.support.instance.impl.Instances;
16 | import com.github.houbb.heaven.util.guava.Guavas;
17 | import com.github.houbb.heaven.util.lang.ObjectUtil;
18 | import com.github.houbb.heaven.util.lang.StringUtil;
19 | import com.github.houbb.heaven.util.util.CollectionUtil;
20 | import com.github.houbb.heaven.util.util.Optional;
21 |
22 | import java.util.List;
23 |
24 | /**
25 | * 针对单个对象的信息构建
26 | * （1）必须为对象
27 | * （2）必须为用户自定义对象
28 | *
29 | * 1. array
30 | * 2. 集合
31 | * 3. map
32 | * 4. 对象
33 | * 5. 其他对象
34 | *
35 | * @author binbin.hou
36 | * @since 0.0.4
37 | */
38 | @ThreadSafe
39 | public class EntryWriteConverter implements IWriteConverter {
40 |
41 | @Override
42 | public String convert(SingleWriteContext context) {
43 | final Object value = context.element();
44 | if (ObjectUtil.isNull(value)) {
45 | return StringUtil.EMPTY;
46 | }
47 |
48 | // 获取字段信息
49 | Class clazz = value.getClass();
50 | List fieldBeanList = CsvFieldUtil.getSortedFields(clazz, context.sort(), CsvOperateType.WRITE);
51 | if (CollectionUtil.isEmpty(fieldBeanList)) {
52 | return StringUtil.EMPTY;
53 | }
54 |
55 | return buildWriteLine(context, value, fieldBeanList);
56 | }
57 |
58 | /**
59 | * 构建待写行
60 | * 1. 将需要写入的字段内容用逗号分隔。
61 | *
62 | * @param context 上下文
63 | * @param t 元素
64 | * @param fieldBeans 字段列表
65 | * @return 结果
66 | */
67 | private String buildWriteLine(final SingleWriteContext context,
68 | final Object t, final List fieldBeans) {
69 | if (ObjectUtil.isNull(t)) {
70 | return StringUtil.EMPTY;
71 | }
72 |
73 | List stringList = Guavas.newArrayList(fieldBeans.size());
74 | // 默认使用通用转换
75 | IWriteConverter converter = Instances.singleton(CommonWriteConverter.class);
76 | try {
77 | for (FieldBean bean : fieldBeans) {
78 | final Object object = bean.field().get(t);
79 | // 上下文的处理
80 | SingleWriteContext entryContext = SingleWriteContext.newInstance()
81 | .value(object)
82 | .field(bean.field())
83 | .element(t)
84 | .sort(context.sort())
85 | .split(CsvConst.COMMA)
86 | .escape(context.escape());
87 |
88 | final Optional csvOptional = bean.annotationOptByType(Csv.class);
89 | if (csvOptional.isPresent()) {
90 | Csv csv = csvOptional.get();
91 | entryContext.csv(csv);
92 | converter = csv.writeConverter().newInstance();
93 |
94 | // 优先使用 writeMapping
95 | if(StringUtil.isNotEmpty(csv.writeMapping())
96 | && (object instanceof String)) {
97 | converter = new WriteMappingConverter();
98 | }
99 | }
100 |
101 | String string = converter.convert(entryContext);
102 | stringList.add(string);
103 | }
104 | } catch (InstantiationException | IllegalAccessException e) {
105 | throw new CommonRuntimeException(e);
106 | }
107 |
108 | return CollectionUtil.join(stringList, context.split());
109 | }
110 |
111 | }
112 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/convert/write/package-info.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.convert.write;
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/csv/DefaultCsv.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.csv;
2 |
3 | import com.github.houbb.csv.annotation.Csv;
4 | import com.github.houbb.csv.api.ICsv;
5 | import com.github.houbb.csv.api.IReadContext;
6 | import com.github.houbb.csv.api.IWriteContext;
7 | import com.github.houbb.csv.constant.CsvConst;
8 | import com.github.houbb.csv.constant.CsvOperateType;
9 | import com.github.houbb.csv.support.context.SingleReadContext;
10 | import com.github.houbb.csv.support.context.SingleWriteContext;
11 | import com.github.houbb.csv.support.convert.read.entry.EntryReadConverter;
12 | import com.github.houbb.csv.support.convert.write.entry.EntryWriteConverter;
13 | import com.github.houbb.csv.support.writer.ICsvWriter;
14 | import com.github.houbb.csv.support.writer.impl.CsvWriterContext;
15 | import com.github.houbb.csv.util.CsvFieldUtil;
16 | import com.github.houbb.heaven.annotation.ThreadSafe;
17 | import com.github.houbb.heaven.constant.PunctuationConst;
18 | import com.github.houbb.heaven.reflect.model.FieldBean;
19 | import com.github.houbb.heaven.util.guava.Guavas;
20 | import com.github.houbb.heaven.util.lang.StringUtil;
21 | import com.github.houbb.heaven.util.util.CollectionUtil;
22 | import com.github.houbb.heaven.util.util.MapUtil;
23 | import com.github.houbb.heaven.util.util.Optional;
24 |
25 | import java.util.Collection;
26 | import java.util.Collections;
27 | import java.util.List;
28 | import java.util.Map;
29 |
30 | /**
31 | * 默认的 csv 处理实现
32 | *
33 | * @param 泛型
34 | * @author binbin.hou
35 | * @since 0.0.1
36 | */
37 | @ThreadSafe
38 | public class DefaultCsv implements ICsv {
39 |
40 | @Override
41 | public List write(IWriteContext context) {
42 | final List writeList = context.list();
43 | if (CollectionUtil.isEmpty(writeList)) {
44 | return Collections.emptyList();
45 | }
46 | final Optional firstOpt = CollectionUtil.firstNotNullElem(writeList);
47 | if (firstOpt.isNotPresent()) {
48 | return Collections.emptyList();
49 | }
50 | final T elem = firstOpt.get();
51 | final List fieldBeanList = CsvFieldUtil.getSortedFields(elem.getClass(),
52 | context.sort(), CsvOperateType.WRITE);
53 | if (CollectionUtil.isEmpty(fieldBeanList)) {
54 | return Collections.emptyList();
55 | }
56 |
57 | // 2.1 存储字符串列表
58 | final int size = context.list().size();
59 | List list = Guavas.newArrayList(size);
60 |
61 | // 2.2 构建每一行的内容
62 | EntryWriteConverter entryWriteConverter = new EntryWriteConverter();
63 | SingleWriteContext singleWriteContext = SingleWriteContext.newInstance()
64 | .sort(context.sort())
65 | .escape(context.escape())
66 | .split(CsvConst.COMMA);
67 | for (T t : writeList) {
68 | singleWriteContext.element(t);
69 |
70 | final String writeLine = entryWriteConverter.convert(singleWriteContext);
71 | if (StringUtil.isEmpty(writeLine)) {
72 | continue;
73 | }
74 | list.add(writeLine);
75 | }
76 |
77 | // 2.3 处理字符串列表
78 | final ICsvWriter csvWriter = context.writer();
79 | final CsvWriterContext csvWriterContext = CsvWriterContext.newInstance()
80 | .writeBom(context.writeBom())
81 | .writeHead(context.writeHead())
82 | .list(list);
83 |
84 | // 2.4 写入头信息
85 | final boolean needWriteHead = context.writeHead();
86 | if (needWriteHead) {
87 | // 只有需要写入时，才进行计算。
88 | String headLine = buildWriteHead(fieldBeanList);
89 | csvWriterContext.head(headLine);
90 | }
91 |
92 | //2.5 执行写入
93 | csvWriter.write(csvWriterContext);
94 |
95 | //3. 返回结果列表
96 | return list;
97 | }
98 |
99 | /**
100 | * 构建表头
101 | * （1）指定注解，且 label 不为空，则使用 label
102 | * （2）使用 field.name()
103 | *
104 | * 所有字段 label 通过逗号连接。
105 | *
106 | * @param fieldBeanList 元素列表
107 | * @return 对应的 head 字符串
108 | */
109 | private String buildWriteHead(List fieldBeanList) {
110 | Collection headList = Guavas.newArrayList(fieldBeanList.size());
111 |
112 | for (FieldBean bean : fieldBeanList) {
113 | String name = bean.name();
114 | Optional csvOptional = bean.annotationOptByType(Csv.class);
115 | if (csvOptional.isPresent()) {
116 | String label = csvOptional.get().label();
117 | if (StringUtil.isNotEmpty(label)) {
118 | name = label;
119 | }
120 | }
121 |
122 | headList.add(name);
123 | }
124 | return StringUtil.join(headList, PunctuationConst.COMMA);
125 | }
126 |
127 | @Override
128 | public List read(IReadContext context) {
129 | // 1. 构建字段和下标之间的映射关系。
130 | Map readMapping = CsvFieldUtil.getReadMapping(context.readClass(), context.sort());
131 | if (MapUtil.isEmpty(readMapping)) {
132 | return Collections.emptyList();
133 | }
134 |
135 | //2. 文件内容
136 | List allLines = context.reader().read();
137 | List readableLines = CollectionUtil.subList(allLines,
138 | context.startIndex(), context.endIndex());
139 | if (CollectionUtil.isEmpty(readableLines)) {
140 | return Collections.emptyList();
141 | }
142 |
143 | //3. 映射处理
144 | List list = Guavas.newArrayList(readableLines.size());
145 | final Class readClass = context.readClass();
146 | final EntryReadConverter readConverter = new EntryReadConverter<>();
147 |
148 | // 单行的上下文，使用同一个对象，节约内存及堆开销
149 | SingleReadContext singleReadContext = new SingleReadContext();
150 | singleReadContext
151 | .classType(readClass)
152 | .sort(context.sort())
153 | .split(CsvConst.COMMA)
154 | .escape(context.escape());
155 | for (String line : readableLines) {
156 | // 跳过空白行
157 | if (StringUtil.isEmpty(line)) {
158 | continue;
159 | }
160 |
161 | // 设置对象内容
162 | singleReadContext.value(line);
163 | T instance = readConverter.convert(singleReadContext);
164 | list.add(instance);
165 | }
166 | return list;
167 | }
168 |
169 | }
170 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/csv/DefaultStringListCsv.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.csv;
2 |
3 | import com.github.houbb.csv.api.ICsv;
4 | import com.github.houbb.csv.api.IReadContext;
5 | import com.github.houbb.csv.api.IWriteContext;
6 | import com.github.houbb.csv.support.writer.ICsvWriter;
7 | import com.github.houbb.csv.support.writer.impl.CsvWriterContext;
8 | import com.github.houbb.heaven.annotation.ThreadSafe;
9 | import com.github.houbb.heaven.util.guava.Guavas;
10 | import com.github.houbb.heaven.util.lang.StringUtil;
11 | import com.github.houbb.heaven.util.util.CollectionUtil;
12 |
13 | import java.util.*;
14 | import java.util.regex.Matcher;
15 | import java.util.regex.Pattern;
16 |
17 | /**
18 | * 处理为 list
19 | *
20 | * @author binbin.hou
21 | * @since 0.2.0
22 | */
23 | @ThreadSafe
24 | public class DefaultStringListCsv implements ICsv> {
25 |
26 | @Override
27 | public List write(IWriteContext> context) {
28 | final List> writeList = context.list();
29 | if (CollectionUtil.isEmpty(writeList)
30 | || writeList.size() <= 0) {
31 | return Collections.emptyList();
32 | }
33 |
34 | // 2.1 存储字符串列表
35 | final int size = context.list().size();
36 | List list = Guavas.newArrayList(size);
37 |
38 | // 2.2 构建每一行的内容
39 | final char quoteChar = context.quoteChar();
40 | for (int i = 1; i < writeList.size(); i++) {
41 | List t = writeList.get(i);
42 |
43 | String writeLine = joinCsvLine(t, quoteChar);
44 | if (StringUtil.isEmpty(writeLine)) {
45 | continue;
46 | }
47 | list.add(writeLine);
48 | }
49 |
50 | // 2.3 处理字符串列表
51 | final ICsvWriter csvWriter = context.writer();
52 | final CsvWriterContext csvWriterContext = CsvWriterContext.newInstance()
53 | .writeBom(context.writeBom())
54 | .writeHead(context.writeHead())
55 | .list(list);
56 |
57 | // 2.4 写入头信息
58 | final boolean needWriteHead = context.writeHead();
59 | if (needWriteHead) {
60 | // 只有需要写入时，才进行计算。
61 | String headLine = joinCsvLine(writeList.get(0), quoteChar);
62 | csvWriterContext.head(headLine);
63 | }
64 |
65 | //2.5 执行写入
66 | csvWriter.write(csvWriterContext);
67 |
68 | //3. 返回结果列表
69 | return list;
70 | }
71 |
72 | @Override
73 | public List> read(IReadContext> context) {
74 | //2. 文件内容
75 | List allLines = context.reader().read();
76 | List readableLines = CollectionUtil.subList(allLines,
77 | context.startIndex(), context.endIndex());
78 | if (CollectionUtil.isEmpty(readableLines)) {
79 | return Collections.emptyList();
80 | }
81 |
82 | final char quoteChar = context.quoteChar();
83 | List> resultList = new ArrayList<>();
84 | for (String line : readableLines) {
85 | // 跳过空白行
86 | if (StringUtil.isEmpty(line)) {
87 | continue;
88 | }
89 |
90 | // 设置对象内容
91 | List lineSplit = splitCsvLine(line, quoteChar);
92 | resultList.add(lineSplit);
93 | }
94 |
95 | return resultList;
96 | }
97 |
98 | protected String joinCsvLine(List splitList, char quoteChar) {
99 | //fast-fail
100 | if(CollectionUtil.isEmpty(splitList)) {
101 | return "";
102 | }
103 |
104 | StringBuilder stringBuilder = new StringBuilder();
105 |
106 |
107 | for(int i = 0; i < splitList.size()-1; i++) {
108 | String field = splitList.get(i);
109 | String escapedField = getJoinEscapeField(field, quoteChar);
110 |
111 | stringBuilder.append(escapedField)
112 | .append(",");
113 | }
114 |
115 | String lastField = splitList.get(splitList.size()-1);
116 | String escapedField = getJoinEscapeField(lastField, quoteChar);
117 | stringBuilder.append(escapedField);
118 | return stringBuilder.toString();
119 | }
120 |
121 | protected String getJoinEscapeField(String field, char quoteChar) {
122 | if(field.contains(",")) {
123 | return quoteChar + field + quoteChar;
124 | }
125 | return field;
126 | }
127 |
128 | protected List splitCsvLine(String csvData, char quoteChar) {
129 | List result = new ArrayList<>();
130 |
131 | // 定义 CSV 数据的正则表达式
132 | String regex = "(?:" + // 开始非捕获组
133 | "([^" + quoteChar + ",]+)" + // 匹配非引号非逗号的内容
134 | "|\"" + // 或匹配引号开头的内容
135 | "([^" + quoteChar + "]*)\"" + // 匹配引号中的内容
136 | ")";
137 |
138 | Pattern pattern = Pattern.compile(regex);
139 | Matcher matcher = pattern.matcher(csvData);
140 |
141 | while (matcher.find()) {
142 | String field = matcher.group(1) != null ? matcher.group(1) : matcher.group(2);
143 | result.add(field);
144 | }
145 |
146 | return result;
147 | }
148 |
149 | }
150 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/csv/package-info.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.csv;
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/package-info.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support;
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/reader/ICsvReader.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.reader;
2 |
3 | import com.github.houbb.heaven.annotation.CommonEager;
4 |
5 | import java.util.List;
6 |
7 | /**
8 | * 可以抽象为 readers
9 | *
10 | * 1. readString
11 | * 2. readLines
12 | * @author binbin.hou
13 | * @since 0.0.8
14 | */
15 | @CommonEager
16 | public interface ICsvReader {
17 |
18 | /**
19 | * 读取内容
20 | * @return 结果
21 | * @since 0.0.8
22 | */
23 | List read();
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/reader/impl/CsvReaderFile.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.reader.impl;
2 |
3 | import com.github.houbb.csv.support.reader.ICsvReader;
4 | import com.github.houbb.heaven.annotation.ThreadSafe;
5 | import com.github.houbb.heaven.constant.CharsetConst;
6 | import com.github.houbb.heaven.util.io.FileUtil;
7 |
8 | import java.io.File;
9 | import java.util.List;
10 |
11 | /**
12 | * @author binbin.hou
13 | * @since 0.0.8
14 | */
15 | @ThreadSafe
16 | public class CsvReaderFile implements ICsvReader {
17 |
18 | /**
19 | * 文件信息
20 | * @since 0.0.8
21 | */
22 | private final File file;
23 |
24 | /**
25 | * 文件编码
26 | * @since 0.0.8
27 | */
28 | private final String charset;
29 |
30 | public CsvReaderFile(File file, String charset) {
31 | this.file = file;
32 | this.charset = charset;
33 | }
34 |
35 | public CsvReaderFile(File file) {
36 | this(file, CharsetConst.UTF8);
37 | }
38 |
39 | /**
40 | * 读取内容
41 | *
42 | * @return 结果
43 | * @since 0.0.8
44 | */
45 | @Override
46 | public List read() {
47 | return FileUtil.readAllLines(file, charset);
48 | }
49 |
50 | }
51 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/reader/impl/CsvReaderFilePath.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.reader.impl;
2 |
3 | import com.github.houbb.csv.support.reader.ICsvReader;
4 | import com.github.houbb.heaven.annotation.ThreadSafe;
5 | import com.github.houbb.heaven.constant.CharsetConst;
6 | import com.github.houbb.heaven.util.io.FileUtil;
7 |
8 | import java.util.List;
9 |
10 | /**
11 | * @author binbin.hou
12 | * @since 0.0.8
13 | */
14 | @ThreadSafe
15 | public class CsvReaderFilePath implements ICsvReader {
16 |
17 | /**
18 | * 文件路径信息
19 | * @since 0.0.8
20 | */
21 | private final String filePath;
22 |
23 | /**
24 | * 文件编码
25 | * @since 0.0.8
26 | */
27 | private final String charset;
28 |
29 | public CsvReaderFilePath(String filePath, String charset) {
30 | this.filePath = filePath;
31 | this.charset = charset;
32 | }
33 |
34 | public CsvReaderFilePath(String filePath) {
35 | this(filePath, CharsetConst.UTF8);
36 | }
37 |
38 | /**
39 | * 读取内容
40 | *
41 | * @return 结果
42 | * @since 0.0.8
43 | */
44 | @Override
45 | public List read() {
46 | return FileUtil.readAllLines(filePath, charset);
47 | }
48 |
49 | }
50 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/reader/impl/CsvReaderInputStream.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.reader.impl;
2 |
3 | import com.github.houbb.csv.support.reader.ICsvReader;
4 | import com.github.houbb.heaven.annotation.ThreadSafe;
5 | import com.github.houbb.heaven.constant.CharsetConst;
6 | import com.github.houbb.heaven.util.io.FileUtil;
7 |
8 | import java.io.InputStream;
9 | import java.util.List;
10 |
11 | /**
12 | * 输入流
13 | * @author binbin.hou
14 | * @since 0.0.8
15 | */
16 | @ThreadSafe
17 | public class CsvReaderInputStream implements ICsvReader {
18 |
19 | /**
20 | * 输入流
21 | * @since 0.0.8
22 | */
23 | private final InputStream inputStream;
24 |
25 | /**
26 | * 编码
27 | * @since 0.0.8
28 | */
29 | private final String charset;
30 |
31 | public CsvReaderInputStream(InputStream inputStream, String charset) {
32 | this.inputStream = inputStream;
33 | this.charset = charset;
34 | }
35 |
36 | public CsvReaderInputStream(InputStream inputStream) {
37 | this(inputStream, CharsetConst.UTF8);
38 | }
39 |
40 | /**
41 | * 读取内容
42 | *
43 | * @return 结果
44 | * @since 0.0.8
45 | */
46 | @Override
47 | public List read() {
48 | return FileUtil.readAllLines(inputStream, charset);
49 | }
50 |
51 | }
52 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/reader/impl/CsvReaderList.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.reader.impl;
2 |
3 | import com.github.houbb.csv.support.reader.ICsvReader;
4 | import com.github.houbb.heaven.annotation.ThreadSafe;
5 |
6 | import java.util.List;
7 |
8 | /**
9 | * @author binbin.hou
10 | * @since 0.0.8
11 | */
12 | @ThreadSafe
13 | public class CsvReaderList implements ICsvReader {
14 |
15 | /**
16 | * 字符串列表
17 | * @since 0.0.8
18 | */
19 | private final List strings;
20 |
21 | public CsvReaderList(List strings) {
22 | this.strings = strings;
23 | }
24 |
25 | /**
26 | * 读取内容
27 | *
28 | * @return 结果
29 | * @since 0.0.8
30 | */
31 | @Override
32 | public List read() {
33 | return strings;
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/reader/impl/CsvReaders.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.reader.impl;
2 |
3 | import com.github.houbb.csv.support.reader.ICsvReader;
4 | import com.github.houbb.heaven.annotation.CommonEager;
5 |
6 | import java.io.File;
7 | import java.io.InputStream;
8 | import java.util.List;
9 |
10 | /**
11 | * @author binbin.hou
12 | * @since 0.0.8
13 | */
14 | @CommonEager
15 | public final class CsvReaders {
16 |
17 | private CsvReaders(){}
18 |
19 | /**
20 | * 基于字符串列表的处理
21 | * @param lines 字符串列表
22 | * @return 结果信息
23 | * @since 0.0.8
24 | */
25 | public static ICsvReader list(final List lines) {
26 | return new CsvReaderList(lines);
27 | }
28 |
29 | /**
30 | * 基于字符串列表的处理
31 | * @param file 文件信息
32 | * @param charset 文件编码
33 | * @return 结果信息
34 | * @since 0.0.8
35 | */
36 | public static ICsvReader file(final File file,
37 | final String charset) {
38 | return new CsvReaderFile(file, charset);
39 | }
40 |
41 | /**
42 | * 基于字符串列表的处理
43 | * @param file 文件信息
44 | * @return 结果信息
45 | * @since 0.0.8
46 | */
47 | public static ICsvReader file(final File file) {
48 | return new CsvReaderFile(file);
49 | }
50 |
51 | /**
52 | * 基于文件路径的处理
53 | * @param file 文件信息
54 | * @param charset 文件编码
55 | * @return 结果信息
56 | * @since 0.0.8
57 | */
58 | public static ICsvReader filePath(final String file,
59 | final String charset) {
60 | return new CsvReaderFilePath(file, charset);
61 | }
62 |
63 | /**
64 | * 基于文件路径的处理
65 | * @param file 文件信息
66 | * @return 结果信息
67 | * @since 0.0.8
68 | */
69 | public static ICsvReader filePath(final String file) {
70 | return new CsvReaderFilePath(file);
71 | }
72 |
73 | /**
74 | * 基于文件输入流的处理
75 | * @param inputStream 文件输入流
76 | * @param charset 文件编码
77 | * @return 结果信息
78 | * @since 0.0.8
79 | */
80 | public static ICsvReader inputStream(final InputStream inputStream,
81 | final String charset) {
82 | return new CsvReaderInputStream(inputStream, charset);
83 | }
84 |
85 | /**
86 | * 基于文件输入流的处理
87 | * @param inputStream 文件输入流
88 | * @return 结果信息
89 | * @since 0.0.8
90 | */
91 | public static ICsvReader inputStream(final InputStream inputStream) {
92 | return new CsvReaderInputStream(inputStream);
93 | }
94 |
95 | }
96 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/reader/package-info.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.reader;
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/writer/ICsvWriter.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.writer;
2 |
3 | /**
4 | * @author binbin.hou
5 | * @since 0.0.8
6 | */
7 | public interface ICsvWriter {
8 |
9 | /**
10 | * 针对字符串列表的写入
11 | * @param context 写入上下文
12 | * @since 0.0.8
13 | */
14 | void write(final ICsvWriterContext context);
15 |
16 | }
17 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/writer/ICsvWriterContext.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.writer;
2 |
3 | import java.util.List;
4 |
5 | /**
6 | * 写入上下文
7 | * @author binbin.hou
8 | * @since 0.0.9
9 | */
10 | public interface ICsvWriterContext {
11 |
12 | /**
13 | * 是否写入标题头
14 | * @return 是否写入 head 行
15 | * @since 0.0.9
16 | */
17 | boolean writeHead();
18 |
19 | /**
20 | * 是否写入 bom 头
21 | * @return 是否
22 | * @since 0.0.9
23 | */
24 | boolean writeBom();
25 |
26 | /**
27 | * 头信息
28 | * @return 头信息
29 | * @since 0.0.9
30 | */
31 | String head();
32 |
33 | /**
34 | * 待写入的字符串列表
35 | * @return 列表
36 | * @since 0.0.9
37 | */
38 | List list();
39 |
40 | }
41 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/writer/impl/CsvWriterConsole.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.writer.impl;
2 |
3 | import com.github.houbb.csv.support.writer.ICsvWriter;
4 | import com.github.houbb.csv.support.writer.ICsvWriterContext;
5 | import com.github.houbb.heaven.annotation.ThreadSafe;
6 |
7 | import java.util.List;
8 |
9 | /**
10 | * 控台输出，主要用于调试和自测
11 | * @author binbin.hou
12 | * @since 0.0.8
13 | */
14 | @ThreadSafe
15 | public class CsvWriterConsole implements ICsvWriter {
16 |
17 | /**
18 | * 针对字符串列表的写入
19 | *
20 | * @param context 上下文
21 | * @since 0.0.8
22 | */
23 | @Override
24 | public void write(final ICsvWriterContext context) {
25 | //do nothing
26 | List list = context.list();
27 | for(String line : list) {
28 | System.out.println(line);
29 | }
30 | }
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/writer/impl/CsvWriterContext.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.writer.impl;
2 |
3 | import com.github.houbb.csv.support.writer.ICsvWriterContext;
4 |
5 | import java.util.List;
6 |
7 | /**
8 | * @author binbin.hou
9 | * @since 0.0.9
10 | */
11 | public class CsvWriterContext implements ICsvWriterContext {
12 |
13 | /**
14 | * 是否写入标题头
15 | * @since 0.0.9
16 | */
17 | private boolean writeHead;
18 |
19 | /**
20 | * 是否写入 bom 头
21 | * @since 0.0.9
22 | */
23 | private boolean writeBom;
24 |
25 | /**
26 | * 头信息
27 | * @since 0.0.9
28 | */
29 | private String head;
30 |
31 | /**
32 | * 待写入的字符串列表
33 | * @since 0.0.9
34 | */
35 | private List list;
36 |
37 | /**
38 | * 新建实例
39 | * @return this
40 | * @since 0.0.9
41 | */
42 | public static CsvWriterContext newInstance() {
43 | return new CsvWriterContext();
44 | }
45 |
46 | @Override
47 | public boolean writeHead() {
48 | return writeHead;
49 | }
50 |
51 | public CsvWriterContext writeHead(boolean writeHead) {
52 | this.writeHead = writeHead;
53 | return this;
54 | }
55 |
56 | @Override
57 | public boolean writeBom() {
58 | return writeBom;
59 | }
60 |
61 | public CsvWriterContext writeBom(boolean writeBom) {
62 | this.writeBom = writeBom;
63 | return this;
64 | }
65 |
66 | @Override
67 | public String head() {
68 | return head;
69 | }
70 |
71 | public CsvWriterContext head(String head) {
72 | this.head = head;
73 | return this;
74 | }
75 |
76 | @Override
77 | public List list() {
78 | return list;
79 | }
80 |
81 | public CsvWriterContext list(List list) {
82 | this.list = list;
83 | return this;
84 | }
85 | }
86 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/writer/impl/CsvWriterFilePath.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.writer.impl;
2 |
3 | import com.github.houbb.csv.exception.CsvException;
4 | import com.github.houbb.csv.support.writer.ICsvWriter;
5 | import com.github.houbb.csv.support.writer.ICsvWriterContext;
6 | import com.github.houbb.csv.util.CsvBomUtil;
7 | import com.github.houbb.heaven.annotation.ThreadSafe;
8 | import com.github.houbb.heaven.constant.CharsetConst;
9 |
10 | import java.io.File;
11 | import java.io.IOException;
12 | import java.nio.charset.Charset;
13 | import java.nio.file.Files;
14 | import java.nio.file.Path;
15 | import java.nio.file.Paths;
16 | import java.nio.file.StandardOpenOption;
17 | import java.util.List;
18 |
19 | /**
20 | * 控台输出，主要用于调试和自测
21 | * @author binbin.hou
22 | * @since 0.0.8
23 | */
24 | @ThreadSafe
25 | public class CsvWriterFilePath implements ICsvWriter {
26 |
27 | /**
28 | * 文件路径
29 | * @since 0.0.8
30 | */
31 | private final String filePath;
32 |
33 | /**
34 | * 文件编码
35 | * @since 0.0.8
36 | */
37 | private final String charset;
38 |
39 | public CsvWriterFilePath(String filePath, String charset) {
40 | this.filePath = filePath;
41 | this.charset = charset;
42 | }
43 |
44 | public CsvWriterFilePath(String filePath) {
45 | this(filePath, CharsetConst.UTF8);
46 | }
47 |
48 | /**
49 | * 针对字符串列表的写入
50 | *
51 | * @param context 上下文
52 | * @since 0.0.8
53 | */
54 | @Override
55 | public void write(final ICsvWriterContext context) {
56 | try {
57 | // 父类文件夹创建
58 | //2. 统一写入文件
59 | // 默认使用添加的方式写入，后期再开放这个开关
60 | Path path = Paths.get(filePath);
61 | //2.1 创建父类文件夹
62 | File parent = path.getParent().toFile();
63 | if (!parent.exists()) {
64 | boolean result = parent.mkdirs();
65 | if(!result) {
66 | throw new CsvException("File mkdirs failed!");
67 | }
68 | }
69 | //2.2 创建文件
70 | File file = path.toFile();
71 | if (!file.exists()) {
72 | boolean result = file.createNewFile();
73 | if(!result) {
74 | throw new CsvException("File create failed!");
75 | }
76 | }
77 |
78 | //2.3 写入（首先记录状态，然后写入信息）
79 | // 2.3.1 写入 bom 头(默认清空文件内容)
80 | // 只有文件为空时才进行写入
81 | final byte[] bomBytes = CsvBomUtil.getBom(charset);
82 | boolean needWriteBoom = context.writeBom() && file.length() <= 0;
83 | if (needWriteBoom) {
84 | Files.write(path, bomBytes, StandardOpenOption.APPEND);
85 | }
86 |
87 | // 2.4 写入头信息
88 | final List writeList = context.list();
89 | // 只有头信息不存在时，才重复写入头信息。
90 | boolean needWriteHead = context.writeHead() && file.length() <= bomBytes.length;
91 | if(needWriteHead) {
92 | writeList.add(0, context.head());
93 | }
94 |
95 | //2.5 新增的方式写入内容
96 | Files.write(path, writeList, Charset.forName(charset), StandardOpenOption.APPEND);
97 | } catch (IOException e) {
98 | throw new CsvException(e);
99 | }
100 | }
101 |
102 | }
103 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/writer/impl/CsvWriterNone.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.writer.impl;
2 |
3 | import com.github.houbb.csv.support.writer.ICsvWriter;
4 | import com.github.houbb.csv.support.writer.ICsvWriterContext;
5 | import com.github.houbb.heaven.annotation.ThreadSafe;
6 |
7 | /**
8 | * @author binbin.hou
9 | * @since 0.0.8
10 | */
11 | @ThreadSafe
12 | public class CsvWriterNone implements ICsvWriter {
13 |
14 | /**
15 | * 针对字符串列表的写入
16 | *
17 | * @param context 上下文
18 | * @since 0.0.8
19 | */
20 | @Override
21 | public void write(final ICsvWriterContext context) {
22 | //do nothing
23 | }
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/support/writer/impl/CsvWriters.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.support.writer.impl;
2 |
3 | import com.github.houbb.csv.support.writer.ICsvWriter;
4 | import com.github.houbb.heaven.constant.CharsetConst;
5 | import com.github.houbb.heaven.support.instance.impl.Instances;
6 |
7 | /**
8 | * 控台输出，主要用于调试和自测
9 | * @author binbin.hou
10 | * @since 0.0.8
11 | */
12 | public final class CsvWriters {
13 |
14 | private CsvWriters(){}
15 |
16 | /**
17 | * 什么都不做
18 | * @return 实现
19 | * @since 0.0.8
20 | */
21 | public static ICsvWriter none() {
22 | return Instances.singleton(CsvWriterNone.class);
23 | }
24 |
25 | /**
26 | * 命令行输出
27 | * @return 实现
28 | * @since 0.0.8
29 | */
30 | public static ICsvWriter console() {
31 | return Instances.singleton(CsvWriterConsole.class);
32 | }
33 |
34 | /**
35 | * 文件输出
36 | * @param filePath 文件路径
37 | * @param charset 文件编码
38 | * @return 实现
39 | * @since 0.0.8
40 | */
41 | public static ICsvWriter filePath(final String filePath,
42 | final String charset) {
43 | return new CsvWriterFilePath(filePath, charset);
44 | }
45 |
46 | /**
47 | * 文件输出
48 | * @param filePath 文件路径
49 | * @return 实现
50 | * @since 0.0.8
51 | */
52 | public static ICsvWriter filePath(final String filePath) {
53 | return new CsvWriterFilePath(filePath, CharsetConst.UTF8);
54 | }
55 |
56 | }
57 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/util/CsvBomUtil.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.util;
2 |
3 | import java.nio.charset.StandardCharsets;
4 |
5 | /**
6 | * Bom 工具类
7 | * 针对常见的编码 bom 进行整理，避免 windows 打开 csv 乱码。
8 | *
9 | * 注意：一般 windows 默认使用（Little Endian）
10 | * @author binbin.hou
11 | * @since 0.0.4
12 | */
13 | public final class CsvBomUtil {
14 |
15 | private CsvBomUtil(){}
16 |
17 | /**
18 | * UTF8_BOM 行信息，避免 excel 打开乱码
19 | */
20 | private static final byte[] UTF8_BOM = new byte[]{(byte) 0xEF, (byte) 0xBB, (byte) 0xBF};
21 |
22 | /**
23 | * UTF-16（大端序）
24 | */
25 | private static final byte[] UTF16_BIG_BOM = new byte[]{(byte) 0xFE, (byte) 0xFF};
26 |
27 | /**
28 | * UTF-16（小端序）
29 | */
30 | private static final byte[] UTF16_LITTLE_BOM = new byte[]{(byte) 0xFF, (byte) 0xFE};
31 |
32 | /**
33 | * UTF-32（大端序）
34 | */
35 | private static final byte[] UTF32_BIG_BOM = new byte[]{(byte) 0x00, (byte) 0x00, (byte) 0xFE, (byte) 0xFF};
36 |
37 | /**
38 | * UTF-32（小端序）
39 | */
40 | private static final byte[] UTF32_LITTLE_BOM = new byte[]{(byte) 0xFF, (byte) 0xFE, (byte) 0x00, (byte) 0x00};
41 |
42 | /**
43 | * UTF-7
44 | * 2B 2F 76和以下的一个字节：[ 38 | 39 | 2B | 2F ]
45 | */
46 | private static final byte[] UTF7_BOM = new byte[]{(byte) 0x2B, (byte) 0x2F, (byte) 0x76, (byte) 0x38};
47 |
48 |
49 | /**
50 | * UTF-1
51 | * F7 64 4C
52 | */
53 | private static final byte[] UTF1_BOM = new byte[]{(byte) 0xF7, (byte) 0x64, (byte) 0x4C};
54 |
55 | /**
56 | * en:UTF-EBCDIC
57 | * DD 73 66 73
58 | */
59 | private static final byte[] UTF_EBCDIC_BOM = new byte[]{(byte) 0xDD, (byte) 0x73, (byte) 0x66, (byte) 0x73};
60 |
61 | /**
62 | * en:Standard Compression Scheme for Unicode
63 | * 0E FE FF
64 | */
65 | private static final byte[] SCSFU_BOM = new byte[]{(byte) 0x0E, (byte) 0xFE, (byte) 0xFF};
66 |
67 | /**
68 | * en:BOCU-1
69 | * FB EE 28及可能跟随着FF
70 | */
71 | private static final byte[] BOCU1_BOM = new byte[]{(byte) 0xFB, (byte) 0xEE, (byte) 0x28};
72 |
73 | /**
74 | * GB-18030
75 | * 84 31 95 33
76 | */
77 | private static final byte[] GB_18030_BOM = new byte[]{(byte) 0x84, (byte) 0x31, (byte) 0x95, (byte) 0x33};
78 |
79 | /**
80 | * 获取对应的 bom 头
81 | * @param charset 编码
82 | * @return 结果信息
83 | */
84 | public static byte[] getBom(final String charset) {
85 | if(StandardCharsets.UTF_8.name().equals(charset)) {
86 | return UTF8_BOM;
87 | }
88 | return new byte[]{};
89 | }
90 |
91 | }
92 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/util/CsvFieldUtil.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.util;
2 |
3 | import com.github.houbb.csv.annotation.Csv;
4 | import com.github.houbb.csv.annotation.CsvEntry;
5 | import com.github.houbb.csv.constant.CsvOperateType;
6 | import com.github.houbb.heaven.constant.PunctuationConst;
7 | import com.github.houbb.heaven.reflect.model.FieldBean;
8 | import com.github.houbb.heaven.support.sort.ISort;
9 | import com.github.houbb.heaven.util.guava.Guavas;
10 | import com.github.houbb.heaven.util.lang.reflect.ClassTypeUtil;
11 | import com.github.houbb.heaven.util.lang.reflect.ClassUtil;
12 | import com.github.houbb.heaven.util.lang.reflect.ReflectFieldUtil;
13 | import com.github.houbb.heaven.util.util.CollectionUtil;
14 | import com.github.houbb.heaven.util.util.MapUtil;
15 |
16 | import java.lang.reflect.Field;
17 | import java.util.Collections;
18 | import java.util.List;
19 | import java.util.Map;
20 | import java.util.concurrent.ConcurrentHashMap;
21 |
22 | /**
23 | * CSV 字段工具类
24 | * @author binbin.hou
25 | * @since 0.0.4
26 | */
27 | public final class CsvFieldUtil {
28 |
29 | private CsvFieldUtil(){}
30 |
31 | /**
32 | * 本地缓存
33 | * key: class.fullName + type
34 | */
35 | private static final Map> CACHE = new ConcurrentHashMap<>();
36 |
37 | /**
38 | * 获取排序后的字段
39 | *
40 | * @param tClass 类
41 | * @param sort 排序
42 | * @param type 操作方式
43 | * @return 列表
44 | */
45 | public static List getSortedFields(final Class tClass,
46 | final ISort sort,
47 | final CsvOperateType type) {
48 | final String cacheKey = buildCacheKey(tClass, type);
49 | if(CACHE.containsKey(cacheKey)) {
50 | return CACHE.get(cacheKey);
51 | }
52 |
53 | List resultList = Guavas.newArrayList();
54 | List allFields = ClassUtil.getAllFieldList(tClass);
55 | if (CollectionUtil.isEmpty(allFields)) {
56 | resultList = Collections.emptyList();
57 | }
58 |
59 | //sort
60 | List sortedFields = sort.sort(allFields);
61 |
62 | // map 处理
63 | //1. 没有注解，正常处理。
64 | //2. 有注解，但是 require=false 则跳过。
65 | for (Field field : sortedFields) {
66 | Csv csv = null;
67 | if (field.isAnnotationPresent(Csv.class)) {
68 | csv = field.getAnnotation(Csv.class);
69 | if (CsvOperateType.READ.equals(type)
70 | && !csv.readRequire()) {
71 | continue;
72 | }
73 | if (CsvOperateType.WRITE.equals(type)
74 | && !csv.writeRequire()) {
75 | continue;
76 | }
77 | }
78 |
79 | FieldBean fieldBean = new FieldBean();
80 | fieldBean.field(field)
81 | .name(field.getName())
82 | .annotation(csv);
83 | //添加到列表中
84 | resultList.add(fieldBean);
85 | }
86 |
87 | // 存放在 cache 中
88 | CACHE.put(cacheKey, resultList);
89 | return resultList;
90 | }
91 |
92 | /**
93 | * 构建缓存 cache
94 | * （1）读写是要区分开的
95 | * String.class, CsvOperateType.READ
96 | * 输出：java.lang.String_READ
97 | * @param tClass 类
98 | * @param type 操作类型
99 | * @return 缓存 key
100 | */
101 | private static String buildCacheKey(final Class tClass,
102 | final CsvOperateType type) {
103 | return tClass.getName()+ PunctuationConst.UNDERLINE+type.name();
104 | }
105 |
106 | /**
107 | * 获取读取的映射关系
108 | *
109 | * @param tClass 类
110 | * @param sort 排序信息
111 | * @return 映射关系
112 | */
113 | public static Map getReadMapping(final Class tClass,
114 | final ISort sort) {
115 | List sortedFields = CsvFieldUtil.getSortedFields(tClass, sort,
116 | CsvOperateType.READ);
117 |
118 | return MapUtil.toIndexMap(sortedFields);
119 | }
120 |
121 | /**
122 | * 是否进行明细相关处理
123 | * @param field 字段信息
124 | * @return 是否
125 | * @since 0.0.5
126 | */
127 | public static boolean isEntryAble(final Field field) {
128 | return ReflectFieldUtil.isAnnotationPresent(field, CsvEntry.class)
129 | && ClassTypeUtil.isJavaBean(field.getType());
130 | }
131 |
132 | }
133 |
--------------------------------------------------------------------------------
/src/main/java/com/github/houbb/csv/util/CsvHelper.java:
--------------------------------------------------------------------------------
1 | package com.github.houbb.csv.util;
2 |
3 | import com.github.houbb.csv.bs.CsvReadBs;
4 | import com.github.houbb.csv.bs.CsvWriteBs;
5 | import com.github.houbb.csv.constant.CsvConst;
6 | import com.github.houbb.csv.support.reader.ICsvReader;
7 | import com.github.houbb.csv.support.reader.impl.CsvReaders;
8 | import com.github.houbb.csv.support.writer.ICsvWriter;
9 | import com.github.houbb.csv.support.writer.impl.CsvWriters;
10 | import com.github.houbb.heaven.constant.CharsetConst;
11 |
12 | import java.io.File;
13 | import java.io.InputStream;
14 | import java.util.List;
15 |
16 | /**
17 | * csv 读写工具类
18 | *
19 | * @author binbin.hou
20 | * @since 0.0.8
21 | */
22 | public final class CsvHelper {
23 |
24 | private CsvHelper() {
25 | }
26 |
27 | /**
28 | * 读取文件信息
29 | *
30 | * @param inputStream 文件输入流
31 | * @param tClass 读取类
32 | * @param 泛型
33 | * @return 结果列表
34 | * @since 0.0.8
35 | */
36 | public static List read(final InputStream inputStream,
37 | final Class tClass) {
38 | final ICsvReader reader = CsvReaders.inputStream(inputStream);
39 | return read(reader, tClass);
40 | }
41 |
42 | /**
43 | * 读取文件信息
44 | *
45 | * @param inputStream 文件输入流
46 | * @param charset 文件编码
47 | * @param tClass 读取类
48 | * @param 泛型
49 | * @return 结果列表
50 | * @since 0.0.8
51 | */
52 | public static List read(final InputStream inputStream,
53 | final String charset,
54 | final Class tClass) {
55 | final ICsvReader reader = CsvReaders.inputStream(inputStream, charset);
56 | return read(reader, tClass);
57 | }
58 |
59 | /**
60 | * 读取文件信息
61 | *
62 | * @param file 文件
63 | * @param tClass 读取类
64 | * @param 泛型
65 | * @return 结果列表
66 | * @since 0.0.8
67 | */
68 | public static List read(final File file,
69 | final Class tClass) {
70 | final ICsvReader reader = CsvReaders.file(file);
71 | return read(reader, tClass);
72 | }
73 |
74 | /**
75 | * 读取文件信息
76 | *
77 | * @param file 文件
78 | * @param charset 字符编码
79 | * @param tClass 读取类
80 | * @param 泛型
81 | * @return 结果列表
82 | * @since 0.0.8
83 | */
84 | public static List read(final File file,
85 | final String charset,
86 | final Class tClass) {
87 | final ICsvReader reader = CsvReaders.file(file, charset);
88 | return read(reader, tClass);
89 | }
90 |
91 | /**
92 | * 读取文件信息
93 | *
94 | * @param filePath 文件路径
95 | * @param tClass 读取类
96 | * @param 泛型
97 | * @return 结果列表
98 | * @since 0.0.8
99 | */
100 | public static List read(final String filePath,
101 | final Class tClass) {
102 | final ICsvReader reader = CsvReaders.filePath(filePath);
103 | return read(reader, tClass);
104 | }
105 |
106 | /**
107 | * 读取文件信息
108 | *
109 | * @param filePath 文件路径
110 | * @param charset 字符编码
111 | * @param tClass 读取类
112 | * @param 泛型
113 | * @return 结果列表
114 | * @since 0.0.8
115 | */
116 | public static List read(final String filePath,
117 | final String charset,
118 | final Class tClass) {
119 | final ICsvReader reader = CsvReaders.filePath(filePath, charset);
120 | return read(reader, tClass);
121 | }
122 |
123 | /**
124 | * 读取文件信息
125 | *
126 | * @param stringList 字符串列表
127 | * @param tClass 读取类
128 | * @param 泛型
129 | * @return 结果列表
130 | * @since 0.0.8
131 | */
132 | public static List read(final List stringList,
133 | final Class tClass) {
134 | final ICsvReader reader = CsvReaders.list(stringList);
135 | return read(reader, tClass);
136 | }
137 |
138 | /**
139 | * 读取文件信息
140 | *
141 | * @param csvReader csv 读取类
142 | * @param tClass 读取类
143 | * @param 泛型
144 | * @return 结果列表
145 | * @since 0.0.8
146 | */
147 | public static List read(final ICsvReader csvReader,
148 | final Class tClass) {
149 | return read(csvReader, tClass, CsvConst.DEFAULT_START_INDEX);
150 | }
151 |
152 | /**
153 | * 读取文件信息
154 | *
155 | * @param csvReader csv 读取类
156 | * @param tClass 读取类
157 | * @param startIndex 开始下标
158 | * @param 泛型
159 | * @return 结果列表
160 | * @since 0.0.8
161 | */
162 | public static List read(final ICsvReader csvReader,
163 | final Class tClass,
164 | final int startIndex) {
165 | return read(csvReader, tClass, startIndex, CsvConst.DEFAULT_END_INDEX);
166 | }
167 |
168 | /**
169 | * 读取文件信息
170 | *
171 | * @param csvReader csv 读取类
172 | * @param tClass 读取类
173 | * @param startIndex 开始下标
174 | * @param endIndex 结束下标
175 | * @param 泛型
176 | * @return 结果列表
177 | * @since 0.0.8
178 | */
179 | public static List read(final ICsvReader csvReader,
180 | final Class tClass,
181 | final int startIndex,
182 | final int endIndex) {
183 | return CsvReadBs.newInstance()
184 | .reader(csvReader)
185 | .startIndex(startIndex)
186 | .endIndex(endIndex)
187 | .read(tClass);
188 | }
189 |
190 |
191 | /**
192 | * 文件写入
193 | * 1. 默认写入表头
194 | * 2. 什么都不做
195 | *
196 | * @param list 文件列表
197 | * @param 泛型
198 | * @return 结果列表
199 | * @since 0.0.8
200 | */
201 | public static List write(final List list) {
202 | return write(list, CsvWriters.none());
203 | }
204 |
205 | /**
206 | * 文件写入
207 | * 1. 默认写入表头
208 | *
209 | * @param list 文件列表
210 | * @param filePath 文件路径
211 | * @param 泛型
212 | * @return 结果列表
213 | * @since 0.0.8
214 | */
215 | public static List write(final List list,
216 | final String filePath) {
217 | return write(list, filePath, CharsetConst.UTF8);
218 | }
219 |
220 | /**
221 | * 文件写入
222 | * 1. 默认写入表头
223 | *
224 | * @param list 文件列表
225 | * @param filePath 文件路径
226 | * @param charset 文件编码
227 | * @param 泛型
228 | * @return 结果列表
229 | * @since 0.0.8
230 | */
231 | public static List write(final List list,
232 | final String filePath,
233 | final String charset) {
234 | final ICsvWriter csvWriter = CsvWriters.filePath(filePath, charset);
235 | return write(list, csvWriter);
236 | }
237 |
238 | /**
239 | * 文件写入
240 | * 1. 默认写入表头
241 | *
242 | * @param list 文件列表
243 | * @param csvWriter 写入类实现
244 | * @param 泛型
245 | * @return 结果列表
246 | * @since 0.0.8
247 | */
248 | public static List write(final List list,
249 | final ICsvWriter csvWriter) {
250 | return write(list, csvWriter, true);
251 | }
252 |
253 | /**
254 | * 文件写入
255 | *
256 | * @param list 文件列表
257 | * @param csvWriter 写入类实现
258 | * @param writeHead 是否写入头信息
259 | * @param