main
黄海 7 months ago
parent aad1bc683a
commit 12f92f8d71

@ -0,0 +1,184 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class A1 {
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【1】学前幼儿入园总量预测\\学前幼儿入园总量预测.xlsx";
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
//有好多EXCEL啥样的有用必须带有关键字字样的才有用!
static String fileNameKey = "发展规模数据";
//第二个表格的表头信息
static String tableKeyword = "自动计算招生数、在校生数";
//第二个表格的表头有几行
static int tableHeadRows = 2;
//第二个表格的最后一列的列名
static String tableLetterIndex = "K";
public static void main(String[] args) throws IOException, InvalidFormatException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".xlsx") && !file.getName().endsWith(".xls"))
continue;
//只关心发展规模数据的表格
if (!file.getName().contains(fileNameKey)) continue;
//县区名称
String areaName = "阳宗海";
if (file.getName().contains("磨憨")) {
areaName = "磨憨-磨丁合作区";
} else if (file.getName().contains("经开")) {
areaName = "经开区";
}
//市州名称
String cityName = "昆明市";
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
System.exit(0);
}
//县区名称
System.out.println("正在进行" + cityName + "-" + areaName + "的数据填充~");
String sourceExcel = file.getAbsolutePath();
List<List<String>> dataList = DsKit.readSecondTable(sourceExcel, 0, tableKeyword,
tableHeadRows, tableLetterIndex);
//这个工作表有四个蓝色列D:预测总招生数E:修正城区招生AF:修正镇区招生BG:修正乡村招生C
//有时有也三个蓝色列D:预测总招生数E:修正县城内招生G:修正县城外招生
//处理办法先判断是4个的还是3个的如果是3个的就把修正县城外招生拆分开两项第一项=修正县城外招生*30%,第二项=修正县城外招生- 第一项
//至于是4个还是3个的可以通过获取第二个table的列宽来获取,4列的时候整个表的列数应该是11列3列的时候整个表的列数应该是9列
//取出第一行
if (dataList.isEmpty()) continue;
List<String> x = dataList.getFirst();
int cnt = 0;
for (String s : x) if (s == null) cnt++;
int colsCount = x.size() - cnt;
//入园总数
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//D预测总招生数
String v = stringList.get(DsKit.transLetter2Num("D")).split("\\.")[0];
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "总入园数", "", v, "", areaName, cityName), dataStyle);
}
//2022入园基数
for (List<String> ignored : dataList) {
//年份
int year = 2022;
//D预测总招生数
int v = Integer.parseInt(dataList.getFirst().get(DsKit.transLetter2Num("D")).split("\\.")[0]);
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "2022年基数(人)", "", String.valueOf(v), "", areaName, cityName), dataStyle);
}
//城区
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//E:修正城区招生A 修正县城内招生
String q = "0";
int v = 0;
if (!StrKit.isBlank(q)) {
try {
q = stringList.get(DsKit.transLetter2Num("E")).split("\\.")[0];
v = Integer.parseInt(q);
} catch (Exception err) {
}
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year),
"", "城区", "", String.valueOf(v), areaName, cityName), dataStyle);
}
//修正镇区招生B 修正县城外招生*30%
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//F:修正镇区招生B 修正县城内招生
String q = stringList.get(DsKit.transLetter2Num("F"));
if (StrKit.isBlank(q)) q = "0";
int v = Integer.parseInt(q.split("\\.")[0]);
if (colsCount == 9) {
v = (int) (v * 0.3);//乘以0.3
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "镇区", "", String.valueOf(v), areaName, cityName), dataStyle);
}
// 修正乡村招生C 修正县城外招生-修正县城外招生*30%
for (List<String> stringList : dataList) {
try {
//年份
int year = Integer.parseInt(stringList.getFirst());
//G:6修正乡村招生G
String q = stringList.get(DsKit.transLetter2Num("G"));
if (StrKit.isBlank(q)) q = "0";
int v = Integer.parseInt(q.split("\\.")[0]);
if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("F")).split("\\.")[0]);
int d = (int) (v * 0.3);//乘以0.3
v = v - d;//剩下70%
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "乡村", "", String.valueOf(v), areaName, cityName), dataStyle);
} catch (Exception err) {
}
}
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,221 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class A10 {
static DataEaseModel dm = new DataEaseModel();
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【10】新-概览\\新-概览.xlsx";
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
public static void main(String[] args) throws IOException, InvalidFormatException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//实例化
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".xlsx") && !file.getName().endsWith(".xls"))
continue;
//市州名称
String cityName = "昆明市";
//县区名称
System.out.println("正在进行" + cityName + "的数据填充~");
String sourceExcel = file.getAbsolutePath();
List<List<String>> dataList = DsKit.readSheet(sourceExcel, 4);
//我们认为第一行就是市州的统计数据,如果不是而是写到了最后的,就人为调整到第一行
// 在本例中,跳过第一行,就是县区
for (int i = 1; i < dataList.size(); i++) {
List<String> row = dataList.get(i);
String areaName = row.getFirst();
// 列的情况
// 行政区划 类型 年份 学段 数值 上级行政区划
// 行的情况
//1、学前学校总数 I
int colIdx = DsKit.transLetter2Num("I");
String xq_school_count = row.get(colIdx).trim();
//2、学前招生总数 O
colIdx = DsKit.transLetter2Num("O");
String xq_enroll_count = row.get(colIdx).trim();
//3、学前在校生总数 P
colIdx = DsKit.transLetter2Num("P");
String xq_student_count = row.get(colIdx).trim();
//4、学前教职工总数 M
colIdx = DsKit.transLetter2Num("M");
String xq_teacher_count = row.get(colIdx).trim();
//5、学前专任教师数 N
colIdx = DsKit.transLetter2Num("N");
String xq_special_teacher_count = row.get(colIdx).trim();
//6、小学学校总数 S
colIdx = DsKit.transLetter2Num("S");
String xx_school_count = row.get(colIdx).trim();
//7、小学招生总数 Z
colIdx = DsKit.transLetter2Num("Z");
String xx_enroll_count = row.get(colIdx).trim();
//8、小学在校生总数 AA
colIdx = DsKit.transLetter2Num("AA");
String xx_student_count = row.get(colIdx).trim();
//9、小学教职工总数 X
colIdx = DsKit.transLetter2Num("X");
String xx_teacher_count = row.get(colIdx).trim();
//10、小学专任教师数 Y
colIdx = DsKit.transLetter2Num("Y");
String xx_special_teacher_count = row.get(colIdx).trim();
//11、初中学校总数 AD
colIdx = DsKit.transLetter2Num("AD");
String cz_school_count = row.get(colIdx).trim();
//12、初中招生总数 AJ
colIdx = DsKit.transLetter2Num("AJ");
String cz_enroll_count = row.get(colIdx).trim();
//13、初中在校生总数 AK
colIdx = DsKit.transLetter2Num("AK");
String cz_student_count = row.get(colIdx).trim();
//14、初中教职工总数 AH
colIdx = DsKit.transLetter2Num("AH");
String cz_teacher_count = row.get(colIdx).trim();
//15、初中专任教师数 AI
colIdx = DsKit.transLetter2Num("AI");
String cz_special_teacher_count = row.get(colIdx).trim();
//16、高中学校总数 AN
colIdx = DsKit.transLetter2Num("AN");
String gz_school_count = row.get(colIdx).trim();
//17、高中招生总数 AQ
colIdx = DsKit.transLetter2Num("AQ");
String gz_enroll_count = row.get(colIdx).trim();
//18、高中在校生总数 AR
colIdx = DsKit.transLetter2Num("AR");
String gz_student_count = row.get(colIdx).trim();
//19、高中教职工总数 AO
colIdx = DsKit.transLetter2Num("AO");
String gz_teacher_count = row.get(colIdx).trim();
//20、高中专任教师数 AP
colIdx = DsKit.transLetter2Num("AP");
String gz_special_teacher_count = row.get(colIdx).trim();
//21、中职学校总数 AU
colIdx = DsKit.transLetter2Num("AU");
String zz_school_count = row.get(colIdx).trim();
//22、中职招生总数 AX
colIdx = DsKit.transLetter2Num("AX");
String zz_enroll_count = row.get(colIdx).trim();
//23、中职在校生总数 AY
colIdx = DsKit.transLetter2Num("AY");
String zz_student_count = row.get(colIdx).trim();
//24、中职教职工总数 AV
colIdx = DsKit.transLetter2Num("AV");
String zz_teacher_count = row.get(colIdx).trim();
//25、中职专任教师数 AW
colIdx = DsKit.transLetter2Num("AW");
String zz_special_teacher_count = row.get(colIdx).trim();
//学前
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "学校总数", "2023", "学前", xq_school_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "招生总数", "2023", "学前", xq_enroll_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "在校生总数", "2023", "学前", xq_student_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "教职工总数", "2023", "学前", xq_teacher_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "专任教师数", "2023", "学前", xq_special_teacher_count, cityName)), dataStyle);
//小学
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "学校总数", "2023", "小学", xx_school_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "招生总数", "2023", "小学", xx_enroll_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "在校生总数", "2023", "小学", xx_student_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "教职工总数", "2023", "小学", xx_teacher_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "专任教师数", "2023", "小学", xx_special_teacher_count, cityName)), dataStyle);
//初中
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "学校总数", "2023", "初中", cz_school_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "招生总数", "2023", "初中", cz_enroll_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "在校生总数", "2023", "初中", cz_student_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "教职工总数", "2023", "初中", cz_teacher_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "专任教师数", "2023", "初中", cz_special_teacher_count, cityName)), dataStyle);
//高中
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "学校总数", "2023", "高中", gz_school_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "招生总数", "2023", "高中", gz_enroll_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "在校生总数", "2023", "高中", gz_student_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "教职工总数", "2023", "高中", gz_teacher_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "专任教师数", "2023", "高中", gz_special_teacher_count, cityName)), dataStyle);
//中职
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "学校总数", "2023", "中职", zz_school_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "招生总数", "2023", "中职", zz_enroll_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "在校生总数", "2023", "中职", zz_student_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "教职工总数", "2023", "中职", zz_teacher_count, cityName)), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(Arrays.asList(areaName, "专任教师数", "2023", "中职", zz_special_teacher_count, cityName)), dataStyle);
}
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,62 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.Record;
import com.jfinal.plugin.activerecord.SqlPara;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class A11 {
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【11】区情\\区(县)情.xlsx";
public static void main(String[] args) throws IOException, InvalidFormatException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
SqlPara sqlPara = Db.getSqlPara("DataEase.getAreaMemo");
List<Record> list = Db.find(sqlPara);
int rowIndex = 0;
for (Record record : list) {
String areaName = record.getStr("area_name");
String cityName = record.getStr("city_name");
String memo = record.getStr("memo");
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, new ArrayList<>(
Arrays.asList(areaName, areaName, memo, cityName)), dataStyle);
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,179 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.dom4j.DocumentException;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class A12 {
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【12】新-教育资源配置发展预测\\新-教育资源配置发展预测.xlsx";
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
//static String parentPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【12】新-教育资源配置发展预测";
static DataEaseModel dm=new DataEaseModel();
public static void main(String[] args) throws IOException, InvalidFormatException, InterruptedException, DocumentException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".docx") || file.getName().startsWith("~"))
continue;
//县区名称
String areaName = "阳宗海";
if (file.getName().contains("磨憨")) {
areaName = "磨憨-磨丁合作区";
} else if (file.getName().contains("经开")) {
areaName = "经开区";
}
//市州名称
String cityName = "昆明市";
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
System.exit(0);
}
//县区名称
System.out.println("正在进行" + cityName + "-" + areaName + "的数据填充~");
int chartNumber = 36;
List<List<String>> source1 = DsKit.getChartData(file.getAbsolutePath(), chartNumber, 0);
//需要处理下人与万人的单位兼容
if (source1 != null) {
//本例中要乘以多少呢?
String xmlPath = DsKit.DocxUnzipDirectory + "word\\charts\\chart" + chartNumber + ".xml";
int mul = DsKit.getMul(xmlPath);
for (List<String> row : source1) {
for (int j = 1; j <= 4; j++) {
if (j + 1 > row.size()) continue;
row.set(j, String.valueOf((int) (Double.parseDouble(row.get(j)) * mul)));
}
}
}
chartNumber = 37;
List<List<String>> source2 = DsKit.getChartData(file.getAbsolutePath(), chartNumber, 0);
//需要处理下平方米与万平方米的单位兼容
if (source2 != null) {
//本例中要乘以多少呢?
String xmlPath = DsKit.DocxUnzipDirectory + "word\\charts\\chart" + chartNumber + ".xml";
int mul = DsKit.getMul(xmlPath);
for (List<String> row : source2) {
for (int j = 1; j <= 4; j++) {
if (j + 1 > row.size()) continue;
row.set(j, String.valueOf(Double.parseDouble(row.get(j)) * mul / 10000));//单位:万平方米
}
}
}
if (source1 != null) {
for (int i = 0; i < source1.size(); i++) {
List<String> row36 = source1.get(i);
if (source2 != null && i + 1 > source2.size()) continue;
List<String> row37 = null;
if (source2 != null) {
row37 = source2.get(i);
}
Row outRow = outSheet.createRow(++rowIndex);
String year = row36.getFirst();//年份
//学前
String xq_jzg = row36.get(1).split("\\.")[0];//教职工数
String xq_jzg2022 = source1.getFirst().get(1).split("\\.")[0];//教职工2022基数
String xq_szqk = String.valueOf((int) (Double.parseDouble(xq_jzg2022) - Double.parseDouble(xq_jzg)));//缺口、富裕
String xq_ysmj = null;//园舍面积
if (row37 != null) {
xq_ysmj = row37.get(1);
}
String xq_ysmj2022 = null;//园舍面积2022基数
if (source2 != null) {
xq_ysmj2022 = source2.getFirst().get(1);
}
String xq_ysmjqk = String.format("%.2f", Double.parseDouble(xq_ysmj2022) - Double.parseDouble(xq_ysmj));
//小学
String xx_jzg = row36.get(2).split("\\.")[0];//教职工数
String xx_jzg2022 = source1.getFirst().get(2).split("\\.")[0];//教职工2022基数
String xx_szqk = String.valueOf((int) (Double.parseDouble(xx_jzg2022) - Double.parseDouble(xx_jzg)));//缺口、富裕
if (2 + 1 > row37.size()) continue;
String xx_ysmj = row37.get(2);//园舍面积
String xx_ysmj2022 = source2.getFirst().get(2);//园舍面积2022基数
String xx_ysmjqk = String.format("%.2f", Double.parseDouble(xx_ysmj2022) - Double.parseDouble(xx_ysmj));
//初中
String cz_jzg = row36.get(3).split("\\.")[0];//教职工数
String cz_jzg2022 = source1.getFirst().get(3).split("\\.")[0];//教职工2022基数
String cz_szqk = String.valueOf((int) (Double.parseDouble(cz_jzg2022) - Double.parseDouble(cz_jzg)));//缺口、富裕
String cz_ysmj = row37.get(3);//园舍面积
String cz_ysmj2022 = source2.getFirst().get(3);//园舍面积2022基数
String cz_ysmjqk = String.format("%.2f", Double.parseDouble(cz_ysmj2022) - Double.parseDouble(cz_ysmj));
//高中
String gz_jzg = "0";
String gz_jzg2022 = "0";
String gz_szqk = "0";
String gz_ysmj = "0";
String gz_ysmj2022 = "0";
String gz_ysmjqk = "0";
try {
gz_jzg = row36.get(4).split("\\.")[0];//教职工数
gz_jzg2022 = source1.getFirst().get(4).split("\\.")[0];//教职工2022基数
gz_szqk = String.valueOf((int) (Double.parseDouble(gz_jzg2022) - Double.parseDouble(gz_jzg)));//缺口、富裕
gz_ysmj = row37.get(4);//园舍面积
gz_ysmj2022 = source2.getFirst().get(4);//园舍面积2022基数
gz_ysmjqk = String.format("%.2f", Double.parseDouble(gz_ysmj2022) - Double.parseDouble(gz_ysmj));
} catch (Exception err) {
}
DsKit.putData(outRow, Arrays.asList(year, areaName,
xq_jzg, xq_jzg2022, xq_szqk, String.format("%.2f", Double.parseDouble(xq_ysmj)), String.format("%.2f", Double.parseDouble(xq_ysmj2022)), xq_ysmjqk, // 学前
xx_jzg, xx_jzg2022, xx_szqk, String.format("%.2f", Double.parseDouble(xx_ysmj)), String.format("%.2f", Double.parseDouble(xx_ysmj2022)), xx_ysmjqk, // 小学
cz_jzg, cz_jzg2022, cz_szqk, String.format("%.2f", Double.parseDouble(cz_ysmj)), String.format("%.2f", Double.parseDouble(cz_ysmj2022)), cz_ysmjqk, // 初中
gz_jzg, gz_jzg2022, gz_szqk, String.format("%.2f", Double.parseDouble(gz_ysmj)), String.format("%.2f", Double.parseDouble(gz_ysmj2022)), gz_ysmjqk, // 高中
cityName), dataStyle);
}
}
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,278 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.aigc.generation.models.QwenParam;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.Constants;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static com.dsideal.base.Tools.FillData.DataEaseKit.DsKit.DocxUnzipDirectory;
public class A13 {
//只输出四和五
static String[] printDx = {"一", "二", "三", "四", "五", "六", "七", "八", "九", "十"};
//转为 List<String>
static List<String> printDxList = Arrays.asList(printDx);
//哪些是处理不了的,就不处理了~
static String[] excludeCityList = {"~$", "磨憨-磨丁", "经开区", "阳宗海"};
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【13】教育特征决策建议\\【云南省】教育特征-决策建议.xlsx";
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
/**
* Word
*
* @param wordPath
* @throws DocumentException
* @throws IOException
*/
static DataEaseModel dm = new DataEaseModel();
public static List<String> get(int idx) throws DocumentException {
List<String> list = new ArrayList<>();
//读入XML
String xmlPath = DocxUnzipDirectory + "word\\document.xml";
SAXReader reader = new SAXReader(); // 创建 SAXReader 对象,读取 XML 文件
Document document = reader.read(new File(xmlPath));
Element root = document.getRootElement();// 获取根元素
List<Element> children = root.element("body").elements("p");//工作区
boolean out = false;
int parent = 0;
for (Element child : children) {
if (child.getName().equals("p")) {
List<Element> pChildren = child.elements();
String content = "";
for (Element pChild : pChildren) {
if (!pChild.getName().equals("pPr")) {
if (pChild.getName().equals("r")) {
for (Element t : pChild.elements("t")) {
content = content + t.getText();
}
}
}
}
if (!StrKit.isBlank(content)) {
//如果content是 "图"+数字形式的,不输出
if (!content.contains("(图") && !content.contains("(图")) {
//如果文字不是以上面printDx中的某一个开头而且不是以数字+.开头,不输出
if (content.startsWith("") && printDxList.contains(String.valueOf(content.charAt(1)))) {
out = true;
}
//太长的不要
if (content.length() > 40) continue;
if (printDxList.contains(content.substring(0, 1))) {
if (content.charAt(0) == '四' && content.charAt(1) == '、') {
parent = 4;
}
if (content.charAt(0) == '五' && content.charAt(1) == '、') {
parent = 5;
}
out = true;
}
if (out && parent > 0) {
if (!content.startsWith("")) continue;
if (parent == idx) {
String c = killKuoHao(content.split("。")[0]);
list.add("• " + c);
}
out = false;
}
}
}
}
}
return list;
}
/**
*
*
* @param question
* @return
* @throws NoApiKeyException
* @throws ApiException
* @throws InputRequiredException
*/
public static String callTongYiQianWen(String question)
throws NoApiKeyException, ApiException, InputRequiredException {
//使用驿来特的api key
Constants.apiKey = "sk-f6da0c787eff4b0389e4ad03a35a911f";
Generation gen = new Generation();
Message userMsg = Message.builder().role(Role.USER.getValue()).content(question).build();
QwenParam param =
QwenParam.builder().model("qwen-long").messages(Arrays.asList(userMsg))
.resultFormat(QwenParam.ResultFormat.MESSAGE).topP(0.8).build();
GenerationResult result = gen.call(param);
return result.getOutput().getChoices().getFirst().getMessage().getContent();
}
public static String rs(String s) {
//如果s中以 形如 (一) (二)或者 (三) (四)这样的内容替换为空,其它的内容保留下来
String regex = "(\\[一二三四五六七八九十]+\\)|(\\([一二三四五六七八九十]+\\))";
return s.replaceAll(regex, "");
}
public static String get2012Summary(String filePath) {
try (FileInputStream fis = new FileInputStream(filePath);
XWPFDocument document = new XWPFDocument(fis)) {
List<XWPFParagraph> paragraphs = document.getParagraphs();
for (XWPFParagraph paragraph : paragraphs) {
String text = paragraph.getText();
if (text != null && text.trim().startsWith("2012")) {
return text.trim();
}
}
return null;
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
public static String killKuoHao(String originalString) {
// 正则表达式匹配中文括号、英文圆括号、方括号和花括号内的内容
String regex = "[^]*|\\([^\\)]*\\)|【[^】]*】|\\{[^}]*\\}";
// 替换掉匹配的内容
return originalString.replaceAll(regex, "");
}
public static void main(String[] args) throws IOException, DocumentException, NoApiKeyException, InputRequiredException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
String fileName = file.getName();
//判断是否为docx文件
if (fileName.endsWith(".docx") && !fileName.startsWith("~")) {
boolean flag = false;
for (String s : excludeCityList) {
if (file.getName().contains(s)) {
flag = true;
break;
}
}
if (flag) continue;
//县区名称
String areaName = dm.getAreaName(file.getName());
//市州名称
String cityName = dm.getCityNameByAreaName(areaName);
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
continue;
}
//县区名称
System.out.println("正在进行" + cityName + "-" + areaName + "的数据填充~");
DsKit.unCompress(file.getAbsolutePath());
List<String> list4 = get(4);
try {
//截取 小学 初中 高中 后面的文字,看看是不是一样的
String prefix = list4.get(1).split("小学")[0];
String xx = list4.get(1).split("小学")[1];
String cz = list4.get(2).split("初中")[1];
String gz = list4.get(3).split("高中")[1];
//三个全相同,需要三个合并
if (xx.equals(cz) && xx.equals(gz)) {
for (int i = 1; i <= 3; i++) list4.removeLast();
list4.add(prefix + "小学、初中、高中" + xx);
}
//如果小学和初中一样
else if (xx.equals(cz)) {
for (int i = 1; i <= 3; i++) list4.removeLast();
list4.add(prefix + "小学、初中" + xx);
list4.add(prefix + "高中" + gz);
} else if (cz.equals(gz)) {
for (int i = 1; i <= 3; i++) list4.removeLast();
list4.add(prefix + "小学" + xx);
list4.add(prefix + "初中、高中" + gz);
}
} catch (Exception err) {
}
List<String> list5 = get(5);
list4.addAll(list5);
while (list4.size() < 7) list4.add("");
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(areaName, "教育特征", "",
rs(list4.getFirst()),
rs(list4.get(1)),
rs(list4.get(2)),
rs(list4.get(3)),
rs(list4.get(4)),
rs(list4.get(5)),
rs(list4.get(6)),
cityName), dataStyle);
// outRow = outSheet.createRow(++rowIndex);
// DsKit.putData(outRow, Arrays.asList(areaName, "决策建议",
// rs(list5.getFirst()),
// rs(list5.get(1)),
// rs(list5.get(2)),
// rs(list5.get(3)),
// rs(list5.get(4)),
// rs(list5.get(5)),
// rs(list5.get(6)),
// rs(list5.get(7)),
// cityName), dataStyle);
}
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,171 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.jfinal.kit.StrKit;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class A14 {
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【14】基本县情\\2023年基本县情【成果】.xlsx";
public static String getHTML(String url) throws IOException {
StringBuilder stringBuilder = new StringBuilder();
URL website = new URL(url);
HttpURLConnection connection = (HttpURLConnection) website.openConnection();
connection.setRequestMethod("GET");
BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
stringBuilder.append(line);
}
reader.close();
return stringBuilder.toString();
}
/**
*
*
* @param areaName
* @return
* @throws IOException
*/
public static List<String> getXq(String areaName) throws IOException {
List<String> list = new ArrayList<>();
String url = "https://baike.baidu.com/item/" + areaName + "?fromModule=lemma_search-box";
String htmlContent = getHTML(url);
//System.out.println(htmlContent);
// 从字符串解析HTML
Document doc = Jsoup.parse(htmlContent);
Elements dts = doc.select("dt");
// 遍历所有dt标签
for (Element dt : dts) {
if (dt.text().equals("下辖地区")) {
// 使用正则表达式替换掉以[]包含的部分
String output = dt.nextElementSibling().text().replaceAll("\\[.*?\\]", "");
output = output.trim();
list.add(output);
}
if (dt.text().replace(" ", "").equals("面积")) {
String output = dt.nextElementSibling().text().replaceAll("\\[.*?\\]", "");
output = output.replace("km²", "");
output = output.trim();
list.add(output);
}
}
return list;
}
public static List<Integer> extractTownAndVillage(String input) {
List<Integer> counts = new ArrayList<>();
Pattern pattern = Pattern.compile("(\\d+)个镇|(\\d+)镇|(\\d+)个乡|(\\d+)乡");
Matcher matcher = pattern.matcher(input);
int townCount = 0;
int villageCount = 0;
while (matcher.find()) {
if (matcher.group(1) != null || matcher.group(2) != null) {
townCount = Integer.parseInt(matcher.group(0).replace("镇", "").replace("乡", "").replace("个", ""));
}
if (matcher.group(3) != null || matcher.group(4) != null) {
villageCount = Integer.parseInt(matcher.group(0).replace("镇", "").replace("乡", "").replace("个", ""));
}
}
counts.add(townCount);
counts.add(villageCount);
return counts;
}
/**
*
*
* @param input
* @param character
* @return
*/
public static int countChineseCharacter(String input, String character) {
if (input == null || character == null || character.length() != 1) {
return 0;
}
int count = 0;
for (int i = 0; i < input.length(); i++) {
if (input.charAt(i) == character.charAt(0)) {
count++;
}
}
return count;
}
public static void main(String[] args) throws NoApiKeyException, InputRequiredException, IOException, InterruptedException {
FileInputStream inputStream = new FileInputStream(sampleExcelPath);
FileOutputStream outputStream;
Workbook workbook = new XSSFWorkbook(inputStream); // 打开工作簿
Sheet sheet = workbook.getSheetAt(0); // 获取第一个工作表
// 读取数据
int idx = 0;
for (Row row : sheet) {
idx++;
if (idx == 1) continue;
String cityName = DsKit.readCell(row.getCell(0)).replace(" ", "");
String areaName = DsKit.readCell(row.getCell(1)).replace(" ", "");
if (!StrKit.isBlank(areaName)) {
System.out.println("正在查询县区:" + cityName + "\t" + areaName);
List<String> list = getXq(areaName);
Thread.sleep(2000);
if (!list.isEmpty()) {
Cell cell2 = row.getCell(2);
if (cell2 == null) cell2 = row.createCell(2);
cell2.setCellValue(list.getFirst());
}
if (list.size() > 1) {
List<Integer> result = extractTownAndVillage(list.get(1));
int zhenCount = result.get(0);
int xiangCount = result.get(1);
//如果zhenCount==0,那么我就用list.get(1)中去查找 镇 这个字的数量,然后用这个数量作为镇的数量
if (zhenCount == 0 && xiangCount == 0) {
zhenCount = countChineseCharacter(list.get(1), "镇");
xiangCount = countChineseCharacter(list.get(1), "乡");
}
System.out.println("镇数量=" + zhenCount + ",乡数量=" + xiangCount);
if (zhenCount == 0 && xiangCount == 0) {
System.out.println("没有找到镇或乡的数量,请手动输入!");
System.out.println(list.get(1));
}
Cell cell3 = row.getCell(3);
if (cell3 == null) cell3 = row.createCell(3);
cell3.setCellValue(zhenCount);
Cell cell4 = row.getCell(4);
if (cell4 == null) cell4 = row.createCell(4);
cell4.setCellValue(xiangCount);
}
}
}
outputStream = new FileOutputStream(sampleExcelPath);
workbook.write(outputStream); // 将修改后的工作簿写入文件
inputStream.close();
outputStream.close();
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,186 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFRun;
import org.dom4j.DocumentException;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class A15 {
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【15】发展规模预测\\教育规模发展情况与预测.xlsx";
public static String removeEmptyLines(String text) {
// 使用正则表达式分割字符串,然后过滤掉空行
return text.replace("\n\n", "\n");
}
/**
*
*
* @param filePath
* @return
* @throws IOException
*/
public static List<String> getDocxJYFZXZ(String filePath) throws IOException {
//使用POI读取上面word文档的所有文字信息
String content = "";
InputStream inputStream = new FileInputStream(filePath);
XWPFDocument document = new XWPFDocument(inputStream);
List<XWPFParagraph> paragraphs = document.getParagraphs();
String[] a = {"入园", "在园", "小学招生", "小学在校生", "初中招生", "初中在校生", "高中招生", "高中在校生"};
//接下我将遍历 word文档 中的每一段文字,如果遍历到的文字中包含上面数组的某一个字符串,开始截取此学段的文字
for (XWPFParagraph paragraph : paragraphs) {
List<XWPFRun> runs = paragraph.getRuns();
for (XWPFRun run : runs) {
String text = run.getText(0);
if (text != null) {
content += text + "\n";
}
}
}
List<Integer> posList = new ArrayList<>();
for (String s : a) {
int pos = content.indexOf(s);
// if (pos < 0) {
// System.out.println(s + "在给定的文本中没有找到,程序无法继续,请人工检查!");
// return null;
// }
posList.add(pos);
}
List<String> res = new ArrayList<>();
for (int i = 0; i < posList.size() - 1; i++) {
int start = posList.get(i);
if (start >= 0) {
int end = start + 1;
//从start开始向后查找直到遇到换行符为止
while (end < content.length() && content.charAt(end) != '图'
&& content.charAt(end) != '。') {
end++;
}
String q = content.substring(start, end);
if (q.endsWith("呈现")) q += "稳步上升变化";
else if (q.endsWith("初中在校生数变化")) q += "相对平稳";
else if (q.endsWith("高中招生数")) q += "变化相对平稳";
else if (q.endsWith("小学在校生规模")) q += "相对平稳";
else if (q.endsWith("初中招生规模")) q += "相对平稳";
else if (q.endsWith("初中在校生规")) q += "模相对平稳";
else if (q.endsWith("高中招生规模")) q += "相对平稳";
else if (q.endsWith("高中招生数变化")) q += "相对平稳";
res.add(q);
} else {
res.add("");
}
}
return res;
}
public static void main(String[] args) throws IOException, DocumentException, NoApiKeyException, InputRequiredException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".docx") || file.getName().startsWith("~"))
continue;
//县区名称
//县区名称
String areaName = "阳宗海";
if (file.getName().contains("磨憨")) {
areaName = "磨憨-磨丁合作区";
} else if (file.getName().contains("经开")) {
areaName = "经开区";
}
//市州名称
String cityName = "昆明市";
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
continue;
}
//县区名称
System.out.println("正在进行" + cityName + "-" + areaName + "的数据填充~");
//获取教育发展现状态
List<String> list = getDocxJYFZXZ(file.getAbsolutePath());
//如果长度不足8个需要补全8个
if (list.size() < 8) {
for (int i = list.size(); i < 8; i++) {
list.add("高中在校生数变化相对平稳。");
}
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(cityName, areaName, "学前", "入园幼儿", list.get(0), ""), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(cityName, areaName, "学前", "在园幼儿", list.get(1), ""), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(cityName, areaName, "小学", "招生总数", list.get(2), ""), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(cityName, areaName, "小学", "在校生总数", list.get(3), ""), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(cityName, areaName, "初中", "招生总数", list.get(4), ""), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(cityName, areaName, "初中", "在校生总数", list.get(5), ""), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(cityName, areaName, "高中", "招生总数", list.get(6), ""), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(cityName, areaName, "高中", "在校生总数", list.get(7), ""), dataStyle);
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,188 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class A2 {
static DataEaseModel dm = new DataEaseModel();
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【2】学前幼儿在园总量预测\\学前幼儿在园总量预测.xlsx";
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
//有好多EXCEL啥样的有用必须带有关键字字样的才有用!
static String fileNameKey = "发展规模数据";
//第二个表格的表头信息
static String tableKeyword = "自动计算招生数、在校生数";
//第二个表格的表头有几行
static int tableHeadRows = 2;
//第二个表格的最后一列的列名
static String tableLetterIndex = "K";
public static void main(String[] args) throws IOException, InvalidFormatException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//实例化
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".xlsx") && !file.getName().endsWith(".xls"))
continue;
//只关心发展规模数据的表格
if (!file.getName().contains(fileNameKey)) continue;
//县区名称
String areaName = "阳宗海";
if (file.getName().contains("磨憨")) {
areaName = "磨憨-磨丁合作区";
} else if (file.getName().contains("经开")) {
areaName = "经开区";
}
//市州名称
String cityName = "昆明市";
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
System.exit(0);
}
//县区名称
System.out.println("正在进行" + cityName + "-" + areaName + "的数据填充~");
String sourceExcel = file.getAbsolutePath();
List<List<String>> dataList = DsKit.readSecondTable(sourceExcel, 0, tableKeyword,
tableHeadRows, tableLetterIndex);
//这个工作表有四个蓝色列D:预测总招生数E:修正城区招生AF:修正镇区招生BG:修正乡村招生C
//有时有也三个蓝色列D:预测总招生数E:修正县城内招生G:修正县城外招生
//处理办法先判断是4个的还是3个的如果是3个的就把修正县城外招生拆分开两项第一项=修正县城外招生*30%,第二项=修正县城外招生- 第一项
//至于是4个还是3个的可以通过获取第二个table的列宽来获取,4列的时候整个表的列数应该是11列3列的时候整个表的列数应该是9列
//取出第一行
if (dataList.isEmpty()) continue;
List<String> x = dataList.getFirst();
int cnt = 0;
for (String s : x) if (s == null) cnt++;
int colsCount = x.size() - cnt;
//在园总数
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//H预测总在校生数
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("H")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("G")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "总在园数", "", String.valueOf(v), "", areaName, cityName), dataStyle);
}
//2022入园基数
for (List<String> ignored : dataList) {
//年份
int year = 2022;
//H预测总招生数
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(dataList.getFirst().get(DsKit.transLetter2Num("H")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(dataList.getFirst().get(DsKit.transLetter2Num("G")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "2022年基数(人)", "", String.valueOf(v), "", areaName, cityName), dataStyle);
}
//城区
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//I:修正城区招生A 修正县城内招生
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("I")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("H")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year),
"", "城区", "", String.valueOf(v), areaName, cityName), dataStyle);
}
//预测镇区在校生数 修正县城外在校生数*30%
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("J")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("I")).split("\\.")[0]);
v = (int) (v * 0.3);//乘以0.3
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "镇区", "", String.valueOf(v), areaName, cityName), dataStyle);
}
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("K")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("I")).split("\\.")[0]);
int d = (int) (v * 0.3);//乘以0.3
v = v - d;//剩下70%
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "乡村", "", String.valueOf(v), areaName, cityName), dataStyle);
}
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,190 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class A3 {
static DataEaseModel dm = new DataEaseModel();
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【3】义务教育招生总量预测\\义务教育招生总量预测.xlsx";
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
//有好多EXCEL啥样的有用必须带有关键字字样的才有用!
static String fileNameKey = "发展规模数据";
//第二个表格的表头信息
static String tableKeyword = "自动计算招生数、在校生数";
//第二个表格的表头有几行
static int tableHeadRows = 2;
//第二个表格的最后一列的列名
static String tableLetterIndex = "K";
public static void main(String[] args) throws IOException, InvalidFormatException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//实例化
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".xlsx") && !file.getName().endsWith(".xls"))
continue;
//只关心发展规模数据的表格
if (!file.getName().contains(fileNameKey)) continue;
//县区名称
String areaName = "阳宗海";
if (file.getName().contains("磨憨")) {
areaName = "磨憨-磨丁合作区";
} else if (file.getName().contains("经开")) {
areaName = "经开区";
}
//市州名称
String cityName = "昆明市";
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
System.exit(0);
}
//县区名称
System.out.println("正在进行" + cityName + "-" + areaName + "的数据填充~");
String sourceExcel = file.getAbsolutePath();
String[] stageList = {"小学", "初中"};
int[] sheetIndexList = {1, 2};
for (int K = 0; K < 2; K++) {
int sheetIndex = sheetIndexList[K];
String stageName = stageList[K];
List<List<String>> dataList = DsKit.readSecondTable(sourceExcel, sheetIndex, tableKeyword,
tableHeadRows, tableLetterIndex);
//取出第一行
if (dataList.isEmpty()) continue;
List<String> x = dataList.getFirst();
int cnt = 0;
for (String s : x) if (s == null) cnt++;
int colsCount = x.size() - cnt;
//义务教育招生数量
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("D")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("D")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "总招生数", stageName, "", String.valueOf(v), areaName, cityName), dataStyle);
}
//2022入园基数
for (List<String> ignored : dataList) {
//年份
int year = 2022;
//H预测总招生数
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(dataList.getFirst().get(DsKit.transLetter2Num("D")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(dataList.getFirst().get(DsKit.transLetter2Num("D")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "2022年基数(人)", stageName, "", String.valueOf(v), areaName, cityName), dataStyle);
}
//城区
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//I:修正城区招生A 修正县城内招生
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("E")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("E")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year),
"城区", "", stageName, String.valueOf(v), "", areaName, cityName), dataStyle);
}
//预测镇区在校生数 修正县城外在校生数*30%
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("F")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("F")).split("\\.")[0]);
v = (int) (v * 0.3);//乘以0.3
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "镇区", "", stageName, String.valueOf(v), "", areaName, cityName), dataStyle);
}
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("G")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("F")).split("\\.")[0]);
int d = (int) (v * 0.3);//乘以0.3
v = v - d;//剩下70%
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "乡村", "", stageName, String.valueOf(v), "", areaName, cityName), dataStyle);
}
}
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,190 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class A4 {
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【4】义务教育在校生总量预测\\义务教育在校生总量预测.xlsx";
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
//有好多EXCEL啥样的有用必须带有关键字字样的才有用!
static String fileNameKey = "发展规模数据";
//第二个表格的表头信息
static String tableKeyword = "自动计算招生数、在校生数";
//第二个表格的表头有几行
static int tableHeadRows = 2;
//第二个表格的最后一列的列名
static String tableLetterIndex = "K";
public static void main(String[] args) throws IOException, InvalidFormatException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//实例化
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".xlsx") && !file.getName().endsWith(".xls"))
continue;
//只关心发展规模数据的表格
if (!file.getName().contains(fileNameKey)) continue;
//县区名称
//县区名称
String areaName = "阳宗海";
if (file.getName().contains("磨憨")) {
areaName = "磨憨-磨丁合作区";
} else if (file.getName().contains("经开")) {
areaName = "经开区";
}
//市州名称
String cityName = "昆明市";
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
System.exit(0);
}
//县区名称
System.out.println("正在进行" + cityName + "-" + areaName + "的数据填充~");
String[] stageList = {"小学", "初中"};
int[] sheetIndexList = {1, 2};
for (int K = 0; K < 2; K++) {
int sheetIndex = sheetIndexList[K];
String stageName = stageList[K];
String sourceExcel = file.getAbsolutePath();
List<List<String>> dataList = DsKit.readSecondTable(sourceExcel, sheetIndex, tableKeyword,
tableHeadRows, tableLetterIndex);
//取出第一行
if (dataList.isEmpty()) continue;
List<String> x = dataList.getFirst();
int cnt = 0;
for (String s : x) if (s == null) cnt++;
int colsCount = x.size() - cnt;
//在园总数
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//H预测总在校生数
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("H")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("G")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "总在校生数", stageName, "", String.valueOf(v), areaName, cityName), dataStyle);
}
//2022入园基数
for (List<String> ignored : dataList) {
//年份
int year = 2022;
//H预测总招生数
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(dataList.getFirst().get(DsKit.transLetter2Num("H")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(dataList.getFirst().get(DsKit.transLetter2Num("G")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "2022年基数(人)", stageName, "", String.valueOf(v), areaName, cityName), dataStyle);
}
//城区
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//I:修正城区招生A 修正县城内招生
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("I")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("H")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year),
"城区", "", stageName, String.valueOf(v), "", areaName, cityName), dataStyle);
}
//预测镇区在校生数 修正县城外在校生数*30%
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("J")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("I")).split("\\.")[0]);
v = (int) (v * 0.3);//乘以0.3
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "镇区", "", stageName, String.valueOf(v), "", areaName, cityName), dataStyle);
}
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("K")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("I")).split("\\.")[0]);
int d = (int) (v * 0.3);//乘以0.3
v = v - d;//剩下70%
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "乡村", "", stageName, String.valueOf(v), "", areaName, cityName), dataStyle);
}
}
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,172 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class A5 {
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【5】普通高中招生总量预测\\普通高中招生总量预测.xlsx";
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
//有好多EXCEL啥样的有用必须带有关键字字样的才有用!
static String fileNameKey = "发展规模数据";
//第二个表格的表头信息
static String tableKeyword = "自动计算招生数、在校生数";
//第二个表格的表头有几行
static int tableHeadRows = 2;
//第二个表格的最后一列的列名
static String tableLetterIndex = "K";
public static void main(String[] args) throws IOException, InvalidFormatException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//实例化
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".xlsx") && !file.getName().endsWith(".xls"))
continue;
//只关心发展规模数据的表格
if (!file.getName().contains(fileNameKey)) continue;
//县区名称
//县区名称
String areaName = "阳宗海";
if (file.getName().contains("磨憨")) {
areaName = "磨憨-磨丁合作区";
} else if (file.getName().contains("经开")) {
areaName = "经开区";
}
//市州名称
String cityName = "昆明市";
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
System.exit(0);
}
//县区名称
System.out.println("正在进行" + cityName + "-" + areaName + "的数据填充~");
String sourceExcel = file.getAbsolutePath();
List<List<String>> dataList = DsKit.readSecondTable(sourceExcel, 3, tableKeyword,
tableHeadRows, tableLetterIndex);
//这个工作表有四个蓝色列D:预测总招生数E:修正城区招生AF:修正镇区招生BG:修正乡村招生C
//有时有也三个蓝色列D:预测总招生数E:修正县城内招生G:修正县城外招生
//处理办法先判断是4个的还是3个的如果是3个的就把修正县城外招生拆分开两项第一项=修正县城外招生*30%,第二项=修正县城外招生- 第一项
//至于是4个还是3个的可以通过获取第二个table的列宽来获取,4列的时候整个表的列数应该是11列3列的时候整个表的列数应该是9列
//取出第一行
if (dataList.isEmpty()) continue;
List<String> x = dataList.getFirst();
int cnt = 0;
for (String s : x) if (s == null) cnt++;
int colsCount = x.size() - cnt;
//入园总数
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//D预测总招生数
String v = stringList.get(DsKit.transLetter2Num("D")).split("\\.")[0];
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "总招生数", "", v, "", areaName, cityName), dataStyle);
}
//2022入园基数
for (List<String> ignored : dataList) {
//年份
int year = 2022;
//D预测总招生数
int v = Integer.parseInt(dataList.getFirst().get(DsKit.transLetter2Num("D")).split("\\.")[0]);
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "2022年基数(人)", "", String.valueOf(v), "", areaName, cityName), dataStyle);
}
//城区
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//E:修正城区招生A 修正县城内招生
int v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("E")).split("\\.")[0]);
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year),
"", "城区", "", String.valueOf(v), areaName, cityName), dataStyle);
}
//修正镇区招生B 修正县城外招生*30%
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//F:修正镇区招生B 修正县城内招生
int v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("F")).split("\\.")[0]);
if (colsCount == 9) {
v = (int) (v * 0.3);//乘以0.3
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "镇区", "", String.valueOf(v), areaName, cityName), dataStyle);
}
// 修正乡村招生C 修正县城外招生-修正县城外招生*30%
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//G:6修正乡村招生G
int v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("G")).split("\\.")[0]);
if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("F")).split("\\.")[0]);
int d = (int) (v * 0.3);//乘以0.3
v = v - d;//剩下70%
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "乡村", "", String.valueOf(v), areaName, cityName), dataStyle);
}
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,187 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class A6 {
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【6】普通高中在校生总量预测\\普通高中在校生总量预测.xlsx";
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
//有好多EXCEL啥样的有用必须带有关键字字样的才有用!
static String fileNameKey = "发展规模数据";
//第二个表格的表头信息
static String tableKeyword = "自动计算招生数、在校生数";
//第二个表格的表头有几行
static int tableHeadRows = 2;
//第二个表格的最后一列的列名
static String tableLetterIndex = "K";
public static void main(String[] args) throws IOException, InvalidFormatException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//实例化
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".xlsx") && !file.getName().endsWith(".xls"))
continue;
//只关心发展规模数据的表格
if (!file.getName().contains(fileNameKey)) continue;
//县区名称
String areaName = "阳宗海";
if (file.getName().contains("磨憨")) {
areaName = "磨憨-磨丁合作区";
} else if (file.getName().contains("经开")) {
areaName = "经开区";
}
//市州名称
String cityName = "昆明市";
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
System.exit(0);
}
//县区名称
System.out.println("正在进行" + cityName + "-" + areaName + "的数据填充~");
String sourceExcel = file.getAbsolutePath();
List<List<String>> dataList = DsKit.readSecondTable(sourceExcel, 3, tableKeyword,
tableHeadRows, tableLetterIndex);
//这个工作表有四个蓝色列D:预测总招生数E:修正城区招生AF:修正镇区招生BG:修正乡村招生C
//有时有也三个蓝色列D:预测总招生数E:修正县城内招生G:修正县城外招生
//处理办法先判断是4个的还是3个的如果是3个的就把修正县城外招生拆分开两项第一项=修正县城外招生*30%,第二项=修正县城外招生- 第一项
//至于是4个还是3个的可以通过获取第二个table的列宽来获取,4列的时候整个表的列数应该是11列3列的时候整个表的列数应该是9列
//取出第一行
if (dataList.isEmpty()) continue;
List<String> x = dataList.getFirst();
int cnt = 0;
for (String s : x) if (s == null) cnt++;
int colsCount = x.size() - cnt;
//在园总数
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//H预测总在校生数
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("H")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("G")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "总在校生数", "", String.valueOf(v), "", areaName, cityName), dataStyle);
}
//2022入园基数
for (List<String> ignored : dataList) {
//年份
int year = 2022;
//H预测总招生数
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(dataList.getFirst().get(DsKit.transLetter2Num("H")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(dataList.getFirst().get(DsKit.transLetter2Num("G")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "2022年基数(人)", "", String.valueOf(v), "", areaName, cityName), dataStyle);
}
//城区
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
//I:修正城区招生A 修正县城内招生
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("I")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("H")).split("\\.")[0]);
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year),
"", "城区", "", String.valueOf(v), areaName, cityName), dataStyle);
}
//预测镇区在校生数 修正县城外在校生数*30%
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("J")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("I")).split("\\.")[0]);
v = (int) (v * 0.3);//乘以0.3
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "镇区", "", String.valueOf(v), areaName, cityName), dataStyle);
}
for (List<String> stringList : dataList) {
//年份
int year = Integer.parseInt(stringList.getFirst());
int v = 0;
if (colsCount == 11) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("K")).split("\\.")[0]);
} else if (colsCount == 9) {
v = Integer.parseInt(stringList.get(DsKit.transLetter2Num("I")).split("\\.")[0]);
int d = (int) (v * 0.3);//乘以0.3
v = v - d;//剩下70%
}
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(String.valueOf(year), "", "乡村", "", String.valueOf(v), areaName, cityName), dataStyle);
}
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,125 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class A7 {
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【7】终-人口总体情况\\终-人口总体情况(万人).xlsx";
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
//有好多EXCEL啥样的有用必须带有关键字字样的才有用!
//第二个表格的表头信息
static String tableKeyword = "自动计算人口数";
//第二个表格的表头有几行
static int tableHeadRows = 2;
//第二个表格的最后一列的列名
static String tableLetterIndex = "D";
public static void main(String[] args) throws IOException, InvalidFormatException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
int idx = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".xlsx") && !file.getName().endsWith(".xls"))
continue;
//县区名称
//县区名称
String areaName = "阳宗海";
if (file.getName().contains("磨憨")) {
areaName = "磨憨-磨丁合作区";
} else if (file.getName().contains("经开")) {
areaName = "经开区";
}
//市州名称
String cityName = "昆明市";
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
System.exit(0);
}
//县区名称
idx++;
System.out.println("第" + idx + "个,正在进行" + cityName + "-" + areaName + "的数据填充~");
String sourceExcel = file.getAbsolutePath();
List<List<String>> dataList = DsKit.readSecondTable(sourceExcel, 0, tableKeyword,
tableHeadRows, tableLetterIndex);
//取出第一行
if (dataList.isEmpty()) {
System.out.println(areaName + ":该县区没有数据,请检查!");
System.exit(-1);
}
List<String> stringList = dataList.get(1);
//总人口
String zrk = stringList.get(DsKit.transLetter2Num("B")).split("\\.")[0];
//城镇人口
String cz = stringList.get(DsKit.transLetter2Num("C")).split("\\.")[0];
//乡村人口
String xc = stringList.get(DsKit.transLetter2Num("D")).split("\\.")[0];
Row outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(areaName, "总人口", String.format("%.2f", 1.0 * Integer.parseInt(zrk) / 10000), "万人", cityName), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(areaName, "新生人口", "0", "万人", cityName), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(areaName, "城镇人口", String.format("%.2f", 1.0 * Integer.parseInt(cz) / 10000), "万人", cityName), dataStyle);
outRow = outSheet.createRow(++rowIndex);
DsKit.putData(outRow, Arrays.asList(areaName, "乡村人口", String.format("%.2f", 1.0 * Integer.parseInt(xc) / 10000), "万人", cityName), dataStyle);
outRow = outSheet.createRow(++rowIndex);
//保留两位小数
DsKit.putData(outRow, Arrays.asList(areaName, "城镇化率",
String.format("%.2f", Double.parseDouble(cz) / Double.parseDouble(zrk) * 100) + "%", "", cityName), dataStyle);
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,117 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.dom4j.DocumentException;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class A8 {
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【8】总人口变化及预测-双\\总人口变化及预测-双-(万人).xlsx";
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
public static void main(String[] args) throws IOException, InvalidFormatException, InterruptedException, DocumentException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".docx") || file.getName().startsWith("~"))
continue;
//县区名称
//县区名称
String areaName = "阳宗海";
if (file.getName().contains("磨憨")) {
areaName = "磨憨-磨丁合作区";
} else if (file.getName().contains("经开")) {
areaName = "经开区";
}
//市州名称
String cityName = "昆明市";
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
System.exit(0);
}
//县区名称
System.out.println("正在进行" + cityName + "-" + areaName + "的数据填充~");
int chartNumber = 1;
List<List<String>> source =
DsKit.getChartData(file.getAbsolutePath(), chartNumber, 0);
//需要处理下人与万人的单位兼容
int mul;
if (source != null) {
//本例中要乘以多少呢?
String xmlPath = DsKit.DocxUnzipDirectory + "word\\charts\\chart" + chartNumber + ".xml";
mul = DsKit.getMul(xmlPath);
for (List<String> row : source) {
String year = row.getFirst().split("\\.")[0];
year = year.replace("年", "");
String q = row.get(1);
if (StrKit.isBlank(q)) {
q = "0";
}
double x = Double.parseDouble(q) * mul;
String v = String.format("%.2f", (x > 1000 ? x / 10000 : x));//如果数值大于1000则计算以万为单位否则就保留原来的数字
Row outRow = outSheet.createRow(++rowIndex);
if (Integer.parseInt(year) < 2023) {
DsKit.putData(outRow, Arrays.asList(cityName, areaName, year, v, ""), dataStyle);
} else if (Integer.parseInt(year) > 2023) {
DsKit.putData(outRow, Arrays.asList(cityName, areaName, year, "", v), dataStyle);
} else {
DsKit.putData(outRow, Arrays.asList(cityName, areaName, year, v, v), dataStyle);
}
}
}
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}

