1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
package com.yanzuoguang.util.table;
import com.yanzuoguang.util.helper.StringHelper;
import java.util.*;
/**
* 表头计算
*
* @author 颜佐光
*/
public class TableHeadHelper {
public static final String SPLIT = ":";
/**
* 获取父节点路径
*
* @param from 子节点
* @return 父节点路径
*/
public static String getParentPath(String from) {
if (from.lastIndexOf(SPLIT) >= 0) {
return from.substring(0, from.lastIndexOf(":"));
} else {
return StringHelper.EMPTY;
}
}
/**
* 对列头进行排序
*
* @param columns 对列头进行排序
*/
public static void sort(String[] columns) {
// 列头排序，同级元素排序
Arrays.sort(columns, new Comparator<String>() {
@Override
public int compare(String from, String to) {
String fromParent = getParentPath(from);
String toParent = getParentPath(to);
if (fromParent.length() == 0 || toParent.length() == 0) {
return 0;
}
return fromParent.compareTo(toParent);
}
});
}
/**
* 列头函数
*
* @param columns 计算列头
* @return 返回计算结果
*/
public static TableHead getTableHead(String... columns) {
TableHead head = new TableHead();
head.setTotalColumn(columns.length);
// 节点关系映射
Map<String, TableHeadItem> headMap = new LinkedHashMap<>();
// 当前节点的子节点元素
Map<String, List<TableHeadItem>> headSubs = new LinkedHashMap<>();
// 计算每个单元格的大小和占用的行、列
for (int columnPos = 0; columnPos < columns.length; columnPos++) {
String column = columns[columnPos];
int totalRow = setHead(head, headMap, headSubs, column, columnPos);
head.setTotalRow(Math.max(totalRow, head.getTotalRow()));
}
// 计算最后一行的合并数量
for (Map.Entry<String, TableHeadItem> item : headMap.entrySet()) {
TableHeadItem headItem = item.getValue();
if (headItem.isDataColumn()) {
headItem.setRowCell(head.getTotalRow() - headItem.getRow());
}
}
return head;
}
/**
* 设置列头相关信息
*
* @param head 列头对象集合
* @param headMap 列头对象路径映射
* @param headSubs 列头对象路径映射
* @param fullPath 来源路径
* @param columnPos 列位置
* @return 当前列包含行数
*/
private static int setHead(TableHead head,
Map<String, TableHeadItem> headMap, Map<String, List<TableHeadItem>> headSubs,
String fullPath, int columnPos) {
String[] heads = fullPath.split(":");
StringBuilder path = new StringBuilder();
for (int rowIndex = 0; rowIndex < heads.length; rowIndex++) {
// 列名称
String column = heads[rowIndex].trim();
// 父路径与当前节点路径
String parentPath = path.toString().trim();
if (rowIndex > 0) {
path.append(":");
}
path.append(column);
String nowPath = path.toString();
// 设置当前单元格属性
if (!headMap.containsKey(nowPath)) {
TableHeadItem headItem = new TableHeadItem();
headItem.setRow(rowIndex);
headItem.setRowCell(1);
headItem.setColumn(columnPos);
headItem.setColumnCell(1);
headItem.setName(column);
headItem.setPath(nowPath);
headItem.setDataColumn(fullPath.equals(nowPath));
// 添加到父元素的子节点
if (!headSubs.containsKey(parentPath)) {
headSubs.put(parentPath, new ArrayList<TableHeadItem>());
}
// 添加到当前元素对应缓存
head.getColumns().add(headItem);
headMap.put(nowPath, headItem);
headSubs.get(parentPath).add(headItem);
} else {
// 当前单元格合并列增加1
TableHeadItem headItem = headMap.get(nowPath);
headItem.setColumnCell(headItem.getColumnCell() + 1);
}
}
return heads.length;
}
}