@ -0,0 +1,154 @@
package com.dsideal.base.Tools.FillData.KaiFaArea;
import cn.hutool.core.io.FileUtil;
import com.dsideal.base.DataEase.Model.DataEaseModel;
import com.dsideal.base.Tools.FillData.DataEaseKit.DsKit;
import com.dsideal.base.Tools.Util.LocalMysqlConnectUtil;
import com.jfinal.kit.StrKit;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.dom4j.DocumentException;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class A9 {
//示例Excel
static String sampleExcelPath = "D:\\dsWork\\YunNanDsBase\\Doc\\待处理\\区\\【9】城镇&乡村人口变化及预测-双\\城镇&乡村人口变化及预测-双.xlsx";
//源文件
static String parentPath = "D:\\dsWork\\YunNanDsBase\\缺失的三个开发区";
public static void main(String[] args) throws IOException, InvalidFormatException, InterruptedException, DocumentException {
//初始化数据库连接
LocalMysqlConnectUtil.Init();
//结果Excel
XSSFWorkbook outWorkbook = new XSSFWorkbook();
//结果Sheet
XSSFSheet outSheet = DsKit.createSheet(outWorkbook);
//样式
XSSFCellStyle headerStyle = DsKit.getHeaderStyle(outWorkbook);
XSSFCellStyle dataStyle = DsKit.getDataStyle(outWorkbook);
//如果样例文件是xls格式则转化为xlsx格式
sampleExcelPath = DsKit.convertXlsToXlsx(sampleExcelPath);
//拷贝文件头
DsKit.copyHead(sampleExcelPath, outSheet, headerStyle);
//目标Excel,就是把文件名解析出来后,后面添加上【成果】,需要动态计算获取,不能写死
String excelPath = sampleExcelPath.replace(".xlsx", "【成果】.xlsx");
DsKit.delExcel(excelPath);
//找到parentPath下一级目录中所有文件
List<File> files = FileUtil.loopFiles(parentPath, file -> true);
int rowIndex = 0;
//处理这个目录
if (files != null) {
for (File file : files) {
//判断file是不是目录是目录的需要跳过
if (file.isDirectory()) continue;
if (!file.getName().endsWith(".docx") || file.getName().startsWith("~"))
continue;
String areaName = "阳宗海";
if (file.getName().contains("磨憨")) {
areaName = "磨憨-磨丁合作区";
} else if (file.getName().contains("经开")) {
areaName = "经开区";
}
//市州名称
String cityName = "昆明市";
if (StrKit.isBlank(cityName) || StrKit.isBlank(areaName)) {
System.out.println("发现异常数据,请人工处理:" + file.getName());
System.exit(0);
}
//县区名称
System.out.println("正在进行" + cityName + "-" + areaName + "的数据填充~");
int chartNumber = 2;
List<List<String>> source1 =
DsKit.getChartData(file.getAbsolutePath(), chartNumber, 0);
//需要处理下人与万人的单位兼容
int mul = 1;
if (source1 != null) {
//本例中要乘以多少呢?
String xmlPath = DsKit.DocxUnzipDirectory + "word\\charts\\chart" + chartNumber + ".xml";
mul = DsKit.getMul(xmlPath);
for (List<String> row : source1) {
String year = row.getFirst().split("\\.")[0];
year = year.replace("年", "");
Row outRow = outSheet.createRow(++rowIndex);
String q1 = row.get(1);
if (StrKit.isBlank(q1)) {
q1 = "0";
}
double x = Double.parseDouble(q1) * mul;
String v1 = String.format("%.2f", (x > 1000 ? x / 10000 : x));
String q2 = "0";
try {
q2 = row.get(2);
if (StrKit.isBlank(q2)) {
q2 = "0";
}
} catch (Exception err) {
}
x = Double.parseDouble(q2) * mul;
String v2 = String.format("%.2f", (x > 1000 ? x / 10000 : x));
DsKit.putData(outRow, Arrays.asList(cityName, areaName, year.replace("年份", "").replace("年", ""), v1, "", v2, ""), dataStyle);
}
}
chartNumber = 3;
List<List<String>> source2 =
DsKit.getChartData(file.getAbsolutePath(), chartNumber, 1);
if (source2 != null) {
//本例中要乘以多少呢?
String xmlPath = DsKit.DocxUnzipDirectory + "word\\charts\\chart" + chartNumber + ".xml";
mul = DsKit.getMul(xmlPath);
for (List<String> row : source2) {
String year = row.getFirst().split("\\.")[0];
year = year.replace("年", "");
Row outRow = outSheet.createRow(++rowIndex);
String q1 = row.get(1);
if (StrKit.isBlank(q1)) {
q1 = "0";
}
String v1 = String.format("%.2f", Double.parseDouble(q1) * mul / 10000);
String q2 = "0";
try {
q2 = row.get(2);
if (StrKit.isBlank(q2)) {
q2 = "0";
}
} catch (Exception err) {
}
double x = Double.parseDouble(q2) * mul;
String v2 = String.format("%.2f", (x > 1000 ? x / 10000 : x));
DsKit.putData(outRow, Arrays.asList(cityName, areaName, year.replace("年份", "").replace("年", ""), "", v1, "", v2), dataStyle);
}
}
}
}
//保存文件
DsKit.saveExcel(excelPath, outWorkbook);
System.out.println("县区所有文件处理完成!");
}
}
Loading…
Cancel
Save