博文
管理信息系统软件生产线源码59-61
|||
版本1
59.源码59，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/**
* 程序文件名：dataStatistic3.java
* 作者：程学先
* 用途：对数据表每条记录中有关字段中的数据进行横向计算， 为方便设计，最终结果统一放在“临时表”中，
* 如果数据库中原来存在临时表，该表将先删除。 统计结果或修改某一列的数据，或放在新生的一列中。 完成日期：2013年1月22日
* 必须提供的参数：数据库“表名”、要求统计的字段名表“统计字段名集”、 统计类型要求结果字段名：“结果字段名”、“关键字段名”。
* 可选参数：“字段号表”、“按钮号表”。 本程序包括：统计、显示、打印、导出、退出等5个按钮。
* 其中打印要求要求先利用程序printFormat1.java生成格式文件
* 显示调用程序tableTenance.java显示，可以再排序显示，也可调用JAVA的打印类打印。
* 导出调用通用导出程序，可以选择纯文本文件、Office文件组织导出。 操作方法与注意事项：
* 在要求统计的字段名表“字段号表2”处可以输入多个字段名，为准备求和等统计的字段名。
* 输入字段名的数量、数据类型及意义见下面关于p01、p02、p03、……、p38说明的括号中的内容。
* 例如，如果统计要求选p01，即要求求统计方差，则可以输入三个以上的字段名， 对每条记录中这多个字段的数据求统计方差值。
* 又例如，统计要求为p04，即求根据某一整数型字段中的数据，求将其变为简述中文大写元角分表示的数据
* 在“字段号表3”处可以输入单个字段名，为保存统计结果的字段名， 如果为已有字段名，将用统计数据更新该字段数据，否则新生成该字段。
* 在“统计要求”处的参数只能为p01、p02、p03、……、p35中某一个。 其意义为： P01：统计方差∑(Xn-μ)^2
* /(n-1)（标准偏差的平方）(数字类型字段名1,数字类型字段名2 [,数字类型字段名3 ...]) P02：标准偏差Sqr(∑(Xn-μ)^2
* /(n-1))(数字类型字段名1,数字类型字段名2 [,数字类型字段名3 ...])
* P03：平均偏差∑(|Xn-μ|)/n(数字类型字段名1,数字类型字段名2 [,数字类型字段名3 ...])
* P04：数字变为中文大写元角分(壹仟零叁拾元)(数字类型字段名) P05：数字变为中文元角分(一千零二十元)(数字类型字段名)
* P06：数字变为表格格式中文大写元角分(壹仟零佰贰拾零元)(数字类型字段名) P07：数字变为表格格式中文元角分(一千零百二十零元)(数字类型字段名)
* P08：变表格格式中文元角分(一仟零三十元零三角)为数字(字符类型字段名)
* P09：变表格格式中文大写元角分(壹仟零百贰拾零元叁角零分)为数字(字符类型字段名)
* P10：变中文元角分(亿,千,百,十,万,千,百,十,元,零,一,二,三,四,五,六,七,八,九)为数字 (字符类型字段名)
* P11：变大写中文(亿,仟,佰,拾,万,仟,佰,拾,元,零,壹,贰,叁,肆,伍,陆,柒,捌,玖)为数字 (字符类型字段名)
* P12：用大写字母返回指定的字符表达式(字符类型字段名)
* P13：对2个或3个表根据关键字名、关键字名1进行全连接，加上结果字段，根据字段序号生成并显示临时表
* P14：返回数字型星期值(日期类型字段)或(日期时间类型字段) P15：返回年份(日期类型字段)
* P16：返回字符型星期值(日期类型字段)或(日期时间类型字段) P17：日期时间表达式的小时部分(日期时间类型字段) 或(时间类型字段)
* P18：日期时间型表达式中的分钟部分(日期时间类型字段) 或(时间类型字段) P19：日期或日期时间表达式的月份值(日期时间类型字段)
* P20：日期时间型表达式中的秒钟部分(日期时间类型字段) 或(时间类型字段) P21：日期时间表达式中返回一个日期值(日期时间类型字段)
* P22：返回给定日期表达式中二个日期数据前一个日期减后一个日期间隔天数(二个日期类型字段，逗号分隔。)
* P23：以日期时间值返回当前的日期和时间(日期类型字段) P25：变日期为数字年月日（2003年 1月15日）(日期类型字段)
* P26：变日期格式为字符****.**.**格式(日期类型字段) ) P27：变日期格式为字符****-**-**格式(日期类型字段)
* P28：变日期格式为字符********格式(YYYYMMDD)(日期类型字段) P29：变中文年月日(二零零三年元月十五日)为日期格式(字符类型字段名)
* P30：变数字年月日（2003年 1月15日）格式为日期格式(字符类型字段名)
* P31：返回给定日期或日期时间表达式的月份英文名称(日期类型字段)或(日期时间类型字段) P32：求和(数字类型字段名1,数字类型字段名2
* [,数字类型字段名3 ...])。 P33：求平均(数字类型字段名1,数字类型字段名2 [,数字类型字段名3 ...])。
* P34：求最大(数字类型字段名1,数字类型字段名2 [,数字类型字段名3 ...])。 P35：求最小(数字类型字段名1,数字类型字段名2
* [,数字类型字段名3 ...])。 P36：根据字符串求变换为UTF-16BE码(字符类型字段名)
* P37：根据接口参数文件中规定的条件将某字段数据改为新值，或产生新字段填充新值。 接口参数文件格式：序号。目标字段。条件表达式。计算公式。
* 例如：0。金额。序号>='0'。入库单价*入库数量。 1。金额。序号>='0'。入库单价*入库数量-出库单价*出库数量。
* P38：根据“统计字段名集”中的公式计算求值将某字段数据改为新值，或产生新字段填充新值。
* 调用tenanceEval1.tenanceeval1(String 数学表达式)完成求值， 因此可以采用更丰富的函数完成计算。
* 支持函数：sqrt,square,ceil,sin,cos,asin,acon.tan.atan,log,exp
* 注意计算公式在“统计字段名集”中输入，不能用字段序号。 必须手工输入由字段名、函数名、常数（只能是整型或双精度数）、括号、四则运算符号构成的公式。
* 可以联系代码表、字典表进行查询。 如果涉及代码表，在生成菜单程序时，在填表名时，应当先在列表框中选主表，再依次选代码表。
* 如果涉及字典表，将根据字典表给定的对应关系变换标签。 要求在当前数据库中有一个表的名字为某某某字典表，
* 即表名最后3个字是“字典表”，本程序将根据该表变换。 要求该表中只有二个字段，第一个字段（命名为字段名）中内容为所查询的数据表中字段名，
* 第二个字段（命名为标签名）内容为变换后的标签名。 所有统计字段名称要按变换前字段名提供。
* 本程序未对输入内容的数据类型、格式进行检查，如果出错或结果不正确，请检查修改输入参数值。
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.io.UnsupportedEncodingException;
public class dataStatistic3 extends JFrame {
static dataStatistic3 frame = new dataStatistic3(); // 创建窗体
private static JTable table; // 创建表格
static Connection con1; // 连接数据库
static String url;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta4;
static ResultSet rs;
static int 窗口宽 = 800, 窗口高 = 630;
static int 列数; // 数据表列数
static String[][] 列名; // 数据表列名
static String[] 表格列名;
static String 关键字名, 关键字名1;
static String[] 列数据类型; // 存放当前记录各字段数据类型的数组
static int[] 列数据宽度, 列小数位数;
static int 记录条数 = 0;
static int 当前记录号;
static String[][] 表格数据;// 存放表格数据的数组
static String[][] 表格数据1;
static DefaultTableModel model;
static String 表名, 表名表, 表名0; // 数据表名
static String 原字段名集合 = "";
static String 字典表名;
static String 按钮号表;
static String 字段号表;
static String 统计字段名表, 统计字段名表0;
static int[] 统计字段序号;
static String 结果字段名;
static int 结果字段名0; // 结果字段类型
static String 连接串;
static String 统计要求;
static String s1 = "", s2 = "", s3 = "";
static String s4 = "", s8 = "", s9 = "", T1 = "";
static int c = 0, b = 0, 表格宽度 = 0;
static JPanel panel = new JPanel(false); // 定义面板
static JScrollPane scrollPane = new JScrollPane();
static String[] 按钮集 = null;
static String 要求按钮号表;
static int 按钮数 = 0, 按钮宽 = 0;
static String 字段名表 = "", 字段名表0 = "";
public static void means(String[] parameter) {
frame = new dataStatistic3();
窗口宽 = 800;
窗口高 = 630;
记录条数 = 0;
原字段名集合 = "";
s1 = "";
s2 = "";
s3 = "";
s4 = "";
s8 = "";
s9 = "";
T1 = "";
c = 0;
b = 0;
表格宽度 = 0;
panel = new JPanel(false); // 定义面板
scrollPane = new JScrollPane();
String[] 按钮集01 = { "统计", "显示", "导出", "退出" };
按钮集 = new String[按钮集01.length];
按钮数 = 0;
for (int i0 = 0; i0 < 按钮集01.length; i0++)
按钮集[i0] = 按钮集01[i0];
if (parameter[11].length() > 0) {
要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号
// 将中文分号、冒号、句号、英文分号统一为英文分号
要求按钮号表 = 要求按钮号表.replaceAll("；", ";");
要求按钮号表 = 要求按钮号表.replaceAll("。", ";");
要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
要求按钮号表 = 要求按钮号表.replaceAll("：", ";");
if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求
String s601[] = 要求按钮号表.split(",");
要求按钮号表 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
按钮集[Integer.parseInt((s602[0]))] = s602[1];
要求按钮号表 = 要求按钮号表 + "," + s602[0];// 只留号，去更名
按钮数++;
} else {
要求按钮号表 = 要求按钮号表 + "," + s601[i01];// 只留号，原无更名
按钮数++;
}
}
} // 如果没有按钮更名要求，要求按钮号长度又大于0，保持原有摸样
else {
String s601[] = 要求按钮号表.split(",");
要求按钮号表 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
要求按钮号表 = s601[i01];
else
要求按钮号表 = 要求按钮号表 + "," + s601[i01];
按钮数++;
}
}
} else {
要求按钮号表 = ""; // 没输入要求按钮号，定全部按钮号
for (int i1 = 0; i1 < 按钮集.length; i1++) {
if (i1 == 0)
要求按钮号表 = 要求按钮号表 + i1;
else
要求按钮号表 = 要求按钮号表 + "," + i1;
按钮数++;
}
}
要求按钮号表 = "," + 要求按钮号表 + ",";
窗口宽 = main1.窗口宽;
窗口高 = main1.窗口高;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);// 宽度参数
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
窗口宽 = m1;
窗口高 = m2;
}
} catch (Exception e2) {
}
表名0 = parameter[4]; // 数据表名
String[] v01 = 表名0.split(",");
表名 = v01[0];
s8 = parameter[5]; // 接口表名
s9 = parameter[20]; // 连接条件
表名表 = "," + parameter[0] + ",";
字段号表 = parameter[8];
关键字名 = parameter[6];
关键字名1 = parameter[7];
连接串 = parameter[20];
if (关键字名.indexOf(".") > 0) // 20150711
关键字名 = 关键字名.substring(关键字名.indexOf(".") + 1, 关键字名.length());
if (关键字名1.indexOf(".") > 0) // 20150711
关键字名1 = 关键字名1.substring(关键字名1.indexOf(".") + 1, 关键字名1.length());
按钮号表 = "," + parameter[11] + ",";
统计字段名表 = parameter[9];
统计字段名表0 = 统计字段名表;
结果字段名 = parameter[10];
String[] ss = parameter[13].split(" ");
统计要求 = ss[0];
if ((统计要求.equalsIgnoreCase("p37")) && (表名表.indexOf(",") > 0))
JOptionPane
.showMessageDialog(null, "本统计项要求选单表操作，请注意输入到表名集中只能有一个表！");
字段名表 = parameter[19];
字段名表0 = parameter[19];
原字段名集合 = 字段名表;
if (字段名表.substring(字段名表.length() - 1).equalsIgnoreCase(","))
字段名表 = 字段名表.substring(0, 字段名表.length() - 1);
String 表名表 = parameter[0];
String[] l3 = 字段名表.split(",");
字典表名 = "";
String[] t1;
b = 0;
c = 0;
String s11 = 表名;
if (表名.indexOf(",") > 0) {
String[] s12 = 表名.split(",");
s11 = s12[0];
}
if (表名表.lastIndexOf(s11 + "字典表") > 0) {
t1 = 表名表.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(s11 + "字典表") >= 0)
字典表名 = t1[i];
}
String[] l1;
if (字段号表.length() > 0) {
l1 = 字段号表.split(",");
int[] l2 = new int[l1.length];
for (int i = 0; i < l1.length; i++) {
l2[i] = Integer.valueOf(l1[i]);
}
列数 = l1.length;
列名 = new String[2][列数];
for (int i = 0; i < 列数; i++) {
列名[0][i] = l3[l2[i]];
列名[1][i] = 列名[0][i];
}
} else {
列数 = l3.length;
列名 = new String[2][列数];
for (int i = 0; i < 列数; i++) {
列名[0][i] = l3[i];
列名[1][i] = 列名[0][i];
}
}
字段名表 = "";
for (int i = 0; i < 列数; i++)
if (i < 列数 - 1)
字段名表 = 字段名表 + 列名[0][i] + ",";
else
字段名表 = 字段名表 + 列名[0][i];
if (表名表.indexOf(",临时表,") >= 0) { // //////////////
try // 利用try尝试性删除临时表，有则删除，无也利用catch跳过
{
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "drop table 临时表";
PreparedStatement stat5 = con.prepareStatement(s4);
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "临时表不存在！");
} // 如果已经存在临时表，则删除
}
s1 = "";
for (int i = 0; i < 列数; i++)
s1 = s1 + 列名[0][i] + ",";
s1 = s1.substring(0, s1.length() - 1);
String s5 = "";
结果字段名0 = 0; // 设结果字段为整型字段
if (("," + 字段名表 + ",").lastIndexOf("," + 结果字段名 + ",") < 0) {
if ((",01,02,03,32,33,34,35,37,").lastIndexOf(","
+ 统计要求.substring(1, 统计要求.length()) + ",") >= 0) {
s5 = "alter table " + 表名 + " add " + 结果字段名
+ " numeric (14,3) ";
结果字段名0 = 0; // 设结果字段为整型字段
} else if ((",14,15,17,18,19,20,21,22,").lastIndexOf(","
+ 统计要求.substring(1, 统计要求.length()) + ",") >= 0) {
s5 = "alter table " + 表名 + " add " + 结果字段名 + " int ";
结果字段名0 = 0; // 设结果字段为整型字段
} else if ((",16,31,").lastIndexOf(","
+ 统计要求.substring(1, 统计要求.length()) + ",") >= 0) {
s5 = "alter table " + 表名 + " add " + 结果字段名 + " char (6) ";
结果字段名0 = 1; // 设结果字段为整型字段
} else if ((",23,24,25,26,27,").lastIndexOf(","
+ 统计要求.substring(1, 统计要求.length()) + ",") >= 0) {
s5 = "alter table " + 表名 + " add " + 结果字段名 + " char (12) ";
结果字段名0 = 0; // 设结果字段为整型字段
} else {
s5 = "alter table " + 表名 + " add " + 结果字段名 + " char (20) ";
结果字段名0 = 1; // 设结果字段为字符型字段
}
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s5);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "添加字段失败！");
} // 如果已经存在临时表，已先期删除
}
try {
s1 = "select * from " + 表名;
T1 = s1;
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
列数 = rsmd4.getColumnCount(); // 获取列数
列名 = new String[2][列数];
列数据类型 = new String[列数]; // 定义列字段类型数组
列数据宽度 = new int[列数]; // 定义列数据宽度
表格宽度 = 0;
for (int i = 0; i < 列数; i++) {
列名[0][i] = rsmd4.getColumnName(i + 1);
列名[1][i] = 列名[0][i];
列数据类型[i] = rsmd4.getColumnTypeName(i + 1);
if (列名[0][i].equalsIgnoreCase(结果字段名))
if (",bit,smallint,integer,int,tinyint,decimal,numeric,real,money,smallmoney,bigint,float,double,"
.lastIndexOf(列数据类型[i]) >= 0)
结果字段名0 = 0;
else
结果字段名0 = 1;
列数据宽度[i] = rsmd4.getColumnDisplaySize(i + 1);
if (列数据宽度[i] < 列名[0][i].length())
列数据宽度[i] = 列名[0][i].length();
if (列数据宽度[i] < 列名[1][i].length())
列数据宽度[i] = 列名[1][i].length();
if (列数据宽度[i] > 50)
列数据宽度[i] = 50;
表格宽度 = 表格宽度 + 列数据宽度[i];
}
String[] b4 = 统计字段名表.split(",");
String[] s7 = parameter[19].split(","); // 用筛选前全部字段名
String s4[];
if (统计字段名表.length() == 0)
统计字段名表 = "0"; // 除P37、P38外统计字段名表都不会空
s4 = 统计字段名表.split(","); // 原为字段号，下面求字段名
统计字段名表 = "";
if (统计要求.indexOf("38") < 0)
for (int i = 0; i < s4.length; i++) {
s4[i] = s7[Integer.parseInt(s4[i])]; // 变换为字段名
if (统计字段名表.length() == 0)
统计字段名表 = s4[i];
else
统计字段名表 = 统计字段名表 + "," + s4[i];
}
统计字段序号 = new int[b4.length];
for (int j = 0; j < b4.length; j++)
for (int i = 0; i < 列数; i++) {
if (s4[j].equalsIgnoreCase(列名[0][i]))
统计字段序号[j] = i;
}
表格列名 = new String[列数];
for (b = 0; b < 列数; b++) {
表格列名[b] = 列名[1][b];
}
b4 = 结果字段名.split(",");
结果字段名 = "";
for (int k = 0; k < b4.length; k++) {
if (b4[k].indexOf(".") > 0)
b4[k] = b4[k].substring(b4[k].indexOf(".") + 1);
if (k < b4.length - 1)
结果字段名 = 结果字段名 + b4[k] + ",";
else
结果字段名 = 结果字段名 + b4[k];
}
记录条数 = 0;
rs.last();
记录条数 = rs.getRow();
表格数据 = new String[记录条数][列数];
rs.absolute(1);
c = 0; // 行号
b = 0; // 列号
while (c < 记录条数) {
rs.absolute(c + 1);
while (b < 列数) {
表格数据[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据出错！");
}
if (字典表名.length() > 0) {
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 字典表名;
rs = sta4.executeQuery(s1);
String s14 = "";
String s15 = "";
b = 1;
while (rs.absolute(b)) {
b++;
s14 = rs.getString(1).trim(); // 字段名
s15 = rs.getString(2).trim();
for (int j = 0; j < 列数; j++) {
if (列名[0][j].trim().equalsIgnoreCase(s14.trim())) {
列名[1][j] = s15;
表格列名[j] = s15;
break;
} else if ((列名[0][j].trim() + ",").indexOf("." + s14
+ ",") > 0) {
列名[1][j] = 列名[1][j].replace(s14, s15);
表格列名[j] = s15;
break;
}
}
}
rs.close();
con1.close();
sta4.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错！");
}
}
frame.setTitle("横向数据统计部件。 作者：程学先"); // 设置窗体标题
frame.setBounds(10, 10, 窗口宽, 窗口高); // 设置窗体的位置和大小
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
frame.setLayout(null);
panel = new JPanel(false); // 定义面板
panel.setLayout(null);
panel.setBounds(10, 10, 窗口宽, 窗口高);
scrollPane = new JScrollPane();
scrollPane.setBounds(0, 0, 窗口宽 - 20, 窗口高 - 120);
panel.add(scrollPane);
model = new DefaultTableModel(表格数据, 列名[1]);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < 列数; i++) {
TableColumn tc = table.getColumn(列名[1][i]);
tc.setPreferredWidth(列数据宽度[i] * 8);
tc.setMaxWidth(列数据宽度[i] * 8);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
int j = 0;
按钮号表 = 要求按钮号表;
if (按钮号表.length() < 3)
j = 5;
else
for (int i = 0; i < 5; i++)
if (按钮号表.lastIndexOf("," + i + ",") >= 0)
j = j + 1;
int 按钮宽 = (窗口宽 - 30) / 按钮数;
int 按钮左边距 = 5;
JButton 统计 = new JButton(按钮集[0]);
统计.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
switch (Integer.parseInt(统计要求.substring(1, 统计要求.length()))) {
case 1: {
p01();
refrese();
break;
}
case 2: {
p02();
refrese();
break;
}
case 3: {
p03();
refrese();
break;
}
case 4: {
p04();
refrese();
break;
}
case 5: {
p05();
refrese();
break;
}
case 6: {
p06();
refrese();
break;
}
case 7: {
p07();
refrese();
break;
}
case 8: {
p08();
refrese();
break;
}
case 9: {
p09();
refrese();
break;
}
case 10: {
p10();
refrese();
break;
}
case 11: {
p11();
refrese();
break;
}
case 12: {
p12();
refrese();
break;
}
case 13: {
p13();
refrese();
break;
}
case 14: {
p14();
refrese();
break;
}
case 15: {
p15();
refrese();
break;
}
case 16: {
p16();
refrese();
break;
}
case 17: {
p17();
refrese();
break;
}
case 18: {
p18();
refrese();
break;
}
case 19: {
p19();
refrese();
break;
}
case 20: {
p20();
refrese();
break;
}
case 21: {
p21();
refrese();
break;
}
case 22: {
p22();
refrese();
break;
}
case 23: {
p23();
refrese();
break;
}
case 24: {
p24();
refrese();
break;
}
case 25: {
p25();
refrese();
break;
}
case 26: {
p26();
refrese();
break;
}
case 27: {
p27();
refrese();
break;
}
case 28: {
p28();
refrese();
break;
}
case 29: {
p29();
refrese();
break;
}
case 30: {
p30();
refrese();
break;
}
case 31: {
p31();
refrese();
break;
}
case 32: {
p32();
refrese();
break;
}
case 33: {
p33();
refrese();
break;
}
case 34: {
p34();
refrese();
break;
}
case 35: {
p35();
refrese();
break;
}
case 36: {
try {
p36();
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
refrese();
break;
}
case 37: {
p37();
refrese();
break;
}
case 38: {
p38();
refrese();
break;
}
}
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",0,") >= 0)) {
统计.setBounds(按钮左边距, 窗口高 - 90, 按钮宽, 20);
panel.add(统计);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 显示 = new JButton(按钮集[1]);
显示.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
tableTenance.tableModel(1000, 600, 列名[1], 列数据宽度, 表格数据, 列数据类型);
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",1,") >= 0)) {
显示.setBounds(按钮左边距, 窗口高 - 90, 按钮宽, 20);
panel.add(显示);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 导出 = new JButton(按钮集[2]);
导出.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataTransfer0.Trans(列名[1], 列数据类型, 列数据宽度, "", 表格数据, 表名);
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",2,") >= 0)) {
导出.setBounds(按钮左边距, 窗口高 - 90, 按钮宽, 20);
panel.add(导出);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 退出 = new JButton(按钮集[3]);
退出.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",3,") >= 0)) {
退出.setBounds(按钮左边距, 窗口高 - 90, 按钮宽, 20);
panel.add(退出);
按钮左边距 = 按钮左边距 + 按钮宽;
}
frame.getContentPane().add(panel, null);
frame.setVisible(true);
frame.getContentPane().add(panel, BorderLayout.SOUTH);
}
public static void refrese() {
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs = sta4.executeQuery(T1);
rs.last();
记录条数 = rs.getRow();
表格数据 = new String[记录条数][列数];
rs.absolute(1);
c = 0; // 行号
b = 0; // 列号
while (c < 记录条数) {
rs.absolute(c + 1);
while (b < 列数) {
表格数据[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据出错！");
}
scrollPane.setBounds(0, 0, 窗口宽 - 20, 窗口高 - 120);
model = new DefaultTableModel(表格数据, 列名[1]);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < 列数; i++) {
TableColumn tc = table.getColumn(列名[1][i]);
tc.setPreferredWidth(列数据宽度[i] * 8);
tc.setMaxWidth(列数据宽度[i] * 8);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
panel.add(scrollPane);
}
public static void p01() {
String[] b4 = 统计字段名表.split(",");
if (b4.length < 2) {
JOptionPane.showMessageDialog(null, "统计字段少于2！");
return;
}
s1 = "";
for (int i = 0; i < b4.length; i++) {
s1 = s1 + b4[i] + "+";
}
s1 = "(" + s1.substring(0, s1.length() - 1) + ")/" + b4.length;
s2 = "";
for (int i = 0; i < b4.length; i++) {
s2 = s2 + "(" + b4[i] + "-" + s1 + ")" + "*" + "(" + b4[i] + "-"
+ s1 + ")" + "+";
}
s2 = s2.substring(0, s2.length() - 1);
s2 = "update " + 表名 + " set " + 结果字段名 + " = (" + s2 + ")/"
+ (b4.length - 1);
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s2);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p02() {
String[] b4 = 统计字段名表.split(",");
if (b4.length < 2) {
JOptionPane.showMessageDialog(null, "统计字段少于2！");
return;
}
s1 = "";
for (int i = 0; i < b4.length; i++) {
s1 = s1 + b4[i] + "+";
}
s1 = "(" + s1.substring(0, s1.length() - 1) + ")/" + b4.length;
s2 = "";
for (int i = 0; i < b4.length; i++) {
s2 = s2 + "(" + b4[i] + "-" + s1 + ")" + "*" + "(" + b4[i] + "-"
+ s1 + ")" + "+";
}
s2 = s2.substring(0, s2.length() - 1);
s2 = "update " + 表名 + " set " + 结果字段名 + " = (" + s2 + ")/"
+ (b4.length - 1);
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s2);
s1 = "update " + 表名 + " set " + 结果字段名 + " = sqrt(" + 结果字段名 + ")";
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p03() {
String[] b4 = 统计字段名表.split(",");
s1 = "";
for (int i = 0; i < b4.length; i++) {
s1 = s1 + b4[i] + "+";
}
s1 = "(" + s1.substring(0, s1.length() - 1) + ")/" + b4.length;
s2 = "";
for (int i = 0; i < b4.length; i++) {
s2 = s2 + "sqrt((" + b4[i] + "-" + s1 + ")" + "*" + "(" + b4[i]
+ "-" + s1 + "))" + "+";
}
s2 = s2.substring(0, s2.length() - 1);
s2 = "update " + 表名 + " set " + 结果字段名 + " = (" + s2 + ")/" + b4.length;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s2);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p04() {
final HashMap<Integer, String> 变换 = new HashMap<Integer, String>();
final String[] 变换数值 = new String[] { "零", "壹", "贰", "叁", "肆", "伍", "陆",
"柒", "捌", "玖" };
变换.put(-2, "分");
变换.put(-1, "角");
变换.put(0, "元");
变换.put(1, "拾");
变换.put(2, "佰");
变换.put(3, "仟");
变换.put(4, "万");
变换.put(5, "拾");
变换.put(6, "佰");
变换.put(7, "仟");
变换.put(8, "亿");
变换.put(9, "拾");
变换.put(10, "佰");
变换.put(11, "仟");
变换.put(12, "万");
StringBuffer 变化值 = new StringBuffer();
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, 统计字段序号[0]) != null) {
s2 = model.getValueAt(i1, 统计字段序号[0]).toString();
s1 = "";
变化值 = new StringBuffer();
s2 = 零字处理(s2);
String 整数部分 = null;
String 小数部分 = null;
if (s2.contains(".")) {
整数部分 = s2.split("\\.")[0];
小数部分 = s2.split("\\.")[1];
} else {
整数部分 = s2;
}
if (整数部分.length() > 0) {
for (int i = 0; i < 整数部分.length(); i++) {
String 位值 = 整数部分.substring(i, i + 1);
int 十进制数位 = 整数部分.length() - i - 1;
Integer 位数值 = Integer.parseInt(位值.toString());
String 中文单位 = 变换.get(十进制数位);
String 中文数字 = 变换数值[Integer.parseInt(位值)];
if (位数值 == 0) {
if (十进制数位 % 4 != 0) {
中文单位 = "";
}
if (i < 整数部分.length() - 1) {
Integer 位数值1 = Integer.parseInt(整数部分.substring(
i + 1, i + 2));
if (位数值 == 0 && 位数值 == 位数值1)
中文数字 = "";
} else if (i == 整数部分.length() - 1)
中文数字 = "";
}
变化值.append(中文数字 + 中文单位);
}
}
if (小数部分 != null) {
整数部分 = 小数部分.substring(0, 1);
if (!"0".equalsIgnoreCase(整数部分))
变化值.append(变换数值[Integer.parseInt(整数部分)] + 变换.get(-1));
if (小数部分.length() == 2) {
整数部分 = 小数部分.substring(1, 2);
if (!"0".equalsIgnoreCase(整数部分))
变化值.append(变换数值[Integer.parseInt(整数部分)]
+ 变换.get(-2));
}
}
s1 = "";
for (int i = 0; i < 变化值.toString().length(); i++)
if ((变化值.toString().substring(i, i + 1)
.equalsIgnoreCase("零"))
&& (i < 变化值.toString().length() - 1)
&& (变化值.toString().substring(i + 1, i + 2)
.equalsIgnoreCase("万")))
s1 = s1;
else
s1 = s1 + 变化值.toString().substring(i, i + 1);
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + s1
+ "' where " + 统计字段名表 + " ='" + s2 + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
private static String 零字处理(String string1) {
if ("0".equalsIgnoreCase(string1.substring(0, 1))) {
return 零字处理(string1.substring(1, string1.length()));
} else if (string1.contains(",")) {
return 零字处理(string1.replaceAll(",", ""));
} else {
return string1;
}
}
public static void p05() {
final HashMap<Integer, String> 变换 = new HashMap<Integer, String>();
final String[] 变换数值 = new String[] { "零", "一", "二", "三", "四", "五", "六",
"七", "八", "九" };
变换.put(-2, "分");
变换.put(-1, "角");
变换.put(0, "元");
变换.put(1, "十");
变换.put(2, "百");
变换.put(3, "千");
变换.put(4, "万");
变换.put(5, "十");
变换.put(6, "百");
变换.put(7, "仟");
变换.put(8, "亿");
变换.put(9, "十");
变换.put(10, "百");
变换.put(11, "千");
变换.put(12, "万");
StringBuffer 变化值 = new StringBuffer();
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, 统计字段序号[0]) != null) {
s2 = model.getValueAt(i1, 统计字段序号[0]).toString();
s1 = "";
变化值 = new StringBuffer();
s2 = 零字处理(s2);
String 整数部分 = null;
String 小数部分 = null;
if (s2.contains(".")) {
整数部分 = s2.split("\\.")[0];
小数部分 = s2.split("\\.")[1];
} else {
整数部分 = s2;
}
if (整数部分.length() > 0) {
for (int i = 0; i < 整数部分.length(); i++) {
String 位值 = 整数部分.substring(i, i + 1);
int 十进制数位 = 整数部分.length() - i - 1;
Integer 位数值 = Integer.parseInt(位值.toString());
String 中文单位 = 变换.get(十进制数位);
String 中文数字 = 变换数值[Integer.parseInt(位值)];
if (位数值 == 0) {
if (十进制数位 % 4 != 0) {
中文单位 = "";
}
if (i < 整数部分.length() - 1) {
Integer 位数值1 = Integer.parseInt(整数部分.substring(
i + 1, i + 2));
if (位数值 == 0 && 位数值 == 位数值1)
中文数字 = "";
} else if (i == 整数部分.length() - 1)
中文数字 = "";
}
变化值.append(中文数字 + 中文单位);
}
}
if (小数部分 != null) {
整数部分 = 小数部分.substring(0, 1);
if (!"0".equalsIgnoreCase(整数部分))
变化值.append(变换数值[Integer.parseInt(整数部分)] + 变换.get(-1));
if (小数部分.length() == 2) {
整数部分 = 小数部分.substring(1, 2);
if (!"0".equalsIgnoreCase(整数部分))
变化值.append(变换数值[Integer.parseInt(整数部分)]
+ 变换.get(-2));
}
}
s1 = "";
for (int i = 0; i < 变化值.toString().length(); i++)
if ((变化值.toString().substring(i, i + 1)
.equalsIgnoreCase("零"))
&& (i < 变化值.toString().length() - 1)
&& (变化值.toString().substring(i + 1, i + 2)
.equalsIgnoreCase("万")))
s1 = s1;
else
s1 = s1 + 变化值.toString().substring(i, i + 1);
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + s1
+ "' where " + 统计字段名表 + " ='" + s2 + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p06() {
String x[] = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
String y[] = { "元", "十", "百", "千", "万", "十", "百", "千", "亿", "十" };
String y1[] = { "角", "分", " ", " ", " ", " ", " " };
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, 统计字段序号[0]) != null) {
s1 = model.getValueAt(i1, 统计字段序号[0]).toString().trim();
s2 = "";
String[] s6 = new String[1];
if (s2.lastIndexOf(".") > 0)
s6 = s1.split(".");
else
s6[0] = s1;
for (int k = 0; k < s6.length; k++)
for (int i = 0; i < s6[k].length(); i++)
for (int j = 0; j < 10; j++)
if (s6[k].substring(i, i + 1).equalsIgnoreCase(
"" + j))
s2 = s2 + x[j] + y[s6[k].length() - i - 1];
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + s2
+ "' where " + 统计字段名表 + " ='" + s1 + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p07() {
String x[] = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
String y[] = { "元", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾" };
String y1[] = { "角", "分", " ", " ", " ", " ", " " };
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, 统计字段序号[0]) != null) {
s1 = model.getValueAt(i1, 统计字段序号[0]).toString().trim();
s2 = "";
String[] s6 = new String[1];
if (s2.lastIndexOf(".") > 0)
s6 = s1.split(".");
else
s6[0] = s1;
for (int k = 0; k < s6.length; k++)
for (int i = 0; i < s6[k].length(); i++)
for (int j = 0; j < 10; j++)
if (s6[k].substring(i, i + 1).equalsIgnoreCase(
"" + j))
s2 = s2 + x[j] + y[s6[k].length() - i - 1];
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + s2
+ "' where " + 统计字段名表 + " ='" + s1 + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p08() {
String[] 单位 = { "亿", "千", "百", "十", "万", "千", "百", "十", "元" };
String[] 数据 = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十" };
int 数据值[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
String s = "";
int sum = 0, sum1 = 0;
int k = 0;
String x = "", x1 = "";
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, 统计字段序号[0]) != null) {
s = model.getValueAt(i1, 统计字段序号[0]).toString() + " ";
sum = 0;
sum1 = 0;
for (int i = 0; i < s.length() - 1; i++) {
x = s.substring(i, i + 1);
x1 = s.substring(i + 1, i + 2);
if (x1.equalsIgnoreCase("亿")) {
sum1 = sum1 + k;
sum = sum1 * 100000000;
sum1 = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("万")) {
sum1 = sum1 + k;
sum = sum + sum1 * 10000;
sum1 = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("千")) {
sum1 = sum1 + k * 1000;
i++;
continue;
}
if (x1.equalsIgnoreCase("百")) {
sum1 = sum1 + k * 100;
i++;
continue;
}
if (x1.equalsIgnoreCase("十")) {
sum1 = sum1 + k * 10;
i++;
continue;
}
if (x1.equalsIgnoreCase("元")) {
sum = sum + sum1 + k;
break;
}
}
}
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + sum + "' where "
+ 统计字段名表 + " ='" + s + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
public static void p09() {
String[] 单位 = { "亿", "仟", "佰", "拾", "万", "仟", "佰", "拾", "元" };
String[] 数据 = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖", "拾" };
int 数据值[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
String s = "";
int sum = 0, sum1 = 0;
int k = 0;
String x = "", x1 = "";
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, 统计字段序号[0]) != null) {
s = model.getValueAt(i1, 统计字段序号[0]).toString() + " ";
sum = 0;
sum1 = 0;
for (int i = 0; i < s.length() - 1; i++) {
x = s.substring(i, i + 1);
x1 = s.substring(i + 1, i + 2);
if (x1.equalsIgnoreCase("亿")) {
sum1 = sum1 + k;
sum = sum1 * 100000000;
sum1 = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("万")) {
sum1 = sum1 + k;
sum = sum + sum1 * 10000;
sum1 = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("仟")) {
sum1 = sum1 + k * 1000;
i++;
continue;
}
if (x1.equalsIgnoreCase("佰")) {
sum1 = sum1 + k * 100;
i++;
continue;
}
if (x1.equalsIgnoreCase("拾")) {
sum1 = sum1 + k * 10;
i++;
continue;
}
if (x1.equalsIgnoreCase("元")) {
sum = sum + sum1 + k;
break;
}
}
}
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + sum + "' where "
+ 统计字段名表 + " ='" + s + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
public static void p10() {
String[] 单位 = { "亿", "千", "百", "十", "万", "千", "百", "十", "元" };
String[] 数据 = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十" };
int 数据值[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
String s = "";
int sum = 0, sum1 = 0;
int k = 0;
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, 统计字段序号[0]) != null) {
s = model.getValueAt(i1, 统计字段序号[0]).toString() + " ";
String x = "", x1 = "";
sum = 0;
sum1 = 0;
for (int i = 0; i < s.length() - 1; i++) {
x = s.substring(i, i + 1);
x1 = s.substring(i + 1, i + 2);
for (int j = 0; j < 数据.length; j++)
if (x.trim().equalsIgnoreCase(数据[j].trim()))
k = j;
if (x1.trim().equalsIgnoreCase("亿")) {
sum1 = sum1 + k;
sum = sum1 * 100000000;
sum1 = 0;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("万")) {
sum1 = sum1 + k;
sum = sum + sum1 * 10000;
sum1 = 0;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("千")) {
sum1 = sum1 + k * 1000;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("百")) {
sum1 = sum1 + k * 100;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("十")) {
sum1 = sum1 + k * 10;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("元")) {
sum = sum + sum1 + k;
break;
}
}
}
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + sum + "' where "
+ 统计字段名表 + " ='" + s + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
public static void p11() {
String[] 单位 = { "亿", "仟", "佰", "拾", "万", "仟", "佰", "拾", "元" };
String[] 数据 = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖", "拾" };
int 数据值[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
String s = "";
int sum = 0, sum1 = 0;
int y = 0, k = 0;
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, 统计字段序号[0]) != null) {
s = model.getValueAt(i1, 统计字段序号[0]).toString() + " ";
s2 = "";
String x = "", x1 = "";
sum = 0;
sum1 = 0;
for (int i = 0; i < s.length() - 1; i++) {
x = s.substring(i, i + 1);
if (x.equalsIgnoreCase("元")) {
sum = sum + sum1;
break;
}
if (x.equalsIgnoreCase("亿")) {
sum = sum1 * 100000000;
sum1 = 0;
continue;
}
if (x.equalsIgnoreCase("万")) {
sum = sum + sum1 * 10000;
sum1 = 0;
continue;
}
if (x.equalsIgnoreCase("零"))
continue;
x1 = s.substring(i + 1, i + 2);
for (int j = 0; j < 数据.length; j++)
if (x.equalsIgnoreCase(数据[j]))
k = j;
if (x1.equalsIgnoreCase("亿")) {
sum1 = sum1 + k;
sum = sum1 * 100000000;
sum1 = 0;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("万")) {
sum1 = sum1 + k;
sum = sum + sum1 * 10000;
sum1 = 0;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("仟")) {
sum1 = sum1 + k * 1000;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("佰")) {
sum1 = sum1 + k * 100;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("拾")) {
sum1 = sum1 + k * 10;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("元")) {
sum = sum + sum1 + k;
break;
}
}
}
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + sum + "' where "
+ 统计字段名表 + " ='" + s + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
public static void p12() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = UPPER(" + 统计字段名表 + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p13() {
if (表名0.indexOf(",") < 0) {
JOptionPane.showMessageDialog(null, "要求至少有二表，彼此间用逗号分隔！");
return;
}
if (关键字名.length() == 0) {
JOptionPane.showMessageDialog(null, "要求有表1关键字名！");
return;
}
if (关键字名1.length() == 0) {
JOptionPane.showMessageDialog(null, "要求有表2关键字名，放在关键字名1中！");
return;
}
try // 利用try尝试性删除临时表，有则删除，无也利用catch跳过
{
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "drop table 临时表";
PreparedStatement stat5 = con.prepareStatement(s4);
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
} // 如果已经存在临时表，则删除
String[] s0 = 表名0.split(",");
String s01 = "";
s01 = "临时表";
s1 = "select " + s0[0] + ".* into " + s01 + " from " + s0[0]
+ " FULL JOIN " + s0[1] + " on " + s0[0] + "." + 关键字名 + "="
+ s0[1] + "." + 关键字名1;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "生成全连接表出错！");
}
}
public static void p36() throws UnsupportedEncodingException {
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, 统计字段序号[0]) != null) {
s1 = model.getValueAt(i1, 统计字段序号[0]).toString() + " ";
byte[] bs = s1.getBytes();
s2 = new String(bs, "UTF-16BE");
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + s2
+ "' where " + 统计字段名表 + " ='" + s1 + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p14() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = DatePart(weekday," + 统计字段名表
+ ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p15() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = datename(Year," + 统计字段名表
+ ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p16() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = datename(weekday," + 统计字段名表
+ ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p17() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = datename(Hour," + 统计字段名表
+ ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p18() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = datename(Minute," + 统计字段名表
+ ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p19() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = datename(Month," + 统计字段名表
+ ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p20() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = datename(Second," + 统计字段名表
+ ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p21() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = datename(Day," + 统计字段名表
+ ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p22() {
String[] s6 = 统计字段名表.split(",");
s1 = "update " + 表名 + " set " + 结果字段名 + " = DATEDIFF ( day," + s6[0]
+ "," + s6[1] + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p23() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = getdate()";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p24() {
String[] s6 = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
for (int i = 0; i < model.getRowCount(); i++) {
if (model.getValueAt(i, 统计字段序号[0]) != null) {
s1 = model.getValueAt(i, 统计字段序号[0]).toString();
s2 = "";
for (int j = 0; j < 4; j++) {
s2 = s2 + s6[Integer.parseInt(s1.substring(j, j + 1))];
}
s2 = s2 + "年";
if (s1.substring(5, 6).equalsIgnoreCase("1"))
s2 = s2 + "十";
if (s1.substring(6, 7).compareTo("0") > 0)
s2 = s2 + s6[Integer.parseInt(s1.substring(6, 7))];
s2 = s2 + "月";
if (s1.substring(8, 9).equalsIgnoreCase("1"))
s2 = s2 + "十";
else if (s1.substring(8, 9).equalsIgnoreCase("2"))
s2 = s2 + "二十";
else if (s1.substring(8, 9).equalsIgnoreCase("3"))
s2 = s2 + "三十";
if (s1.substring(9, 10).compareTo("0") > 0)
s2 = s2 + s6[Integer.parseInt(s1.substring(9, 10))];
s2 = s2 + "日";
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + s2
+ "' where ";
s2 = 统计字段名表 + " ='" + model.getValueAt(i, 统计字段序号[0]).toString()
+ "'";
s3 = s3 + s2;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p25() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = DATENAME (yy," + 统计字段名表
+ ")+'年'+DATENAME (mm," + 统计字段名表 + ")+'月'+DATENAME (dd,"
+ 统计字段名表 + ")+'日'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p26() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = CONVERT(varchar(100),"
+ 统计字段名表 + ",102)";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p27() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = CONVERT(varchar(100),"
+ 统计字段名表 + ",25)";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p28() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = CONVERT(varchar(100),"
+ 统计字段名表 + ",112)";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p29() {
String[] s6 = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
int n = 0;
for (int i = 0; i < model.getRowCount(); i++) {
if (model.getValueAt(i, 统计字段序号[0]) != null) {
s1 = model.getValueAt(i, 统计字段序号[0]).toString();
s2 = "";
for (int j = 0; j < s1.length(); j++) {
if (s1.substring(j, j + 1).equalsIgnoreCase("年"))
s2 = s2 + "-";
else if (s1.substring(j, j + 1).equalsIgnoreCase("月"))
s2 = s2 + "-";
else if (s1.substring(j, j + 1).equalsIgnoreCase("日"))
s2 = s2;
else if (s1.substring(j, j + 1).equalsIgnoreCase("元"))
s2 = s2 + "1";
else if (((s1.substring(j, j + 1).equalsIgnoreCase("十")) || ((s1
.substring(j, j + 1).equalsIgnoreCase("拾"))))
&& ((s1.substring(j + 1, j + 2)
.equalsIgnoreCase("月")) || ((s1.substring(
j + 1, j + 2).equalsIgnoreCase("日")))))
s2 = s2 + "10";
else if ((s1.substring(j, j + 1).equalsIgnoreCase("十"))
|| ((s1.substring(j, j + 1).equalsIgnoreCase("拾"))))
s2 = s2 + "1";
else if (((s1.substring(j, j + 2).equalsIgnoreCase("二十")) || ((s1
.substring(j, j + 2).equalsIgnoreCase("贰拾"))))
&& ((s1.substring(j + 2, j + 3)
.equalsIgnoreCase("月")) || ((s1.substring(
j + 2, j + 3).equalsIgnoreCase("日"))))) {
s2 = s2 + "20";
j++;
} else if ((s1.substring(j, j + 2).equalsIgnoreCase("二十"))
|| ((s1.substring(j, j + 2).equalsIgnoreCase("贰拾")))) {
s2 = s2 + "2";
j++;
} else if (((s1.substring(j, j + 2).equalsIgnoreCase("三十")) || ((s1
.substring(j, j + 2).equalsIgnoreCase("叁拾"))))
&& ((s1.substring(j + 2, j + 3)
.equalsIgnoreCase("月")) || ((s1.substring(
j + 2, j + 3).equalsIgnoreCase("日"))))) {
s2 = s2 + "30";
j++;
} else if ((s1.substring(j, j + 2).equalsIgnoreCase("三十"))
|| ((s1.substring(j, j + 2).equalsIgnoreCase("叁拾")))) {
s2 = s2 + "3";
j++;
} else {
for (int k = 0; k < 10; k++)
if (s1.substring(j, j + 1).equalsIgnoreCase(s6[k]))
n = k;
s2 = s2 + n;
}
}
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + s2
+ "' where ";
s2 = 统计字段名表 + " ='" + model.getValueAt(i, 统计字段序号[0]).toString()
+ "'";
s3 = s3 + s2;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p30() {
s1 = "update " + 表名 + " set " + 结果字段名 + " = DATENAME (yy," + 统计字段名表
+ ")+'年'+DATENAME (mm," + 统计字段名表 + ")+'月'+DATENAME (dd,"
+ 统计字段名表 + ")+'日'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p31() {
String[] s6 = { "", "January", "February", "March", "April", "May",
"June", "July", "August", "September", "October", "November",
"December" };
for (int i = 1; i <= 12; i++) {
s3 = "update " + 表名 + " set " + 结果字段名 + " = '" + s6[i]
+ "' where Month(" + 统计字段名表 + ") =" + i;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
public static void p32() {
String[] b4 = 统计字段名表.split(",");
s1 = "";
for (int i = 0; i < b4.length; i++) {
s1 = s1 + b4[i] + "+";
}
s1 = s1.substring(0, s1.length() - 1);
s1 = "update " + 表名 + " set " + 结果字段名 + " = " + s1;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p33() {
String[] b4 = 统计字段名表.split(",");
s1 = "";
for (int i = 0; i < b4.length; i++) {
s1 = s1 + b4[i] + "+";
}
s1 = s1.substring(0, s1.length() - 1);
s1 = "update " + 表名 + " set " + 结果字段名 + " = (" + s1 + ")/" + b4.length;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p34() {
String[] b4 = 统计字段名表.split(",");
统计字段序号 = new int[b4.length];
for (int j = 0; j < b4.length; j++)
for (int i = 0; i < 列数; i++) {
if (b4[j].equalsIgnoreCase(列名[0][i]))
统计字段序号[j] = i;
}
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "update " + 表名 + " set " + 结果字段名 + " = " + 列名[0][统计字段序号[0]];
sta4.executeUpdate(s1);
for (int j = 1; j < b4.length; j++) {
s1 = "update " + 表名 + " set " + 结果字段名 + " = "
+ 列名[0][统计字段序号[j]] + " where " + 列名[0][统计字段序号[j]] + ">"
+ 结果字段名;
sta4.executeUpdate(s1);
}
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p35() {
String[] b4 = 统计字段名表.split(",");
统计字段序号 = new int[b4.length];
for (int j = 0; j < b4.length; j++)
for (int i = 0; i < 列数; i++) {
if (b4[j].equalsIgnoreCase(列名[0][i]))
统计字段序号[j] = i;
}
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "update " + 表名 + " set " + 结果字段名 + " = " + 列名[0][统计字段序号[0]];
sta4.executeUpdate(s1);
for (int j = 1; j < b4.length; j++) {
s1 = "update " + 表名 + " set " + 结果字段名 + " = "
+ 列名[0][统计字段序号[j]] + " where " + 列名[0][统计字段序号[j]] + "<"
+ 结果字段名;
sta4.executeUpdate(s1);
}
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p37() {
String[] s11 = new String[500]; // 文件中条件语句内容
String[] s12; // 临时变量存条件语句句号二边二部分
String s13 = "*";
int s10 = 0; // 文件中条件语句条数
try {
File file1 = new File(s8);
if (file1.exists()) {
FileReader fr = new FileReader(file1);
BufferedReader br = new BufferedReader(fr);
String tempStr = null;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
if (tempStr.trim().length() < 1)
break;
s10 = i;
s11[s10] = tempStr;
}
}
} catch (IOException e2) {
JOptionPane.showMessageDialog(null, "打开文件错！");
}
String sk = 字段名表;
if (s8.length() > 0)
try // 利用try尝试性删除临时表，有则删除，无也利用catch跳过
{
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "drop table 临时表";
PreparedStatement stat5 = con.prepareStatement(s4);
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "临时表不存在！");
} // 如果已经存在临时表，则删除
for (int j = 0; j <= s10; j++) {
s12 = s11[j].split("。");
if ((s12[1] != null) && (s12[1].length() > 0)
&& (sk.indexOf(s12[1]) < 0))
if (s11[j].indexOf("'") > 0)
sk = sk + ",' ' as " + s12[1];
else
sk = sk + ",1000000000.0000 as " + s12[1];
}
s1 = "select " + sk + " into 临时表 from " + 表名0;
s2 = s1;
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s2);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "生成临时表失败！");
} // 如果已经存在临时表，已经删除
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "";
for (int j = 0; j <= s10; j++) {
s12 = s11[j].split("。");
if ((s11[j] != null) && (s11[j].length() > 0)) {
结果字段名 = s12[1];// s12[2]为条件表达式，3为计算式
}
if (结果字段名.length() > 0) {
s1 = "update 临时表 set " + 结果字段名 + " = " + s12[3];
if (s12[2].length() > 0)
s1 = s1 + " where " + s12[2];
}
sta4.executeUpdate(s1);
s1 = "";
}
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null,
"更新出错！请检查表中数据情况，是否存在计算式结果为空值的情况。");
}
if (表名0.indexOf(",") > 0) {
s12 = 表名0.split(",");
表名 = s12[0]; // 如果原字段名在原第1个表中
数据表查询结构001(s12[0]);
if (("," + 原字段名集合 + ",").indexOf("," + 结果字段名 + ",") >= 0) {
s13 = 原字段名集合;
} else
s13 = 原字段名集合 + "," + 结果字段名;
}
Object[] options = { "更换" + 表名, "保持原表", "退出" };
int variabl4043 = (JOptionPane.showOptionDialog(null, "请确定是否将" + 表名
+ "换成所显示内容", "请确定是否将" + 表名 + "换成所显示内容",
JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null,
options, options[1]));
if (variabl4043 == 0) {
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "drop table " + 表名;
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "删除失败！");
} // 如果已经存在临时表，则删除
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "select " + s13 + " into " + 表名 + " from 临时表";
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "更新失败！");
}
}
}
public static void p38() {
if (结果字段名.length() == 0) {
JOptionPane.showMessageDialog(null, "缺少结果字段名！");
return;
}
if (表名0.length() == 0) {
JOptionPane.showMessageDialog(null, "缺少表名！");
return;
}
if (关键字名.length() == 0) {
JOptionPane.showMessageDialog(null, "缺少关键字段名称！");
return;
}
String[] s11 = new String[500]; // 文件中条件语句内容
String sk = 字段名表;
if (s8.length() > 0)
try // 利用try尝试性删除临时表，有则删除，无也利用catch跳过
{
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "drop table 临时表";
PreparedStatement stat5 = con.prepareStatement(s4);
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
} // 如果已经存在临时表，则删除
s1 = "select " + 原字段名集合 + " into 临时表 from " + 表名0;
if (连接串.length() > 0)
s1 = s1 + " where " + 连接串;
s2 = s1;
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s2);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "生成临时表失败！");
}
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "";
String s0 = 统计字段名表0;
String 计算结果 = "";
String[] s3 = 关键字名.split(",");
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
s0 = 统计字段名表0;
for (int j1 = 0; j1 < 列名[0].length; j1++) {
s1 = "";
if (s0.indexOf(列名[0][j1]) >= 0) {
s0 = s0.replaceAll(列名[0][j1], 表格数据[i1][j1]);
}
for (int j2 = 0; j2 < s3.length; j2++)
if (s3[j2].equals(列名[0][j1])) {
if (s1.length() == 0)
s1 = " where " + s3[j2] + "=" + 表格数据[i1][j1];
else
s1 = s1 + " and " + s3[j2] + "=" + 表格数据[i1][j1];
}
}
计算结果 = tenanceEval1.tenanceeval1(s0);
{
s1 = "update 临时表 set " + 结果字段名 + " = " + 计算结果 + s1;
sta4.executeUpdate(s1);
}
}
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null,
"更新出错！请检查表中数据情况，是否存在计算式结果为空值的情况。");
}
}
static void 数据表查询结构001(String 数据表名001) {
原字段名集合 = "";
String[] s14;
int s15 = 0;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1 = "select * from " + 数据表名001;
rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
s15 = rsmd4.getColumnCount();
s14 = new String[s15];
for (int i = 0; i < s15; i++) {
s14[i] = rsmd4.getColumnName(i + 1);
if (原字段名集合.length() == 0)
原字段名集合 = s14[i];
else
原字段名集合 = 原字段名集合 + "," + s14[i];
}
rs.absolute(1);
rs.close();
sta4.close();
con1.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错！");
}
}
}
60.源码60，公用程序，四则表达式求值宏替换程序。应用双精度或整型常量加上运算符（+、-、*、/、%、(、)、）及函数：sqrt,square,ceil,sin,cos,asin,acon.tan.atan,log,exp构成表达式，求其运算结果。
/**
* 程序文件名：tenanceEval1.java
* 作者：程学先
* 功能：四则表达式求值宏替换程序
* 完成日期：2015年3月11日
* 修改时间2018.5.25
* 数学表达式中运算符可包括：+、-、*、/、%、(、)、
* 支持函数：sqrt,square,ceil,sin,cos,asin,acon.tan.atan,log,exp
* 具体含义见程序代码
* 调用：tenanceEval1.tenanceeval1(String 数学表达式)
* 以字符串形式返回表达式的值
*/
import java.util.Stack;
public class tenanceEval1 {
public static tenanceEval1 be = new tenanceEval1(); // 对每个表达式计算其值
public static String 算术表达式 = "";
public static String tenanceeval1(String 算术表达式) { // 构造函数
int k1 = 0, k2 = 0;
String x1 = 算术表达式, s2 = "";
x1 = x1.replaceAll("(sqrt)|(square)|(ceil)|(sin)|(cos)|(asin)|"
+ "(acon)|(tan)|(atan)|(log)|(exp)(sqrt)|(square)|(ceil)|"
+ "(sin)|(cos)|(asin)|(acon)|(tan)|(atan)|(log)|(exp)", "￥");
if (x1.length() != 算术表达式.length()) {
// 通过变换后长度变化测试表达式中是否有函数表达式
算术表达式 = be.函数数据计算(x1, 算术表达式);
}
while (算术表达式.indexOf("(") >= 0) {
算术表达式 = be.去括号计算2(算术表达式);
}
x1 = 算术表达式;
x1 = x1.replaceAll("[-/%]", "");
x1 = x1.replaceAll("[\\+]", "");
x1 = x1.replaceAll("[\\*]", "");
if (x1.length() != 算术表达式.length()) {
算术表达式 = 四则运算(算术表达式);
}
return 算术表达式;
}
protected String 去括号计算2(String s) {
// 有括号，括号内无NOT、AND、OR，为纯粹四则运算式
String[] s0 = s.split("\\(");
String[] s1 = s0[s0.length - 1].split("\\)");
int n1 = 0, n2 = 0;
String s2 = "", s3 = "";
for (int i = 0; i < s0.length - 1; i++) {
n1 = n1 + s0[i].length() + 1;
s2 = s2 + s0[i];
if (i < s0.length - 2)
s2 = s2 + "(";
}
n2 = n1 + s1[0].length() + 1;
s3 = s.substring(n2, s.length());
s = s.substring(n1 - 1, n2);
n1--;
s = s.replaceAll("(\\()|(\\))", "");
四则运算(s);
算术表达式 = s2 + 算术表达式 + s3;
return 算术表达式;
}
public static String 四则运算(String s) {
String s1 = s.replaceAll("[-/%]", "*");
s1 = s1.replaceAll("[\\+]", "*");
String[] s0 = s1.split("\\*");
int[] l0 = new int[s0.length]; // 每一块长度
String[] s01 = new String[s0.length]; // 准备存乘除法之后中间结果
String[] l1 = new String[s0.length]; // 准备存符号
String[] l2 = new String[s0.length]; // 准备存乘除法之后中间结果符号
Stack 堆栈数据1 = new Stack();
Stack 堆栈数据2 = new Stack();
Stack 堆栈数据3 = new Stack();
Stack 堆栈数据4 = new Stack();
String sm1 = "", sm2 = "", sn1, sn2, sn3, sn4;
int n = 0, n1 = 0;
double d1 = 0.0, d2 = 0.0;
l2[0] = "";
for (int i = 0; i < s0.length; i++) { // 初始化
l0[i] = s0[i].length();
n = n + s0[i].length();
s01[i] = s0[i];
if (i < s0.length - 1) {
l2[i + 1] = s.substring(n, n + 1);
n++;
}
}
for (int i = s0.length - 1; i >= 0; i--) {
堆栈数据1.push(s0[i]); // 压入数据
堆栈数据2.push(l2[i]);// 压入符号
}
// 处理乘法除法
n = 堆栈数据1.size();
for (int i = 0; i < n; i++) {
sn1 = 堆栈数据1.pop().toString();
sn2 = 堆栈数据2.pop().toString();
if (sn2.equals("*")) {
d1 = Double.parseDouble(sm1) * Double.parseDouble(sn1);
sm1 = d1 + "";
s01[i] = sm1;
s01[i - 1] = "";
l2[i] = l2[i - 1];
l2[i - 1] = "";
} else if (sn2.equals("/")) {
d1 = Double.parseDouble(sm1) / Double.parseDouble(sn1);
sm1 = d1 + "";
s01[i] = sm1;
s01[i - 1] = "";
l2[i] = l2[i - 1];
l2[i - 1] = "";
} else if (sn2.equals("%")) {
d1 = Double.parseDouble(sm1) % Double.parseDouble(sn1);
sm1 = d1 + "";
s01[i] = sm1;
l2[i] = l2[i - 1];
s01[i - 1] = "";
l2[i - 1] = "";
} else
sm1 = sn1;
算术表达式 = d1 + "";
}
for (int i = s01.length - 1; i >= 0; i--) {
if (s01[i].length() > 0) {
堆栈数据3.push(s01[i]); // 压入数据
堆栈数据4.push(l2[i]);// 压入符号
}
}
// 处理加法、减法
if (堆栈数据3.size() > 1) {
d1 = 0.0;
sm1 = "";
n = 堆栈数据3.size();
for (int i = 0; i < n; i++) {
sn1 = 堆栈数据3.pop().toString();
sn2 = 堆栈数据4.pop().toString();
if (sn2.equals("+")) {
d1 = Double.parseDouble(sm1) + Double.parseDouble(sn1);
sm1 = d1 + "";
s01[i] = sm1;
s01[i - 1] = "";
l2[i] = l2[i - 1];
l2[i - 1] = "";
} else if (sn2.equals("-")) {
d1 = Double.parseDouble(sm1) - Double.parseDouble(sn1);
sm1 = d1 + "";
s01[i] = sm1;
s01[i - 1] = "";
l2[i] = l2[i - 1];
l2[i - 1] = "";
} else {
sm1 = sn1; // 上一个元素
}
}
算术表达式 = d1 + "";
}
return 算术表达式;
}
protected String 函数数据计算(String 算术表达式1, String 变量值3) {
String[] s1 = 算术表达式1.split("￥"); // 根据函数式的函数名分块
String 变量值4 = "", 变量值5 = "", 变量值6 = "", 变量值7 = "", x1;
int n1 = 0, n2 = 0, n3 = 0;
double db = 0.0;
for (int i = 0; i < s1.length; i++) { // 本程序暂不考虑函数嵌套问题
n3 = n1 + s1[i].length(); // 在算术表达式中函数式前面部分长度
n1 = 变量值3.indexOf("(", n2 + s1[i].length());// 在算术表达式中函数后面左括号位置
if (n1 < 0)
break;
n2 = 变量值3.indexOf(")", n1); // 函数右括号位置
变量值4 = 变量值3.substring(n1 + 1, n2); // 待进行函数运算的表达式
变量值5 = 变量值3.substring(n3, n1); // 函数名
变量值7 = 变量值3.substring(n3, n2 + 1); // 原来变量值3中完整的函数表达式
if (变量值4.indexOf("(") > 0)
变量值4 = be.去括号计算2(变量值4); // 求待进行函数运算的表达式的值
else {
x1 = 变量值4;
x1 = x1.replaceAll("[-/%]", "");
x1 = x1.replaceAll("[\\+]", "");
x1 = x1.replaceAll("[\\*]", "");
if (x1.length() != 变量值4.length())
变量值4 = 四则运算(变量值4);
}
try {
db = Double.valueOf(变量值4).doubleValue();
if (变量值5.equals("log")) {
变量值6 = Math.log(db) + "";
} else if (变量值5.equals("square")) {
变量值6 = Math.pow(db, 2) + "";
} else if (变量值5.equals("sqrt")) {
变量值6 = Math.sqrt(db) + "";
} else if (变量值5.equals("sin")) {
变量值6 = Math.sin(db) + "";
} else if (变量值5.equals("asin")) {
变量值6 = Math.asin(db) + "";
} else if (变量值5.equals("cos")) {
变量值6 = Math.cos(db) + "";
} else if (变量值5.equals("tan")) {
变量值6 = Math.tan(db) + "";
} else if (变量值5.equals("atan")) {
变量值6 = Math.atan(db) + "";
} else if (变量值5.equals("ceil")) {
变量值6 = Math.ceil(db) + "";
} else if (变量值5.equals("exp")) {
变量值6 = Math.exp(db) + "";
}
} catch (Exception e) {
}
int l1 = 变量值3.indexOf(变量值7); // 变量值7位置
int l2 = 变量值7.length(); // 变量值7长度
变量值3 = 变量值3.substring(0, l1)
+ (变量值6 + " ").substring(0, l2)
+ 变量值3.substring(l1 + l2, 变量值3.length());
变量值3 = 变量值3.replaceAll(" ", "");
n2--;
}
算术表达式 = 变量值3;
return 变量值3;
}
}
61.源码61，部件程序，高度综合纵向计算程序，可对全表按某些字段分组后对每组及全部数据进行统计计算，可以进行ABC分析。
/**
* 程序文件名：dataStatistic4.java
* 作者：程学先
* 完成时间：2013年12月3日
* 部件功能：对全表按某些字段分组后对每组及全部数据的若干字段进行纵向计算，
* 是数据处理1、2综合成程序，可以进行ABC分析。
* 求和或求平均或求最大或最小或记录条数或标准偏差或填充标准偏差 或统计方差或填充统计方差等，
* 被调用语句：dataStatistic4.means(parameter);
* 必须提供的参数：数据库“表名”、要求统计的字段“统计字段名”
* 可选参数：“分组字段名”、“字段号表”、“按钮号表”、“分类比例”。
* 本程序包括：求和、求平均、求最大、求最小、求记录条数、求平均偏差,求相对偏差,
* 求统计标准偏差,求填充统计标准偏差,求统计方差,求填充统计方差 、退出等12个按钮。
* 其中打印要求要求先利用程序printFormat1.java生成格式文件
* 操作方法与注意事项：
* 在“字段号表2”处可以输入多个字段名，为准备求和等统计的字段名。
* 在“字段号表3”处可以输入多个字段名，为分组要求的字段名。
* 可以联系代码表、字典表进行查询。
* 如果涉及代码表，在生成菜单程序时，在填表名时，应当先在列表框中选主表，再依次选代码表。
* 如果涉及字典表，将根据字典表给定的对应关系变换标签。
* 要求在当前数据库中有一个表的名字为某某某字典表，
* 即表名最后3个字是“字典表”，本程序将根据该表变换。
* 要求该表中只有二个字段，第一个字段（命名为字段名）中内容为所查询的数据表中字段名，
* 第二个字段（命名为标签名）内容为变换后的标签名。
* 所有统计字段名称要按变换前字段名提供。
* 如果进行ABC分析，要求输入“分类比例”，可以是3个数，也可以是更多的数，之间用逗号分隔。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import java.util.ArrayList;
public class dataStatistic4 extends JFrame {
static dataStatistic4 frame = new dataStatistic4();
static dataStatistic4 frame1 = new dataStatistic4();
static JPanel panel1 = new JPanel(false); // 定义面板
static String 表名;
static String 字典表名;
static String 表名表;
static DefaultTableModel tableModel;
static ArrayList 小组平均 = new ArrayList();
static JTable table;
static JScrollPane scrollPane = new JScrollPane();
static String s1 = "";
static ResultSet rs;
static int b = 0, c = 0;
static int 列数;
static String[][] 列名;
static String[] 列数据类型;
static int[] 列数据宽度;
static int 记录条数, 记录条数1, 分组个数, 分组个数1;
static String[][] 记录4; // 存放ABC统计时分组数据
static String[][] 表格数据;// 存放表格数据的数;
static String[][] 表格数据1;
static String 统计字段;
static String 分组字段;
static int[] 分组字段号;
static String 字段号表;
static String 统计要求;
static int[] 统计字段号;
static String 连接条件;
static String 字段名字串;
static String 按钮号表, 分类比例;
static int 左边距 = 80;
static Connection con; // 连接数据库
static ResultSetMetaData rsmd3;
static Statement sta3;
static int 窗口宽 = main1.窗口宽 + 300, 窗口高 = main1.窗口高;
static String[] 按钮集 = null;
static String 要求按钮号表;
static int 按钮数 = 0, 按钮宽 = 0;
public static void means(String[] parameter) {
frame = new dataStatistic4();
frame1 = new dataStatistic4();
panel1 = new JPanel(false);
小组平均 = new ArrayList();
scrollPane = new JScrollPane();
s1 = "";
b = 0;
c = 0;
左边距 = 80;
窗口宽 = 1400;
窗口高 = main1.窗口高;
String[] 按钮集01 = { "求和", "求平均", "求最大", "求最小", "求记录条数", "求平均偏差",
"求相对偏差", "标准偏差", "填充标准偏差", "统计方差", "填充统计方差", "求ABC分类", "退出",
"打印预览", "打印", "导出" };
按钮集 = new String[按钮集01.length];
按钮数 = 0;
for (int i0 = 0; i0 < 按钮集01.length; i0++)
按钮集[i0] = 按钮集01[i0];
if (parameter[11].length() > 0) {
要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号
// 将中文分号、冒号、句号、英文分号统一为英文分号
要求按钮号表 = 要求按钮号表.replaceAll("；", ";");
要求按钮号表 = 要求按钮号表.replaceAll("。", ";");
要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
要求按钮号表 = 要求按钮号表.replaceAll("：", ";");
if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求
String s601[] = 要求按钮号表.split(",");
要求按钮号表 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
按钮集[Integer.parseInt((s602[0]))] = s602[1];
要求按钮号表 = 要求按钮号表 + "," + s602[0];// 只留号，去更名
按钮数++;
} else {
要求按钮号表 = 要求按钮号表 + "," + s601[i01];// 只留号，原无更名
按钮数++;
}
}
} // 如果没有按钮更名要求，要求按钮号长度又大于0，保持原有摸样
else {
String s601[] = 要求按钮号表.split(",");
要求按钮号表 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
要求按钮号表 = s601[i01];
else
要求按钮号表 = 要求按钮号表 + "," + s601[i01];
按钮数++;
}
}
} else {
要求按钮号表 = ""; // 没输入要求按钮号，定全部按钮号
for (int i1 = 0; i1 < 按钮集.length; i1++) {
if (i1 == 0)
要求按钮号表 = 要求按钮号表 + i1;
else
要求按钮号表 = 要求按钮号表 + "," + i1;
按钮数++;
}
}
要求按钮号表 = "," + 要求按钮号表 + ",";
窗口宽 = main1.窗口宽;
窗口高 = main1.窗口高;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);// 宽度参数
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
窗口宽 = m1;
窗口高 = m2;
}
} catch (Exception e2) {
}
分组个数1 = 0;
表名 = parameter[4];
连接条件 = parameter[20];
字段名字串 = parameter[19];
分组字段 = parameter[10];
if (字段名字串.lastIndexOf(",") == 字段名字串.length() - 1)
字段名字串 = 字段名字串.substring(0, 字段名字串.length() - 1);
表名表 = parameter[0];
字段号表 = parameter[8];
统计字段 = parameter[9];
按钮号表 = "," + parameter[11] + ",";
分类比例 = parameter[14];
字典表名 = "";
String[] t1;
String s11 = 表名;
if (表名.indexOf(",") > 0) {
String[] s12 = 表名.split(",");
s11 = s12[0];
}
if (表名表.lastIndexOf(s11 + "字典表") > 0) {
t1 = 表名表.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(s11 + "字典表") >= 0)
字典表名 = t1[i];
}
String[] l1;
String[] l3 = 字段名字串.split(",");
if (字段号表.length() > 0) {
l1 = 字段号表.split(",");
int[] l2 = new int[l1.length];
for (int i = 0; i < l1.length; i++) {
l2[i] = Integer.valueOf(l1[i]);
}
列数 = l1.length;
列名 = new String[2][列数];
for (int i = 0; i < 列数; i++) {
列名[0][i] = l3[l2[i]];
列名[1][i] = 列名[0][i];
}
} else {
列数 = l3.length;
列名 = new String[2][列数];
for (int i = 0; i < 列数; i++) {
列名[0][i] = l3[i];
列名[1][i] = 列名[0][i];
}
}
s1 = "";
for (int i = 0; i < 列数; i++)
s1 = s1 + 列名[0][i] + ",";
s1 = s1.substring(0, s1.length() - 1);
try {
con = main1.getConn();// 连接数据库
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s = "";
if (表名.lastIndexOf(",") > 0)
s = "select " + s1 + " from " + 表名 + " where " + 连接条件;
else
s = "select " + s1 + " from " + 表名;
ResultSet rs = sta3.executeQuery(s);
rsmd3 = rs.getMetaData();
列数 = rsmd3.getColumnCount(); // 获取列数
列名 = new String[2][列数]; // 定义列名数组
列数据类型 = new String[列数]; // 定义列字段类型数组
列数据宽度 = new int[列数]; // 定义列数据宽度
for (int i = 0; i < 列数; i++) {
列名[0][i] = rsmd3.getColumnName(i + 1); // 获取列名存到数组中
列名[1][i] = 列名[0][i];
列数据类型[i] = rsmd3.getColumnTypeName(i + 1);
列数据宽度[i] = rsmd3.getColumnDisplaySize(i + 1);
}
记录条数 = 0; // 记录条数
rs.last();
记录条数 = rs.getRow();
表格数据 = new String[记录条数][列数];
rs.absolute(1);
c = 0; // 行号
b = 0; // 列号
while (c < 记录条数) {
rs.absolute(c + 1);
while (b < 列数) {
表格数据[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close(); // 关闭查询结果集
sta3.close(); // 关闭连接
con.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "查询数据出错！");
}
s1 = "";
if (字典表名.length() > 0) {
try {
con = main1.getConn();// 连接数据库
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 字典表名; // 查取全表数据
rs = sta3.executeQuery(s1);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount(); // 记录数
String s14 = "";
String s15 = "";
int b = 1;
while (rs.absolute(b)) {
b++;
s14 = rs.getString(1).trim(); // 字段名
s15 = rs.getString(2).trim();
for (int j = 0; j < 列数; j++) {
if (列名[0][j].trim().equalsIgnoreCase(s14.trim())) {
列名[1][j] = s15;
break;
} else if ((列名[0][j].trim() + ",").indexOf("." + s14
+ ",") > 0) {
列名[1][j] = 列名[1][j].replace(s14, s15);
break;
}
}
}
rs.close(); // 关闭查询结果集
con.close();
sta3.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错！" + s1);
}
}
String[] s71 = 字段名字串.split(","); // ////////////
String s4[];
s4 = 统计字段.split(",");
for (int i = 0; i < s4.length; i++)
// ////////////
s4[i] = s71[Integer.parseInt(s4[i])]; // //////
统计字段号 = new int[s4.length];
for (int i = 0; i < s4.length; i++) {
for (int j = 0; j < 列数; j++) {
if (s4[i].trim().equalsIgnoreCase(列名[0][j].trim()))
统计字段号[i] = j;
}
for (int j = 0; j < 记录条数; j++)
if ((表格数据[j][统计字段号[i]] == null)
|| (表格数据[j][统计字段号[i]].length() < 1))
表格数据[j][统计字段号[i]] = "0";
}
String s5[];
s5 = 分组字段.split(",");
分组字段号 = new int[s5.length];
for (int i = 0; i < s5.length; i++)
for (int j = 0; j < 列数; j++) {
if (s5[i].trim().equalsIgnoreCase(列名[0][j].trim()))
分组字段号[i] = j;
}
记录4 = new String[记录条数][6];// 分组个数最大等于记录数
for (int i = 0; i < 记录条数; i++)
for (int j = 0; j < 6; j++)
记录4[i][j] = "";
分组个数1 = 0;
String s6 = "", s7 = "";
String[] 记录 = new String[列数];
for (int i0 = 0; i0 < 记录条数 - 1; i0++) {
for (int i = 0; i < 记录条数 - 1 - i0; i++) {
s6 = "";
s7 = "";
for (int j = 0; j < s5.length; j++)
s6 = s6 + 表格数据[i][分组字段号[j]].trim();
for (int j = 0; j < s5.length; j++)
s7 = s7 + 表格数据[i + 1][分组字段号[j]].trim();
if (s6.compareTo(s7) > 0)
for (int k = 0; k < 列数; k++) {
记录[k] = 表格数据[i][k];
表格数据[i][k] = 表格数据[i + 1][k];
表格数据[i + 1][k] = 记录[k];
}
}
}
frame.setTitle("查询统计部件程序 作者：程学先"); // 窗口标题
frame.setBounds(10, 10, 窗口宽 - 10, 窗口高 - 10); // 窗口位置大小
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
frame.getContentPane().setLayout(null); // 关闭窗口布局管理器
frame1.setTitle(" ABC分类表");
frame1.setBounds(100, 10, 窗口宽 - 10, 窗口高 - 10); // 窗口位置大小
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
frame1.getContentPane().setLayout(null); // 关闭窗口布局管理器
final JPanel panel = new JPanel(false); // 定义面板
panel1 = new JPanel(false);
panel.setLayout(null); // 关闭面板布局管理器
panel.setBounds(20, 20, 窗口宽 - 50, 窗口高 - 20);
panel1.setLayout(null); // 关闭面板布局管理器
panel1.setBounds(20, 20, 窗口宽 - 50, 窗口高 - 20);
String[][] 记录1 = new String[0][列数];
tableModel = new DefaultTableModel(记录1, 列名[1]); // 创建空表格模型
table = new JTable(tableModel); // 创建指定表格模型的表格
table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);// 设置表格的选择模式为单选
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < 列数; i++) { // 设置表格每列宽度
TableColumn tc = table.getColumn(列名[1][i]);
int g10 = 列名[1][i].length();
if (列数据宽度[i] > g10)
g10 = 列数据宽度[i];
tc.setPreferredWidth(g10 * 20);
tc.setMaxWidth(g10 * 20);
tc.sizeWidthToFit();
}
scrollPane.getViewport().add(table, null);
scrollPane.setBounds(30, 30, 窗口宽 - 100, 窗口高 - 200);
panel.add(scrollPane);
按钮宽 = (窗口宽 - 60) / 按钮数;
if (按钮宽 < 100)
按钮宽 = 100;
int 按钮左边距 = 30;
int h0 = 窗口高 - 150, h1 = 1, h2;
按钮号表 = 要求按钮号表;
JButton 求和 = new JButton(按钮集[0]);
求和.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "求和";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",0,") >= 0)) {
求和.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(求和);
按钮左边距 = 按钮左边距 + 按钮宽;
if (窗口宽 < 按钮宽 + 按钮左边距) {
按钮左边距 = 5;
h0 = h0 + 30;
按钮宽 = (按钮宽 * h1) / (按钮数 - h1);
}
h1++;
}
JButton 求平均 = new JButton(按钮集[1]);
求平均.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "求平均";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",1,") >= 0)) {
求平均.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(求平均);
按钮左边距 = 按钮左边距 + 按钮宽;
if (窗口宽 < 按钮宽 + 按钮左边距) {
按钮左边距 = 5;
h0 = h0 + 30;
按钮宽 = (按钮宽 * h1) / (按钮数 - h1);
}
h1++;
}
JButton 求最大 = new JButton(按钮集[2]);
求最大.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "求最大";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",2,") >= 0)) {
求最大.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(求最大);
按钮左边距 = 按钮左边距 + 按钮宽;
if (窗口宽 < 按钮宽 + 按钮左边距) {
按钮左边距 = 5;
h0 = h0 + 30;
按钮宽 = (按钮宽 * h1) / (按钮数 - h1);
}
h1++;
}
JButton 求最小 = new JButton(按钮集[3]);
求最小.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "求最小";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",3,") >= 0)) {
求最小.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(求最小);
按钮左边距 = 按钮左边距 + 按钮宽;
if (窗口宽 < 按钮宽 + 按钮左边距) {
按钮左边距 = 5;
h0 = h0 + 30;
按钮宽 = (按钮宽 * h1) / (按钮数 - h1);
}
h1++;
}
JButton 求记录条数 = new JButton(按钮集[4]);
求记录条数.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "求记录条数";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",4,") >= 0)) {
求记录条数.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(求记录条数);
按钮左边距 = 按钮左边距 + 按钮宽;
if (窗口宽 < 按钮宽 + 按钮左边距) {
按钮左边距 = 5;
h0 = h0 + 30;
按钮宽 = (按钮宽 * h1) / (按钮数 - h1);
}
h1++;
}
JButton 求平均偏差 = new JButton(按钮集[5]);
求平均偏差.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "求平均偏差";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",5,") >= 0)) {
求平均偏差.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(求平均偏差);
按钮左边距 = 按钮左边距 + 按钮宽;
if (窗口宽 < 按钮宽 + 按钮左边距) {
按钮左边距 = 5;
h0 = h0 + 30;
按钮宽 = (按钮宽 * h1) / (按钮数 - h1);
}
h1++;
}
JButton 求相对偏差 = new JButton(按钮集[6]);
求相对偏差.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "求相对偏差";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",6,") >= 0)) {
求相对偏差.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(求相对偏差);
按钮左边距 = 按钮左边距 + 按钮宽;
if (窗口宽 < 按钮宽 + 按钮左边距) {
按钮左边距 = 5;
h0 = h0 + 30;
按钮宽 = (按钮宽 * h1) / (按钮数 - h1);
}
h1++;
}
JButton 求统计标准偏差 = new JButton(按钮集[7]);
求统计标准偏差.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "求统计标准偏差";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",7,") >= 0)) {
求统计标准偏差.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(求统计标准偏差);
按钮左边距 = 按钮左边距 + 按钮宽;
if (窗口宽 < 按钮宽 + 按钮左边距) {
按钮左边距 = 5;
h0 = h0 + 30;
按钮宽 = (按钮宽 * h1) / (按钮数 - h1);
}
}
JButton 填充统计标准偏差 = new JButton(按钮集[8]);
填充统计标准偏差.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "填充统计标准偏差";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",8,") >= 0)) {
填充统计标准偏差.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(填充统计标准偏差);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 填充方差 = new JButton(按钮集[9]);
填充方差.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "填充统计方差";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",9,") >= 0)) {
填充方差.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(填充方差);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 求统计方差 = new JButton(按钮集[10]);
求统计方差.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "求统计方差";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",10,") >= 0)) {
求统计方差.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(求统计方差);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton ABC分类 = new JButton(按钮集[11]);
ABC分类.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
统计要求 = "求ABC分类";
统计();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",11,") >= 0)) {
ABC分类.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(ABC分类);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 退出 = new JButton(按钮集[12]);
退出.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame1.setVisible(false);
frame1.dispose();
frame.setVisible(false);
frame.dispose();
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",12,") >= 0)) {
退出.setBounds(按钮左边距, h0, 按钮宽, 20);
panel.add(退出);
按钮左边距 = 按钮左边距 + 按钮宽;
}
final String[] g6 = { "分组数据", "小计值", "记录条数", "分类名称", "小计占比", "记录数占比" };
final int[] g7 = { 100, 100, 50, 50, 100, 100 };// "分组数据","小计值","记录条数","分类名称","小计占比","记录数占比"};
final String[] g8 = { "char", "Double", "int", "char", "Double",
"Double" };
按钮左边距 = 50;
JButton 打印预览1 = new JButton(按钮集[13]);
打印预览1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPreview0.printView1(g6, 记录4, g7, "ABC分类表");
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",1,") >= 0)) {
打印预览1.setBounds(按钮左边距, 窗口高 - 150, 按钮宽, 20);
panel1.add(打印预览1);
按钮左边距 = 按钮左边距 + 按钮宽;
}
JButton 打印1 = new JButton(按钮集[14]);
打印1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPrint0.printView1(g6, 记录4, g7, "ABC分类表");
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",2,") >= 0)) {
打印1.setBounds(按钮左边距, 窗口高 - 150, 按钮宽, 20);
panel1.add(打印1);
按钮左边距 = 按钮左边距 + 按钮宽;
}
final int[] g9 = { 20, 20, 6, 6, 20, 20 };// "分组数据","小计值","记录条数","分类名称","小计占比","记录数占比"};
JButton 导出1 = new JButton(按钮集[15]);
导出1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataTransfer0.Trans(g6, g8, g9, "", 记录4, "ABC分类表");
}
});
if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",3,") >= 0)) {
导出1.setBounds(按钮左边距, 窗口高 - 150, 按钮宽, 20);
panel1.add(导出1);
按钮左边距 = 按钮左边距 + 按钮宽;
}
frame.getContentPane().add(panel, null);
frame.setVisible(true);
frame.getContentPane().add(panel, BorderLayout.SOUTH);
}
public static void 统计() {
for (int i = tableModel.getRowCount() - 1; i >= 0; i--)
tableModel.removeRow(i); // 从最后一行向前删除
String[] 记录 = new String[列数];
String[] 记录2 = new String[列数];
String[] 记录3 = new String[列数];
double[] x0 = new double[列数];
double[] x1 = new double[列数];
double[] x2 = new double[列数];
double[] x3 = new double[列数];
double[] x4 = new double[列数];
double[][] y0;
double[] y1 = new double[列数];
double[] y2 = new double[列数];
double[] y3 = new double[列数];
double[] y4 = new double[列数];
String s6 = "", s7 = "";
int 小组起始号 = 0;
double[] x = new double[列数];
double[] y = new double[列数];
for (int i = 0; i < 列数; i++) {
记录2[i] = "";
记录3[i] = "";
}
Double 总合计 = 0.0;
int 总记录数 = 0;
s6 = "";
for (int n0 = 0; n0 < 分组字段号.length; n0++) {
s6 = s6 + 表格数据[0][分组字段号[n0]].trim();
}
// System.out.println("s6="+s6+" 统计要求"+统计要求+" 统计字段号="+统计字段号[0]+" 分组字段号="+分组字段号[0]);
for (int k = 0; k < 统计字段号.length; k++) {
x1[统计字段号[k]] = Double.parseDouble(表格数据[0][统计字段号[k]]);
y1[统计字段号[k]] = Double.parseDouble(表格数据[小组起始号][统计字段号[k]]);
x2[统计字段号[k]] = 0;
y2[统计字段号[k]] = 0;
x3[统计字段号[k]] = 0;
y3[统计字段号[k]] = 0;
x4[统计字段号[k]] = 0;
y4[统计字段号[k]] = 0;
}
for (int n0 = 0; n0 < 列数; n0++) {
记录[n0] = "";
}
for (int n = 0; n < 记录条数; n++) {
if (("求最大,求最小,求记录数,求和,求平均,求ABC分类").lastIndexOf(统计要求) >= 0)
tableModel.addRow(表格数据[n]);
for (int k = 0; k < 统计字段号.length; k++) {
x[统计字段号[k]] = Double.parseDouble(表格数据[n][统计字段号[k]]);
if (x[统计字段号[k]] < x1[统计字段号[k]])
x1[统计字段号[k]] = x[统计字段号[k]];
if (x[统计字段号[k]] > x2[统计字段号[k]])
x2[统计字段号[k]] = x[统计字段号[k]];
x3[统计字段号[k]] = x3[统计字段号[k]] + x[统计字段号[k]];
x4[统计字段号[k]]++;
if (x[统计字段号[k]] < y1[统计字段号[k]])
y1[统计字段号[k]] = x[统计字段号[k]];
if (x[统计字段号[k]] > y2[统计字段号[k]])
y2[统计字段号[k]] = x[统计字段号[k]];
y3[统计字段号[k]] = y3[统计字段号[k]] + x[统计字段号[k]];
y4[统计字段号[k]]++;
}
s7 = "";
String s8 = "";
if (n < 记录条数 - 1) {
for (int n1 = 0; n1 < 分组字段号.length; n1++) {
s7 = s7 + 表格数据[n + 1][分组字段号[n1]].trim();
if (s8.length() == 0)
s8 = s8 + 表格数据[n][分组字段号[n1]].trim();
else
s8 = s8 + "," + 表格数据[n][分组字段号[n1]].trim();
}
if (!s6.trim().equalsIgnoreCase(s7.trim())) {
s6 = s7;
for (int k = 0; k < 统计字段号.length; k++) {
if (统计要求.trim().equalsIgnoreCase("求最小"))
记录[统计字段号[k]] = "" + y1[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求最大"))
记录[统计字段号[k]] = "" + y2[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求和"))
记录[统计字段号[k]] = "" + y3[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求ABC分类")) {
记录[统计字段号[k]] = "" + y3[统计字段号[k]];
} else if (统计要求.trim().equalsIgnoreCase("求记录数"))
记录[统计字段号[k]] = "" + (int) y4[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求平均")) {
记录[统计字段号[k]] = "" + y3[统计字段号[k]] / y4[统计字段号[k]];
}
if (k == 0) {
记录4[分组个数1][1] = y3[统计字段号[k]] + ""; // 只保存第一个统计字段统计值k=0
记录4[分组个数1][2] = (int) y4[统计字段号[k]] + ""; // 记录条数
记录4[分组个数1][0] = s8;
分组个数1++;
}
小组平均.add(y3[统计字段号[k]] / y4[统计字段号[k]]);
}
if (("求最大,求最小,求记录数,求和,求平均").lastIndexOf(统计要求) >= 0)
记录[分组字段号[分组字段号.length - 1]] = 表格数据[n][分组字段号[分组字段号.length - 1]]
.trim() + 统计要求.substring(1, 统计要求.length());
else if (("求ABC分类").lastIndexOf(统计要求) >= 0)
记录[分组字段号[分组字段号.length - 1]] = 表格数据[n][分组字段号[分组字段号.length - 1]]
.trim() + "分类";
if (("求最大,求最小,求记录数,求和,求平均,求ABC分类").lastIndexOf(统计要求) >= 0)
tableModel.addRow(记录);
小组起始号 = n + 1;
for (int k = 0; k < 统计字段号.length; k++) {
y1[统计字段号[k]] = Double
.parseDouble(表格数据[小组起始号][统计字段号[k]]);
y2[统计字段号[k]] = 0;
y3[统计字段号[k]] = 0;
y4[统计字段号[k]] = 0;
}
for (int n0 = 0; n0 < 列数; n0++) {
记录[n0] = "";
}
}
}
}
for (int k = 0; k < 统计字段号.length; k++) {
if (统计要求.trim().equalsIgnoreCase("求最小"))
记录[统计字段号[k]] = "" + y1[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求最大"))
记录[统计字段号[k]] = "" + y2[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求和"))
记录[统计字段号[k]] = "" + y3[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求ABC分类"))
记录[统计字段号[k]] = "" + y3[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求记录数"))
记录[统计字段号[k]] = "" + (int) y4[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求平均")) {
记录[统计字段号[k]] = "" + y3[统计字段号[k]] / y4[统计字段号[k]];
}
String s9 = "";
for (int n1 = 0; n1 < 分组字段号.length; n1++) {
if (s9.length() == 0)
s9 = s9 + 表格数据[记录条数 - 1][分组字段号[n1]].trim();
else
s9 = s9 + "," + 表格数据[记录条数 - 1][分组字段号[n1]].trim();
}
if (k == 0) {
记录4[分组个数1][1] = y3[统计字段号[k]] + ""; // 只保存第一个统计字段统计值k=0
记录4[分组个数1][2] = (int) y4[统计字段号[k]] + ""; // 记录条数
记录4[分组个数1][0] = s9;
}
}
记录[分组字段号[分组字段号.length - 1]] = 表格数据[记录条数 - 1][分组字段号[分组字段号.length - 1]]
.trim() + 统计要求.substring(1, 统计要求.length());
if (("求最大,求最小,求记录数,求和,求平均,求ABC分类").lastIndexOf(统计要求) >= 0) {
tableModel.addRow(记录);
for (int k = 0; k < 统计字段号.length; k++) {
if (统计要求.trim().equalsIgnoreCase("求最小"))
记录[统计字段号[k]] = "" + x1[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求最大"))
记录[统计字段号[k]] = "" + x2[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求和"))
记录[统计字段号[k]] = "" + x3[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求ABC分类"))
记录[统计字段号[k]] = "" + x3[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求记录数"))
记录[统计字段号[k]] = "" + (int) x4[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求平均")) {
记录[统计字段号[k]] = "" + x0[统计字段号[k]];
y4[统计字段号[k]]++;
x4[统计字段号[k]]++;
}
if (统计要求.trim().equalsIgnoreCase("求平均")) {
x0[统计字段号[k]] = x3[统计字段号[k]] / 记录条数; // x4[统计字段号[k]];
记录[统计字段号[k]] = "" + x0[统计字段号[k]];
}
if (k == 0)
总合计 = Double.valueOf(记录[统计字段号[k]]);
}
}
if (("求最大,求最小,求记录数,求和,求平均").lastIndexOf(统计要求) >= 0) {
记录[分组字段号[分组字段号.length - 1]] = "总"
+ 统计要求.substring(1, 统计要求.length());
tableModel.addRow(记录);
} else if (("求ABC分类").lastIndexOf(统计要求) >= 0) {
记录[分组字段号[分组字段号.length - 1]] = "总分类";
tableModel.addRow(记录);
}
y0 = new double[小组平均.size() / 统计字段号.length + 1][统计字段号.length];
int i1 = 0;
for (int i = 0; i < 小组平均.size() / 统计字段号.length; i++)
for (int j = 0; j < 统计字段号.length; j++) {
y0[i][j] = Double.parseDouble(""
+ 小组平均.get(i * 统计字段号.length + j));
}
int 组号 = 0;
if (("求最大,求最小,求记录数,求和,求平均,求ABC分类").lastIndexOf(统计要求) < 0) {
for (int k1 = 0; k1 < 统计字段号.length; k1++) {
x2[统计字段号[k1]] = 0;
x3[统计字段号[k1]] = 0;
y2[统计字段号[k1]] = 0;
y3[统计字段号[k1]] = 0;
x4[统计字段号[k1]] = 0;
y4[统计字段号[k1]] = 0;
}
s6 = "";
for (int n0 = 0; n0 < 分组字段号.length; n0++) {
s6 = s6 + 表格数据[0][分组字段号[n0]].trim();
}
for (int n = 0; n < 记录条数; n++) {
tableModel.addRow(表格数据[n]);
for (int k = 0; k < 统计字段号.length; k++) {
x[统计字段号[k]] = Math.abs(Double
.parseDouble(表格数据[n][统计字段号[k]]) - x0[统计字段号[k]]);
x2[统计字段号[k]] = x2[统计字段号[k]] + x[统计字段号[k]];
x3[统计字段号[k]] = x3[统计字段号[k]] + x[统计字段号[k]] * x[统计字段号[k]];
y[统计字段号[k]] = Math.abs(Double
.parseDouble(表格数据[n][统计字段号[k]]) - y0[组号][k]);
y2[统计字段号[k]] = y2[统计字段号[k]] + y[统计字段号[k]];
y3[统计字段号[k]] = y3[统计字段号[k]] + y[统计字段号[k]] * y[统计字段号[k]];
x4[统计字段号[k]]++;
y4[统计字段号[k]]++;
}
s7 = "";
if (n < 记录条数 - 1) {
for (int n1 = 0; n1 < 分组字段号.length; n1++)
s7 = s7 + 表格数据[n + 1][分组字段号[n1]].trim();
if (!s6.equalsIgnoreCase(s7)) {
s6 = s7;
for (int k = 0; k < 统计字段号.length; k++) {
if (统计要求.trim().equalsIgnoreCase("求平均偏差"))
记录[统计字段号[k]] = "" + y2[统计字段号[k]] / y4[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求相对偏差"))
记录[统计字段号[k]] = "" + y2[统计字段号[k]] / y4[统计字段号[k]]
/ y0[组号][k] * 100;
else if (统计要求.trim().equalsIgnoreCase(
"求统计标准偏差stdev"))
记录[统计字段号[k]] = ""
+ Math.sqrt(y3[统计字段号[k]]
/ (y4[统计字段号[k]] - 1));
else if (统计要求.trim().equalsIgnoreCase(
"求填充统计标准偏差stdevp"))
记录[统计字段号[k]] = ""
+ Math.sqrt(y3[统计字段号[k]] / y4[统计字段号[k]]);
else if (统计要求.trim().equalsIgnoreCase("求统计方差var"))
记录[统计字段号[k]] = "" + y3[统计字段号[k]]
/ (y4[统计字段号[k]] - 1);
else if (统计要求.trim()
.equalsIgnoreCase("求填充统计方差varp"))
记录[统计字段号[k]] = "" + y3[统计字段号[k]] / y4[统计字段号[k]];
}
记录[分组字段号[分组字段号.length - 1]] = 表格数据[n][分组字段号[分组字段号.length - 1]]
.trim() + 统计要求.substring(1, 统计要求.length());
tableModel.addRow(记录);
组号++;
for (int n3 = 0; n3 < 列数; n3++) {
记录3[n3] = "";
y2[n3] = 0;
y3[n3] = 0;
y4[n3] = 0;
}
}
}
}
for (int k = 0; k < 统计字段号.length; k++) {
if (统计要求.trim().equalsIgnoreCase("求平均偏差"))
记录[统计字段号[k]] = "" + y2[统计字段号[k]] / y4[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求相对偏差"))
记录[统计字段号[k]] = "" + y2[统计字段号[k]] / y4[统计字段号[k]] / y0[组号][k]
* 100;
else if (统计要求.trim().equalsIgnoreCase("求统计标准偏差"))
记录[统计字段号[k]] = ""
+ Math.sqrt(y3[统计字段号[k]] / (y4[统计字段号[k]] - 1));
else if (统计要求.trim().equalsIgnoreCase("求填充统计标准偏差"))
记录[统计字段号[k]] = "" + Math.sqrt(y3[统计字段号[k]] / y4[统计字段号[k]]);
else if (统计要求.trim().equalsIgnoreCase("求统计方差"))
记录[统计字段号[k]] = "" + y3[统计字段号[k]] / (y4[统计字段号[k]] - 1);
else if (统计要求.trim().equalsIgnoreCase("求填充统计方差"))
记录[统计字段号[k]] = "" + y3[统计字段号[k]] / y4[统计字段号[k]];
}
tableModel.addRow(记录);
for (int k = 0; k < 统计字段号.length; k++) {
if (统计要求.trim().equalsIgnoreCase("求平均偏差"))
记录[统计字段号[k]] = "" + x2[统计字段号[k]] / x4[统计字段号[k]];
else if (统计要求.trim().equalsIgnoreCase("求相对偏差"))
记录[统计字段号[k]] = "" + x2[统计字段号[k]] / x4[统计字段号[k]]
/ x0[统计字段号[k]] * 100;
else if (统计要求.trim().equalsIgnoreCase("求统计标准偏差"))
记录[统计字段号[k]] = ""
+ Math.sqrt(x3[统计字段号[k]] / (x4[统计字段号[k]] - 1));
else if (统计要求.trim().equalsIgnoreCase("求填充统计标准偏差"))
记录[统计字段号[k]] = "" + Math.sqrt(x3[统计字段号[k]] / x4[统计字段号[k]]);
else if (统计要求.trim().equalsIgnoreCase("求统计方差"))
记录[统计字段号[k]] = "" + x3[统计字段号[k]] / (x4[统计字段号[k]] - 1);
else if (统计要求.trim().equalsIgnoreCase("求填充统计方差"))
记录[统计字段号[k]] = "" + x3[统计字段号[k]] / x4[统计字段号[k]];
}
记录[分组字段号[分组字段号.length - 1]] = "总"
+ 统计要求.substring(1, 统计要求.length());
tableModel.addRow(记录);
}
表格数据1 = new String[tableModel.getRowCount()][列数];
for (int i = 0; i < tableModel.getRowCount(); i++)
for (int j = 0; j < 列数; j++) {
if (tableModel.getValueAt(i, j) == null)
表格数据1[i][j] = "";
else
表格数据1[i][j] = tableModel.getValueAt(i, j).toString().trim();
}
if (("求ABC分类").lastIndexOf(统计要求) >= 0) {
String g0 = "";
for (int i = 0; i <= 分组个数1; i++) {
for (int j = i; j <= 分组个数1; j++) {
if (Double.parseDouble(记录4[j][1]) > Double
.parseDouble(记录4[i][1])) {
for (int k = 0; k < 6; k++) {
g0 = 记录4[i][k];
记录4[i][k] = 记录4[j][k];
记录4[j][k] = g0;
}
}
}
}
Double g1 = 0.0; // 某一类总值
String g2[];
if (分类比例.indexOf(",") > 0)
g2 = 分类比例.split(",");
else
g2 = 分类比例.split("，");
String[] g3 = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" };
int g4 = 0; // 计数
Double g5[] = new Double[g2.length];
总记录数 = 0;
for (int i = 0; i < g2.length; i++)
g5[i] = Double.parseDouble(g2[i]);
for (int i = 0; i <= 分组个数1; i++) {
g1 = g1 + Double.parseDouble(记录4[i][1]);
记录4[i][3] = g3[g4]; // 分类名称
if (g1 > (总合计 * g5[g4] / 100)) {
g1 = 0.0;
g4++;
}
总记录数 = 总记录数 + Integer.parseInt(记录4[i][2]);
}
for (int i = 0; i <= 分组个数1; i++) {
记录4[i][4] = Double.parseDouble(记录4[i][1]) / 总合计 * 100 + "";
记录4[i][4] = (记录4[i][4] + " ").substring(0, 6);
记录4[i][5] = Double.parseDouble(记录4[i][2]) * 100 / 总记录数 + "";
记录4[i][5] = (记录4[i][5] + " ").substring(0, 6);
}
String[] g6 = { "分组数据", "小计值", "记录条数", "分类名称", "小计占比", "记录数占比" };
DefaultTableModel tableModel1 = new DefaultTableModel(记录4, g6); // 创建表格模型
JTable table1 = new JTable(tableModel1); // 创建指定表格模型的表格
table1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);// 设置表格的选择模式为单选
table1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table1.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < g6.length; i++) { // 设置表格每列宽度
TableColumn tc1 = table1.getColumn(g6[i]);
tc1.setPreferredWidth(10 * 8);
tc1.setMaxWidth(10 * 8);
tc1.sizeWidthToFit();
}
JScrollPane scrollPane1 = new JScrollPane();
scrollPane1.getViewport().add(table1, null);
scrollPane1.setBounds(30, 30, 窗口宽 - 100, 窗口高 - 200);
panel1.add(scrollPane1);
frame1.getContentPane().add(panel1, null);
frame1.setVisible(true);
}
}
}
版本2
59.源码59，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/**
* 程序文件名：dataStatistic3.java 作者：程学先 用途：对数据表每条记录中有关字段中的数据进行横向计算，
* 为方便设计，最终结果统一放在“临时表”中， 如果数据库中原来存在临时表，该表将先删除。 统计结果或修改某一列的数据，或放在新生的一列中。
* 完成日期：2013年1月22日 必须提供的参数：数据库“表名”、要求统计的字段名表“统计字段名集”、
* 统计类型要求结果字段名：“结果字段名”、“关键字段名”。 可选参数：“字段号表”、“按钮号表”。 本程序包括：统计、显示、打印、导出、退出等5个按钮。
* 其中打印要求要求先利用程序printFormat1.java生成格式文件
* 显示调用程序tableTenance.java显示，可以再排序显示，也可调用JAVA的打印类打印。
* 导出调用通用导出程序，可以选择纯文本文件、Office文件组织导出。 操作方法与注意事项：
* 在要求统计的字段名表“字段号表2”处可以输入多个字段名，为准备求和等统计的字段名。
* 输入字段名的数量、数据类型及意义见下面关于p01、p02、p03、……、p35说明的括号中的内容。
* 例如，如果统计要求选p01，即要求求统计方差，则可以输入三个以上的字段名， 对每条记录中这多个字段的数据求统计方差值。
* 又例如，统计要求为p04，即求根据某一整数型字段中的数据，求将其变为简述中文大写元角分表示的数据
* 在“字段号表3”处可以输入单个字段名，为保存统计结果的字段名， 如果为已有字段名，将用统计数据更新该字段数据，否则新生成该字段。
* 在“统计要求”处的参数只能为p01、p02、p03、……、p35中某一个。 其意义为： P01：统计方差∑(Xn-μ)^2
* /(n-1)（标准偏差的平方）(variabl10851,variabl10852 [,variabl10853 ...])
* P02：标准偏差Sqr(∑(Xn-μ)^2 /(n-1))(variabl10851,variabl10852 [,variabl10853 ...])
* P03：平均偏差∑(|Xn-μ|)/n(variabl10851,variabl10852 [,variabl10853 ...])
* P04：数字变为中文大写元角分(壹仟零叁拾元)(variabl1085) P05：数字变为中文元角分(一千零二十元)(variabl1085)
* P06：数字变为表格格式中文大写元角分(壹仟零佰贰拾零元)(variabl1085)
* P07：数字变为表格格式中文元角分(一千零百二十零元)(variabl1085)
* P08：变表格格式中文元角分(一仟零三十元零三角)为数字(variabl1105)
* P09：变表格格式中文大写元角分(壹仟零百贰拾零元叁角零分)为数字(variabl1105)
* P10：变中文元角分(亿,千,百,十,万,千,百,十,元,零,一,二,三,四,五,六,七,八,九)为数字 (variabl1105)
* P11：变大写中文(亿,仟,佰,拾,万,仟,佰,拾,元,零,壹,贰,叁,肆,伍,陆,柒,捌,玖)为数字 (variabl1105)
* P12：用大写字母返回指定的字符表达式(variabl1105)
* P13：对2个或3个表根据关键字名、关键字名1进行全连接，加上结果字段，根据字段序号生成并显示临时表
* P14：返回数字型星期值(日期类型字段)或(日期时间类型字段) P15：返回年份(日期类型字段)
* P16：返回字符型星期值(日期类型字段)或(日期时间类型字段) P17：日期时间表达式的小时部分(日期时间类型字段) 或(时间类型字段)
* P18：日期时间型表达式中的分钟部分(日期时间类型字段) 或(时间类型字段) P19：日期或日期时间表达式的月份值(日期时间类型字段)
* P20：日期时间型表达式中的秒钟部分(日期时间类型字段) 或(时间类型字段) P21：日期时间表达式中返回一个日期值(日期时间类型字段)
* P22：返回给定日期表达式中二个日期数据前一个日期减后一个日期间隔天数(二个日期类型字段，逗号分隔。)
* P23：以日期时间值返回当前的日期和时间(日期类型字段) P25：变日期为数字年月日（2003年 1月15日）(日期类型字段)
* P26：变日期格式为字符****.**.**格式(日期类型字段) ) P27：变日期格式为字符****-**-**格式(日期类型字段)
* P28：变日期格式为字符********格式(YYYYMMDD)(日期类型字段)
* P29：变中文年月日(二零零三年元月十五日)为日期格式(variabl1105) P30：变数字年月日（2003年
* 1月15日）格式为日期格式(variabl1105) P31：返回给定日期或日期时间表达式的月份英文名称(日期类型字段)或(日期时间类型字段)
* P32：求和(variabl10851,variabl10852 [,variabl10853 ...])。
* P33：求平均(variabl10851,variabl10852 [,variabl10853 ...])。
* P34：求最大(variabl10851,variabl10852 [,variabl10853 ...])。
* P35：求最小(variabl10851,variabl10852 [,variabl10853 ...])。
* P36：根据字符串求变换为UTF-16BE码(variabl1105) P37：根据接口参数文件中规定的条件将某字段数据改为新值，或产生新字段填充新值。
* 接口参数文件格式：序号。目标字段。条件表达式。计算公式。 例如：0。金额。序号>='0'。入库单价*入库数量。
* 1。金额。序号>='0'。入库单价*入库数量-出库单价*出库数量。
* P38：根据“统计字段名集”中的公式计算求值将某字段数据改为新值，或产生新字段填充新值。
* 调用tenanceEval1.tenanceeval1(String 数学表达式)完成求值， 因此可以采用更丰富的函数完成计算。
* 支持函数：sqrt,square,ceil,sin,cos,asin,acon.tan.atan,log,exp
* 注意计算公式在“统计字段名集”中输入，不能用字段序号。 必须手工输入由字段名、函数名、常数（只能是整型或双精度数）、括号、四则运算符号构成的公式。
* 可以联系代码表、字典表进行查询。 如果涉及代码表，在生成菜单程序时，在填表名时，应当先在列表框中选主表，再依次选代码表。
* 如果涉及字典表，将根据字典表给定的对应关系变换标签。 要求在当前数据库中有一个表的名字为某某某字典表，
* 即表名最后3个字是“字典表”，本程序将根据该表变换。 要求该表中只有二个字段，第一个字段（命名为字段名）中内容为所查询的数据表中字段名，
* 第二个字段（命名为标签名）内容为变换后的标签名。 所有统计字段名称要按变换前字段名提供。
* 本程序未对输入内容的数据类型、格式进行检查，如果出错或结果不正确，请检查修改输入参数值。
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.io.UnsupportedEncodingException;
public class dataStatistic3 extends JFrame {
static dataStatistic3 frame = new dataStatistic3();
private static JTable table;
static Connection con1;
static String url;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta4;
static ResultSet rs;
static int variabl2483 = 800, variabl2503 = 630;
static int variabl2651;
static String[][] variabl2517;
static String[] variabl1913;
static String variabl2053, variabl20531;
static String[] variabl1501;
static int[] variabl1489, variabl1571;
static int variabl1853 = 0;
static int variabl1527;
static String[][] variabl2197;
static String[][] variabl21971;
static DefaultTableModel model;
static String variabl2603, variabl2429, variabl26030;
static String variabl1251 = "";
static String variabl1873;
static String variabl1779;
static String variabl1735;
static String variabl1129, variabl11290;
static int[] variabl1173;
static String variabl1375;
static int variabl13750;
static String variabl2395;
static String variabl1987;
static String s1 = "", s2 = "", s3 = "";
static String s4 = "", s8 = "", s9 = "", T1 = "";
static int c = 0, b = 0, variabl2067 = 0;
static JPanel panel = new JPanel(false);
static JScrollPane scrollPane = new JScrollPane();
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2851 = 0, variabl2339 = 0;
static String variabl1633 = "", variabl16330 = "";
public static void means(String[] parameter) {
frame = new dataStatistic3();
variabl2483 = 800;
variabl2503 = 630;
variabl1853 = 0;
variabl1251 = "";
s1 = "";
s2 = "";
s3 = "";
s4 = "";
s8 = "";
s9 = "";
T1 = "";
c = 0;
b = 0;
variabl2067 = 0;
panel = new JPanel(false);
scrollPane = new JScrollPane();
String[] variabl240501 = { "统计", "显示", "导出", "退出" };
variabl2405 = new String[variabl240501.length];
variabl2851 = 0;
for (int i0 = 0; i0 < variabl240501.length; i0++)
variabl2405[i0] = variabl240501[i0];
if (parameter[11].length() > 0) {
variabl1187 = parameter[11];
variabl1187 = variabl1187.replaceAll("；", ";");
variabl1187 = variabl1187.replaceAll("。", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
variabl1187 = variabl1187.replaceAll("：", ";");
if (variabl1187.indexOf(";") > 0) {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
variabl2405[Integer.parseInt((s602[0]))] = s602[1];
variabl1187 = variabl1187 + "," + s602[0];
variabl2851++;
} else {
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
variabl1187 = s601[i01];
else
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
variabl1187 = "";
for (int i1 = 0; i1 < variabl2405.length; i1++) {
if (i1 == 0)
variabl1187 = variabl1187 + i1;
else
variabl1187 = variabl1187 + "," + i1;
variabl2851++;
}
}
variabl1187 = "," + variabl1187 + ",";
variabl2483 = main1.variabl2483;
variabl2503 = main1.variabl2503;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
variabl2483 = m1;
variabl2503 = m2;
}
} catch (Exception e2) {
}
variabl26030 = parameter[4];
String[] v01 = variabl26030.split(",");
variabl2603 = v01[0];
s8 = parameter[5];
s9 = parameter[20];
variabl2429 = "," + parameter[0] + ",";
variabl1735 = parameter[8];
variabl2053 = parameter[6];
variabl20531 = parameter[7];
variabl2395 = parameter[20];
if (variabl2053.indexOf(".") > 0)
variabl2053 = variabl2053.substring(variabl2053.indexOf(".") + 1,
variabl2053.length());
if (variabl20531.indexOf(".") > 0)
variabl20531 = variabl20531.substring(
variabl20531.indexOf(".") + 1, variabl20531.length());
variabl1779 = "," + parameter[11] + ",";
variabl1129 = parameter[9];
variabl11290 = variabl1129;
variabl1375 = parameter[10];
String[] ss = parameter[13].split(" ");
variabl1987 = ss[0];
if ((variabl1987.equalsIgnoreCase("p37"))
&& (variabl2429.indexOf(",") > 0))
JOptionPane
.showMessageDialog(null, "本统计项要求选单表操作，请注意输入到表名集中只能有一个表！");
variabl1633 = parameter[19];
variabl16330 = parameter[19];
variabl1251 = variabl1633;
if (variabl1633.substring(variabl1633.length() - 1).equalsIgnoreCase(
","))
variabl1633 = variabl1633.substring(0, variabl1633.length() - 1);
String variabl2429 = parameter[0];
String[] l3 = variabl1633.split(",");
variabl1873 = "";
String[] t1;
b = 0;
c = 0;
String s11 = variabl2603;
if (variabl2603.indexOf(",") > 0) {
String[] s12 = variabl2603.split(",");
s11 = s12[0];
}
if (variabl2429.lastIndexOf(s11 + "字典表") > 0) {
t1 = variabl2429.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(s11 + "字典表") >= 0)
variabl1873 = t1[i];
}
String[] l1;
if (variabl1735.length() > 0) {
l1 = variabl1735.split(",");
int[] l2 = new int[l1.length];
for (int i = 0; i < l1.length; i++) {
l2[i] = Integer.valueOf(l1[i]);
}
variabl2651 = l1.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[l2[i]];
variabl2517[1][i] = variabl2517[0][i];
}
} else {
variabl2651 = l3.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[i];
variabl2517[1][i] = variabl2517[0][i];
}
}
variabl1633 = "";
for (int i = 0; i < variabl2651; i++)
if (i < variabl2651 - 1)
variabl1633 = variabl1633 + variabl2517[0][i] + ",";
else
variabl1633 = variabl1633 + variabl2517[0][i];
if (variabl2429.indexOf(",临时表,") >= 0) {
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "drop table 临时表";
PreparedStatement stat5 = con.prepareStatement(s4);
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "临时表不存在！");
}
}
s1 = "";
for (int i = 0; i < variabl2651; i++)
s1 = s1 + variabl2517[0][i] + ",";
s1 = s1.substring(0, s1.length() - 1);
String s5 = "";
variabl13750 = 0;
if (("," + variabl1633 + ",").lastIndexOf("," + variabl1375 + ",") < 0) {
if ((",01,02,03,32,33,34,35,37,").lastIndexOf(","
+ variabl1987.substring(1, variabl1987.length()) + ",") >= 0) {
s5 = "alter table " + variabl2603 + " add " + variabl1375
+ " numeric (14,3) ";
variabl13750 = 0;
} else if ((",14,15,17,18,19,20,21,22,").lastIndexOf(","
+ variabl1987.substring(1, variabl1987.length()) + ",") >= 0) {
s5 = "alter table " + variabl2603 + " add " + variabl1375
+ " int ";
variabl13750 = 0;
} else if ((",16,31,").lastIndexOf(","
+ variabl1987.substring(1, variabl1987.length()) + ",") >= 0) {
s5 = "alter table " + variabl2603 + " add " + variabl1375
+ " char (6) ";
variabl13750 = 1;
} else if ((",23,24,25,26,27,").lastIndexOf(","
+ variabl1987.substring(1, variabl1987.length()) + ",") >= 0) {
s5 = "alter table " + variabl2603 + " add " + variabl1375
+ " char (12) ";
variabl13750 = 0;
} else {
s5 = "alter table " + variabl2603 + " add " + variabl1375
+ " char (20) ";
variabl13750 = 1;
}
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s5);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "添加字段失败！");
}
}
try {
s1 = "select * from " + variabl2603;
T1 = s1;
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
variabl2651 = rsmd4.getColumnCount();
variabl2517 = new String[2][variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
variabl2067 = 0;
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = rsmd4.getColumnName(i + 1);
variabl2517[1][i] = variabl2517[0][i];
variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
if (variabl2517[0][i].equalsIgnoreCase(variabl1375))
if (",bit,smallint,integer,int,tinyint,decimal,numeric,real,money,smallmoney,bigint,float,double,"
.lastIndexOf(variabl1501[i]) >= 0)
variabl13750 = 0;
else
variabl13750 = 1;
variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
if (variabl1489[i] < variabl2517[0][i].length())
variabl1489[i] = variabl2517[0][i].length();
if (variabl1489[i] < variabl2517[1][i].length())
variabl1489[i] = variabl2517[1][i].length();
if (variabl1489[i] > 50)
variabl1489[i] = 50;
variabl2067 = variabl2067 + variabl1489[i];
}
String[] b4 = variabl1129.split(",");
String[] s7 = parameter[19].split(",");
String s4[];
if (variabl1129.length() == 0)
variabl1129 = "0";
s4 = variabl1129.split(",");
variabl1129 = "";
if (variabl1987.indexOf("38") < 0)
for (int i = 0; i < s4.length; i++) {
s4[i] = s7[Integer.parseInt(s4[i])];
if (variabl1129.length() == 0)
variabl1129 = s4[i];
else
variabl1129 = variabl1129 + "," + s4[i];
}
variabl1173 = new int[b4.length];
for (int j = 0; j < b4.length; j++)
for (int i = 0; i < variabl2651; i++) {
if (s4[j].equalsIgnoreCase(variabl2517[0][i]))
variabl1173[j] = i;
}
variabl1913 = new String[variabl2651];
for (b = 0; b < variabl2651; b++) {
variabl1913[b] = variabl2517[1][b];
}
b4 = variabl1375.split(",");
variabl1375 = "";
for (int k = 0; k < b4.length; k++) {
if (b4[k].indexOf(".") > 0)
b4[k] = b4[k].substring(b4[k].indexOf(".") + 1);
if (k < b4.length - 1)
variabl1375 = variabl1375 + b4[k] + ",";
else
variabl1375 = variabl1375 + b4[k];
}
variabl1853 = 0;
rs.last();
variabl1853 = rs.getRow();
variabl2197 = new String[variabl1853][variabl2651];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据出错！");
}
if (variabl1873.length() > 0) {
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl1873;
rs = sta4.executeQuery(s1);
String s14 = "";
String s15 = "";
b = 1;
while (rs.absolute(b)) {
b++;
s14 = rs.getString(1).trim();
s15 = rs.getString(2).trim();
for (int j = 0; j < variabl2651; j++) {
if (variabl2517[0][j].trim().equalsIgnoreCase(
s14.trim())) {
variabl2517[1][j] = s15;
variabl1913[j] = s15;
break;
} else if ((variabl2517[0][j].trim() + ",").indexOf("."
+ s14 + ",") > 0) {
variabl2517[1][j] = variabl2517[1][j].replace(s14,
s15);
variabl1913[j] = s15;
break;
}
}
}
rs.close();
con1.close();
sta4.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错！");
}
}
frame.setTitle("横向数据统计部件。 作者：程学先");
frame.setBounds(10, 10, variabl2483, variabl2503);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
panel = new JPanel(false);
panel.setLayout(null);
panel.setBounds(10, 10, variabl2483, variabl2503);
scrollPane = new JScrollPane();
scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 120);
panel.add(scrollPane);
model = new DefaultTableModel(variabl2197, variabl2517[1]);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = table.getColumn(variabl2517[1][i]);
tc.setPreferredWidth(variabl1489[i] * 8);
tc.setMaxWidth(variabl1489[i] * 8);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
int j = 0;
variabl1779 = variabl1187;
if (variabl1779.length() < 3)
j = 5;
else
for (int i = 0; i < 5; i++)
if (variabl1779.lastIndexOf("," + i + ",") >= 0)
j = j + 1;
int variabl2339 = (variabl2483 - 30) / variabl2851;
int variabl1423 = 5;
JButton variabl2645 = new JButton(variabl2405[0]);
variabl2645.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
switch (Integer.parseInt(variabl1987.substring(1,
variabl1987.length()))) {
case 1: {
p01();
refrese();
break;
}
case 2: {
p02();
refrese();
break;
}
case 3: {
p03();
refrese();
break;
}
case 4: {
p04();
refrese();
break;
}
case 5: {
p05();
refrese();
break;
}
case 6: {
p06();
refrese();
break;
}
case 7: {
p07();
refrese();
break;
}
case 8: {
p08();
refrese();
break;
}
case 9: {
p09();
refrese();
break;
}
case 10: {
p10();
refrese();
break;
}
case 11: {
p11();
refrese();
break;
}
case 12: {
p12();
refrese();
break;
}
case 13: {
p13();
refrese();
break;
}
case 14: {
p14();
refrese();
break;
}
case 15: {
p15();
refrese();
break;
}
case 16: {
p16();
refrese();
break;
}
case 17: {
p17();
refrese();
break;
}
case 18: {
p18();
refrese();
break;
}
case 19: {
p19();
refrese();
break;
}
case 20: {
p20();
refrese();
break;
}
case 21: {
p21();
refrese();
break;
}
case 22: {
p22();
refrese();
break;
}
case 23: {
p23();
refrese();
break;
}
case 24: {
p24();
refrese();
break;
}
case 25: {
p25();
refrese();
break;
}
case 26: {
p26();
refrese();
break;
}
case 27: {
p27();
refrese();
break;
}
case 28: {
p28();
refrese();
break;
}
case 29: {
p29();
refrese();
break;
}
case 30: {
p30();
refrese();
break;
}
case 31: {
p31();
refrese();
break;
}
case 32: {
p32();
refrese();
break;
}
case 33: {
p33();
refrese();
break;
}
case 34: {
p34();
refrese();
break;
}
case 35: {
p35();
refrese();
break;
}
case 36: {
try {
p36();
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
refrese();
break;
}
case 37: {
p37();
refrese();
break;
}
case 38: {
p38();
refrese();
break;
}
}
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",0,") >= 0)) {
variabl2645.setBounds(variabl1423, variabl2503 - 90, variabl2339,
20);
panel.add(variabl2645);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl2541 = new JButton(variabl2405[1]);
variabl2541.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
tableTenance.tableModel(1000, 600, variabl2517[1], variabl1489,
variabl2197, variabl1501);
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",1,") >= 0)) {
variabl2541.setBounds(variabl1423, variabl2503 - 90, variabl2339,
20);
panel.add(variabl2541);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl2639 = new JButton(variabl2405[2]);
variabl2639.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataTransfer0.Trans(variabl2517[1], variabl1501, variabl1489,
"", variabl2197, variabl2603);
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",2,") >= 0)) {
variabl2639.setBounds(variabl1423, variabl2503 - 90, variabl2339,
20);
panel.add(variabl2639);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl2599 = new JButton(variabl2405[3]);
variabl2599.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",3,") >= 0)) {
variabl2599.setBounds(variabl1423, variabl2503 - 90, variabl2339,
20);
panel.add(variabl2599);
variabl1423 = variabl1423 + variabl2339;
}
frame.getContentPane().add(panel, null);
frame.setVisible(true);
frame.getContentPane().add(panel, BorderLayout.SOUTH);
}
public static void refrese() {
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs = sta4.executeQuery(T1);
rs.last();
variabl1853 = rs.getRow();
variabl2197 = new String[variabl1853][variabl2651];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据出错！");
}
scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 120);
model = new DefaultTableModel(variabl2197, variabl2517[1]);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = table.getColumn(variabl2517[1][i]);
tc.setPreferredWidth(variabl1489[i] * 8);
tc.setMaxWidth(variabl1489[i] * 8);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
panel.add(scrollPane);
}
public static void p01() {
String[] b4 = variabl1129.split(",");
if (b4.length < 2) {
JOptionPane.showMessageDialog(null, "统计字段少于2！");
return;
}
s1 = "";
for (int i = 0; i < b4.length; i++) {
s1 = s1 + b4[i] + "+";
}
s1 = "(" + s1.substring(0, s1.length() - 1) + ")/" + b4.length;
s2 = "";
for (int i = 0; i < b4.length; i++) {
s2 = s2 + "(" + b4[i] + "-" + s1 + ")" + "*" + "(" + b4[i] + "-"
+ s1 + ")" + "+";
}
s2 = s2.substring(0, s2.length() - 1);
s2 = "update " + variabl2603 + " set " + variabl1375 + " = (" + s2
+ ")/" + (b4.length - 1);
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s2);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p02() {
String[] b4 = variabl1129.split(",");
if (b4.length < 2) {
JOptionPane.showMessageDialog(null, "统计字段少于2！");
return;
}
s1 = "";
for (int i = 0; i < b4.length; i++) {
s1 = s1 + b4[i] + "+";
}
s1 = "(" + s1.substring(0, s1.length() - 1) + ")/" + b4.length;
s2 = "";
for (int i = 0; i < b4.length; i++) {
s2 = s2 + "(" + b4[i] + "-" + s1 + ")" + "*" + "(" + b4[i] + "-"
+ s1 + ")" + "+";
}
s2 = s2.substring(0, s2.length() - 1);
s2 = "update " + variabl2603 + " set " + variabl1375 + " = (" + s2
+ ")/" + (b4.length - 1);
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s2);
s1 = "update " + variabl2603 + " set " + variabl1375 + " = sqrt("
+ variabl1375 + ")";
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p03() {
String[] b4 = variabl1129.split(",");
s1 = "";
for (int i = 0; i < b4.length; i++) {
s1 = s1 + b4[i] + "+";
}
s1 = "(" + s1.substring(0, s1.length() - 1) + ")/" + b4.length;
s2 = "";
for (int i = 0; i < b4.length; i++) {
s2 = s2 + "sqrt((" + b4[i] + "-" + s1 + ")" + "*" + "(" + b4[i]
+ "-" + s1 + "))" + "+";
}
s2 = s2.substring(0, s2.length() - 1);
s2 = "update " + variabl2603 + " set " + variabl1375 + " = (" + s2
+ ")/" + b4.length;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s2);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p04() {
final HashMap<Integer, String> variabl2625 = new HashMap<Integer, String>();
final String[] variabl2109 = new String[] { "零", "壹", "贰", "叁", "肆",
"伍", "陆", "柒", "捌", "玖" };
variabl2625.put(-2, "分");
variabl2625.put(-1, "角");
variabl2625.put(0, "元");
variabl2625.put(1, "拾");
variabl2625.put(2, "佰");
variabl2625.put(3, "仟");
variabl2625.put(4, "万");
variabl2625.put(5, "拾");
variabl2625.put(6, "佰");
variabl2625.put(7, "仟");
variabl2625.put(8, "亿");
variabl2625.put(9, "拾");
variabl2625.put(10, "佰");
variabl2625.put(11, "仟");
variabl2625.put(12, "万");
StringBuffer variabl2427 = new StringBuffer();
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, variabl1173[0]) != null) {
s2 = model.getValueAt(i1, variabl1173[0]).toString();
s1 = "";
variabl2427 = new StringBuffer();
s2 = variabl1977(s2);
String variabl1943 = null;
String variabl1775 = null;
if (s2.contains(".")) {
variabl1943 = s2.split("\\.")[0];
variabl1775 = s2.split("\\.")[1];
} else {
variabl1943 = s2;
}
if (variabl1943.length() > 0) {
for (int i = 0; i < variabl1943.length(); i++) {
String variabl2691 = variabl1943.substring(i, i + 1);
int variabl1443 = variabl1943.length() - i - 1;
Integer variabl2383 = Integer.parseInt(variabl2691
.toString());
String variabl1695 = variabl2625.get(variabl1443);
String variabl1969 = variabl2109[Integer
.parseInt(variabl2691)];
if (variabl2383 == 0) {
if (variabl1443 % 4 != 0) {
variabl1695 = "";
}
if (i < variabl1943.length() - 1) {
Integer variabl23831 = Integer
.parseInt(variabl1943.substring(i + 1,
i + 2));
if (variabl2383 == 0
&& variabl2383 == variabl23831)
variabl1969 = "";
} else if (i == variabl1943.length() - 1)
variabl1969 = "";
}
variabl2427.append(variabl1969 + variabl1695);
}
}
if (variabl1775 != null) {
variabl1943 = variabl1775.substring(0, 1);
if (!"0".equalsIgnoreCase(variabl1943))
variabl2427.append(variabl2109[Integer
.parseInt(variabl1943)] + variabl2625.get(-1));
if (variabl1775.length() == 2) {
variabl1943 = variabl1775.substring(1, 2);
if (!"0".equalsIgnoreCase(variabl1943))
variabl2427.append(variabl2109[Integer
.parseInt(variabl1943)]
+ variabl2625.get(-2));
}
}
s1 = "";
for (int i = 0; i < variabl2427.toString().length(); i++)
if ((variabl2427.toString().substring(i, i + 1)
.equalsIgnoreCase("零"))
&& (i < variabl2427.toString().length() - 1)
&& (variabl2427.toString().substring(i + 1, i + 2)
.equalsIgnoreCase("万")))
s1 = s1;
else
s1 = s1 + variabl2427.toString().substring(i, i + 1);
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '"
+ s1 + "' where " + variabl1129 + " ='" + s2 + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
private static String variabl1977(String string1) {
if ("0".equalsIgnoreCase(string1.substring(0, 1))) {
return variabl1977(string1.substring(1, string1.length()));
} else if (string1.contains(",")) {
return variabl1977(string1.replaceAll(",", ""));
} else {
return string1;
}
}
public static void p05() {
final HashMap<Integer, String> variabl2625 = new HashMap<Integer, String>();
final String[] variabl2109 = new String[] { "零", "一", "二", "三", "四",
"五", "六", "七", "八", "九" };
variabl2625.put(-2, "分");
variabl2625.put(-1, "角");
variabl2625.put(0, "元");
variabl2625.put(1, "十");
variabl2625.put(2, "百");
variabl2625.put(3, "千");
variabl2625.put(4, "万");
variabl2625.put(5, "十");
variabl2625.put(6, "百");
variabl2625.put(7, "仟");
variabl2625.put(8, "亿");
variabl2625.put(9, "十");
variabl2625.put(10, "百");
variabl2625.put(11, "千");
variabl2625.put(12, "万");
StringBuffer variabl2427 = new StringBuffer();
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, variabl1173[0]) != null) {
s2 = model.getValueAt(i1, variabl1173[0]).toString();
s1 = "";
variabl2427 = new StringBuffer();
s2 = variabl1977(s2);
String variabl1943 = null;
String variabl1775 = null;
if (s2.contains(".")) {
variabl1943 = s2.split("\\.")[0];
variabl1775 = s2.split("\\.")[1];
} else {
variabl1943 = s2;
}
if (variabl1943.length() > 0) {
for (int i = 0; i < variabl1943.length(); i++) {
String variabl2691 = variabl1943.substring(i, i + 1);
int variabl1443 = variabl1943.length() - i - 1;
Integer variabl2383 = Integer.parseInt(variabl2691
.toString());
String variabl1695 = variabl2625.get(variabl1443);
String variabl1969 = variabl2109[Integer
.parseInt(variabl2691)];
if (variabl2383 == 0) {
if (variabl1443 % 4 != 0) {
variabl1695 = "";
}
if (i < variabl1943.length() - 1) {
Integer variabl23831 = Integer
.parseInt(variabl1943.substring(i + 1,
i + 2));
if (variabl2383 == 0
&& variabl2383 == variabl23831)
variabl1969 = "";
} else if (i == variabl1943.length() - 1)
variabl1969 = "";
}
variabl2427.append(variabl1969 + variabl1695);
}
}
if (variabl1775 != null) {
variabl1943 = variabl1775.substring(0, 1);
if (!"0".equalsIgnoreCase(variabl1943))
variabl2427.append(variabl2109[Integer
.parseInt(variabl1943)] + variabl2625.get(-1));
if (variabl1775.length() == 2) {
variabl1943 = variabl1775.substring(1, 2);
if (!"0".equalsIgnoreCase(variabl1943))
variabl2427.append(variabl2109[Integer
.parseInt(variabl1943)]
+ variabl2625.get(-2));
}
}
s1 = "";
for (int i = 0; i < variabl2427.toString().length(); i++)
if ((variabl2427.toString().substring(i, i + 1)
.equalsIgnoreCase("零"))
&& (i < variabl2427.toString().length() - 1)
&& (variabl2427.toString().substring(i + 1, i + 2)
.equalsIgnoreCase("万")))
s1 = s1;
else
s1 = s1 + variabl2427.toString().substring(i, i + 1);
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '"
+ s1 + "' where " + variabl1129 + " ='" + s2 + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p06() {
String x[] = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
String y[] = { "元", "十", "百", "千", "万", "十", "百", "千", "亿", "十" };
String y1[] = { "角", "分", " ", " ", " ", " ", " " };
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, variabl1173[0]) != null) {
s1 = model.getValueAt(i1, variabl1173[0]).toString().trim();
s2 = "";
String[] s6 = new String[1];
if (s2.lastIndexOf(".") > 0)
s6 = s1.split(".");
else
s6[0] = s1;
for (int k = 0; k < s6.length; k++)
for (int i = 0; i < s6[k].length(); i++)
for (int j = 0; j < 10; j++)
if (s6[k].substring(i, i + 1).equalsIgnoreCase(
"" + j))
s2 = s2 + x[j] + y[s6[k].length() - i - 1];
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '"
+ s2 + "' where " + variabl1129 + " ='" + s1 + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p07() {
String x[] = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
String y[] = { "元", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾" };
String y1[] = { "角", "分", " ", " ", " ", " ", " " };
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, variabl1173[0]) != null) {
s1 = model.getValueAt(i1, variabl1173[0]).toString().trim();
s2 = "";
String[] s6 = new String[1];
if (s2.lastIndexOf(".") > 0)
s6 = s1.split(".");
else
s6[0] = s1;
for (int k = 0; k < s6.length; k++)
for (int i = 0; i < s6[k].length(); i++)
for (int j = 0; j < 10; j++)
if (s6[k].substring(i, i + 1).equalsIgnoreCase(
"" + j))
s2 = s2 + x[j] + y[s6[k].length() - i - 1];
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '"
+ s2 + "' where " + variabl1129 + " ='" + s1 + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p08() {
String[] variabl2675 = { "亿", "千", "百", "十", "万", "千", "百", "十", "元" };
String[] variabl2649 = { "零", "一", "二", "三", "四", "五", "六", "七", "八",
"九", "十" };
int variabl2293[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
String s = "";
int sum = 0, sum1 = 0;
int k = 0;
String x = "", x1 = "";
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, variabl1173[0]) != null) {
s = model.getValueAt(i1, variabl1173[0]).toString() + " ";
sum = 0;
sum1 = 0;
for (int i = 0; i < s.length() - 1; i++) {
x = s.substring(i, i + 1);
x1 = s.substring(i + 1, i + 2);
if (x1.equalsIgnoreCase("亿")) {
sum1 = sum1 + k;
sum = sum1 * 100000000;
sum1 = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("万")) {
sum1 = sum1 + k;
sum = sum + sum1 * 10000;
sum1 = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("千")) {
sum1 = sum1 + k * 1000;
i++;
continue;
}
if (x1.equalsIgnoreCase("百")) {
sum1 = sum1 + k * 100;
i++;
continue;
}
if (x1.equalsIgnoreCase("十")) {
sum1 = sum1 + k * 10;
i++;
continue;
}
if (x1.equalsIgnoreCase("元")) {
sum = sum + sum1 + k;
break;
}
}
}
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '" + sum
+ "' where " + variabl1129 + " ='" + s + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
public static void p09() {
String[] variabl2675 = { "亿", "仟", "佰", "拾", "万", "仟", "佰", "拾", "元" };
String[] variabl2649 = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌",
"玖", "拾" };
int variabl2293[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
String s = "";
int sum = 0, sum1 = 0;
int k = 0;
String x = "", x1 = "";
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, variabl1173[0]) != null) {
s = model.getValueAt(i1, variabl1173[0]).toString() + " ";
sum = 0;
sum1 = 0;
for (int i = 0; i < s.length() - 1; i++) {
x = s.substring(i, i + 1);
x1 = s.substring(i + 1, i + 2);
if (x1.equalsIgnoreCase("亿")) {
sum1 = sum1 + k;
sum = sum1 * 100000000;
sum1 = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("万")) {
sum1 = sum1 + k;
sum = sum + sum1 * 10000;
sum1 = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("仟")) {
sum1 = sum1 + k * 1000;
i++;
continue;
}
if (x1.equalsIgnoreCase("佰")) {
sum1 = sum1 + k * 100;
i++;
continue;
}
if (x1.equalsIgnoreCase("拾")) {
sum1 = sum1 + k * 10;
i++;
continue;
}
if (x1.equalsIgnoreCase("元")) {
sum = sum + sum1 + k;
break;
}
}
}
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '" + sum
+ "' where " + variabl1129 + " ='" + s + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
public static void p10() {
String[] variabl2675 = { "亿", "千", "百", "十", "万", "千", "百", "十", "元" };
String[] variabl2649 = { "零", "一", "二", "三", "四", "五", "六", "七", "八",
"九", "十" };
int variabl2293[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
String s = "";
int sum = 0, sum1 = 0;
int k = 0;
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, variabl1173[0]) != null) {
s = model.getValueAt(i1, variabl1173[0]).toString() + " ";
String x = "", x1 = "";
sum = 0;
sum1 = 0;
for (int i = 0; i < s.length() - 1; i++) {
x = s.substring(i, i + 1);
x1 = s.substring(i + 1, i + 2);
for (int j = 0; j < variabl2649.length; j++)
if (x.trim().equalsIgnoreCase(variabl2649[j].trim()))
k = j;
if (x1.trim().equalsIgnoreCase("亿")) {
sum1 = sum1 + k;
sum = sum1 * 100000000;
sum1 = 0;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("万")) {
sum1 = sum1 + k;
sum = sum + sum1 * 10000;
sum1 = 0;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("千")) {
sum1 = sum1 + k * 1000;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("百")) {
sum1 = sum1 + k * 100;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("十")) {
sum1 = sum1 + k * 10;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("元")) {
sum = sum + sum1 + k;
break;
}
}
}
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '" + sum
+ "' where " + variabl1129 + " ='" + s + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
public static void p11() {
String[] variabl2675 = { "亿", "仟", "佰", "拾", "万", "仟", "佰", "拾", "元" };
String[] variabl2649 = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌",
"玖", "拾" };
int variabl2293[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
String s = "";
int sum = 0, sum1 = 0;
int y = 0, k = 0;
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, variabl1173[0]) != null) {
s = model.getValueAt(i1, variabl1173[0]).toString() + " ";
s2 = "";
String x = "", x1 = "";
sum = 0;
sum1 = 0;
for (int i = 0; i < s.length() - 1; i++) {
x = s.substring(i, i + 1);
if (x.equalsIgnoreCase("元")) {
sum = sum + sum1;
break;
}
if (x.equalsIgnoreCase("亿")) {
sum = sum1 * 100000000;
sum1 = 0;
continue;
}
if (x.equalsIgnoreCase("万")) {
sum = sum + sum1 * 10000;
sum1 = 0;
continue;
}
if (x.equalsIgnoreCase("零"))
continue;
x1 = s.substring(i + 1, i + 2);
for (int j = 0; j < variabl2649.length; j++)
if (x.equalsIgnoreCase(variabl2649[j]))
k = j;
if (x1.equalsIgnoreCase("亿")) {
sum1 = sum1 + k;
sum = sum1 * 100000000;
sum1 = 0;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("万")) {
sum1 = sum1 + k;
sum = sum + sum1 * 10000;
sum1 = 0;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("仟")) {
sum1 = sum1 + k * 1000;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("佰")) {
sum1 = sum1 + k * 100;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("拾")) {
sum1 = sum1 + k * 10;
k = 0;
i++;
continue;
}
if (x1.equalsIgnoreCase("元")) {
sum = sum + sum1 + k;
break;
}
}
}
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '" + sum
+ "' where " + variabl1129 + " ='" + s + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
public static void p12() {
s1 = "update " + variabl2603 + " set " + variabl1375 + " = UPPER("
+ variabl1129 + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p13() {
if (variabl26030.indexOf(",") < 0) {
JOptionPane.showMessageDialog(null, "要求至少有二表，彼此间用逗号分隔！");
return;
}
if (variabl2053.length() == 0) {
JOptionPane.showMessageDialog(null, "要求有表1关键字名！");
return;
}
if (variabl20531.length() == 0) {
JOptionPane.showMessageDialog(null, "要求有表2关键字名，放在关键字名1中！");
return;
}
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "drop table 临时表";
PreparedStatement stat5 = con.prepareStatement(s4);
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
}
String[] s0 = variabl26030.split(",");
String s01 = "";
s01 = "临时表";
s1 = "select " + s0[0] + ".* into " + s01 + " from " + s0[0]
+ " FULL JOIN " + s0[1] + " on " + s0[0] + "." + variabl2053
+ "=" + s0[1] + "." + variabl20531;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "生成全连接表出错！");
}
}
public static void p36() throws UnsupportedEncodingException {
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
if (model.getValueAt(i1, variabl1173[0]) != null) {
s1 = model.getValueAt(i1, variabl1173[0]).toString() + " ";
byte[] bs = s1.getBytes();
s2 = new String(bs, "UTF-16BE");
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '"
+ s2 + "' where " + variabl1129 + " ='" + s1 + "'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p14() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = DatePart(weekday," + variabl1129 + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p15() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = datename(Year," + variabl1129 + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p16() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = datename(weekday," + variabl1129 + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p17() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = datename(Hour," + variabl1129 + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p18() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = datename(Minute," + variabl1129 + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p19() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = datename(Month," + variabl1129 + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p20() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = datename(Second," + variabl1129 + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p21() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = datename(Day," + variabl1129 + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p22() {
String[] s6 = variabl1129.split(",");
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = DATEDIFF ( day," + s6[0] + "," + s6[1] + ")";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p23() {
s1 = "update " + variabl2603 + " set " + variabl1375 + " = getdate()";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p24() {
String[] s6 = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
for (int i = 0; i < model.getRowCount(); i++) {
if (model.getValueAt(i, variabl1173[0]) != null) {
s1 = model.getValueAt(i, variabl1173[0]).toString();
s2 = "";
for (int j = 0; j < 4; j++) {
s2 = s2 + s6[Integer.parseInt(s1.substring(j, j + 1))];
}
s2 = s2 + "年";
if (s1.substring(5, 6).equalsIgnoreCase("1"))
s2 = s2 + "十";
if (s1.substring(6, 7).compareTo("0") > 0)
s2 = s2 + s6[Integer.parseInt(s1.substring(6, 7))];
s2 = s2 + "月";
if (s1.substring(8, 9).equalsIgnoreCase("1"))
s2 = s2 + "十";
else if (s1.substring(8, 9).equalsIgnoreCase("2"))
s2 = s2 + "二十";
else if (s1.substring(8, 9).equalsIgnoreCase("3"))
s2 = s2 + "三十";
if (s1.substring(9, 10).compareTo("0") > 0)
s2 = s2 + s6[Integer.parseInt(s1.substring(9, 10))];
s2 = s2 + "日";
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '"
+ s2 + "' where ";
s2 = variabl1129 + " ='"
+ model.getValueAt(i, variabl1173[0]).toString() + "'";
s3 = s3 + s2;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p25() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = DATENAME (yy," + variabl1129 + ")+'年'+DATENAME (mm,"
+ variabl1129 + ")+'月'+DATENAME (dd," + variabl1129 + ")+'日'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p26() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = CONVERT(varchar(100)," + variabl1129 + ",102)";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p27() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = CONVERT(varchar(100)," + variabl1129 + ",25)";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p28() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = CONVERT(varchar(100)," + variabl1129 + ",112)";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p29() {
String[] s6 = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
int n = 0;
for (int i = 0; i < model.getRowCount(); i++) {
if (model.getValueAt(i, variabl1173[0]) != null) {
s1 = model.getValueAt(i, variabl1173[0]).toString();
s2 = "";
for (int j = 0; j < s1.length(); j++) {
if (s1.substring(j, j + 1).equalsIgnoreCase("年"))
s2 = s2 + "-";
else if (s1.substring(j, j + 1).equalsIgnoreCase("月"))
s2 = s2 + "-";
else if (s1.substring(j, j + 1).equalsIgnoreCase("日"))
s2 = s2;
else if (s1.substring(j, j + 1).equalsIgnoreCase("元"))
s2 = s2 + "1";
else if (((s1.substring(j, j + 1).equalsIgnoreCase("十")) || ((s1
.substring(j, j + 1).equalsIgnoreCase("拾"))))
&& ((s1.substring(j + 1, j + 2)
.equalsIgnoreCase("月")) || ((s1.substring(
j + 1, j + 2).equalsIgnoreCase("日")))))
s2 = s2 + "10";
else if ((s1.substring(j, j + 1).equalsIgnoreCase("十"))
|| ((s1.substring(j, j + 1).equalsIgnoreCase("拾"))))
s2 = s2 + "1";
else if (((s1.substring(j, j + 2).equalsIgnoreCase("二十")) || ((s1
.substring(j, j + 2).equalsIgnoreCase("贰拾"))))
&& ((s1.substring(j + 2, j + 3)
.equalsIgnoreCase("月")) || ((s1.substring(
j + 2, j + 3).equalsIgnoreCase("日"))))) {
s2 = s2 + "20";
j++;
} else if ((s1.substring(j, j + 2).equalsIgnoreCase("二十"))
|| ((s1.substring(j, j + 2).equalsIgnoreCase("贰拾")))) {
s2 = s2 + "2";
j++;
} else if (((s1.substring(j, j + 2).equalsIgnoreCase("三十")) || ((s1
.substring(j, j + 2).equalsIgnoreCase("叁拾"))))
&& ((s1.substring(j + 2, j + 3)
.equalsIgnoreCase("月")) || ((s1.substring(
j + 2, j + 3).equalsIgnoreCase("日"))))) {
s2 = s2 + "30";
j++;
} else if ((s1.substring(j, j + 2).equalsIgnoreCase("三十"))
|| ((s1.substring(j, j + 2).equalsIgnoreCase("叁拾")))) {
s2 = s2 + "3";
j++;
} else {
for (int k = 0; k < 10; k++)
if (s1.substring(j, j + 1).equalsIgnoreCase(s6[k]))
n = k;
s2 = s2 + n;
}
}
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '"
+ s2 + "' where ";
s2 = variabl1129 + " ='"
+ model.getValueAt(i, variabl1173[0]).toString() + "'";
s3 = s3 + s2;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
}
public static void p30() {
s1 = "update " + variabl2603 + " set " + variabl1375
+ " = DATENAME (yy," + variabl1129 + ")+'年'+DATENAME (mm,"
+ variabl1129 + ")+'月'+DATENAME (dd," + variabl1129 + ")+'日'";
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p31() {
String[] s6 = { "", "January", "February", "March", "April", "May",
"June", "July", "August", "September", "October", "November",
"December" };
for (int i = 1; i <= 12; i++) {
s3 = "update " + variabl2603 + " set " + variabl1375 + " = '"
+ s6[i] + "' where Month(" + variabl1129 + ") =" + i;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s3);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
}
public static void p32() {
String[] b4 = variabl1129.split(",");
s1 = "";
for (int i = 0; i < b4.length; i++) {
s1 = s1 + b4[i] + "+";
}
s1 = s1.substring(0, s1.length() - 1);
s1 = "update " + variabl2603 + " set " + variabl1375 + " = " + s1;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p33() {
String[] b4 = variabl1129.split(",");
s1 = "";
for (int i = 0; i < b4.length; i++) {
s1 = s1 + b4[i] + "+";
}
s1 = s1.substring(0, s1.length() - 1);
s1 = "update " + variabl2603 + " set " + variabl1375 + " = (" + s1
+ ")/" + b4.length;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p34() {
String[] b4 = variabl1129.split(",");
variabl1173 = new int[b4.length];
for (int j = 0; j < b4.length; j++)
for (int i = 0; i < variabl2651; i++) {
if (b4[j].equalsIgnoreCase(variabl2517[0][i]))
variabl1173[j] = i;
}
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "update " + variabl2603 + " set " + variabl1375 + " = "
+ variabl2517[0][variabl1173[0]];
sta4.executeUpdate(s1);
for (int j = 1; j < b4.length; j++) {
s1 = "update " + variabl2603 + " set " + variabl1375 + " = "
+ variabl2517[0][variabl1173[j]] + " where "
+ variabl2517[0][variabl1173[j]] + ">" + variabl1375;
sta4.executeUpdate(s1);
}
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p35() {
String[] b4 = variabl1129.split(",");
variabl1173 = new int[b4.length];
for (int j = 0; j < b4.length; j++)
for (int i = 0; i < variabl2651; i++) {
if (b4[j].equalsIgnoreCase(variabl2517[0][i]))
variabl1173[j] = i;
}
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "update " + variabl2603 + " set " + variabl1375 + " = "
+ variabl2517[0][variabl1173[0]];
sta4.executeUpdate(s1);
for (int j = 1; j < b4.length; j++) {
s1 = "update " + variabl2603 + " set " + variabl1375 + " = "
+ variabl2517[0][variabl1173[j]] + " where "
+ variabl2517[0][variabl1173[j]] + "<" + variabl1375;
sta4.executeUpdate(s1);
}
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "更新出错！");
}
}
public static void p37() {
String[] s11 = new String[500];
String[] s12;
String s13 = "*";
int s10 = 0;
try {
File file1 = new File(s8);
if (file1.exists()) {
FileReader fr = new FileReader(file1);
BufferedReader br = new BufferedReader(fr);
String tempStr = null;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
if (tempStr.trim().length() < 1)
break;
s10 = i;
s11[s10] = tempStr;
}
}
} catch (IOException e2) {
JOptionPane.showMessageDialog(null, "打开文件错！");
}
String sk = variabl1633;
if (s8.length() > 0)
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "drop table 临时表";
PreparedStatement stat5 = con.prepareStatement(s4);
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "临时表不存在！");
}
for (int j = 0; j <= s10; j++) {
s12 = s11[j].split("。");
if ((s12[1] != null) && (s12[1].length() > 0)
&& (sk.indexOf(s12[1]) < 0))
if (s11[j].indexOf("'") > 0)
sk = sk + ",' ' as " + s12[1];
else
sk = sk + ",1000000000.0000 as " + s12[1];
}
s1 = "select " + sk + " into 临时表 from " + variabl26030;
s2 = s1;
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s2);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "生成临时表失败！");
}
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "";
for (int j = 0; j <= s10; j++) {
s12 = s11[j].split("。");
if ((s11[j] != null) && (s11[j].length() > 0)) {
variabl1375 = s12[1];
}
if (variabl1375.length() > 0) {
s1 = "update 临时表 set " + variabl1375 + " = " + s12[3];
if (s12[2].length() > 0)
s1 = s1 + " where " + s12[2];
}
sta4.executeUpdate(s1);
s1 = "";
}
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null,
"更新出错！请检查表中数据情况，是否存在计算式结果为空值的情况。");
}
if (variabl26030.indexOf(",") > 0) {
s12 = variabl26030.split(",");
variabl2603 = s12[0];
variabl1005(s12[0]);
if (("," + variabl1251 + ",").indexOf("," + variabl1375 + ",") >= 0) {
s13 = variabl1251;
} else
s13 = variabl1251 + "," + variabl1375;
}
Object[] options = { "更换" + variabl2603, "保持原表", "退出" };
int variabl4043 = (JOptionPane.showOptionDialog(null, "请确定是否将"
+ variabl2603 + "换成所显示内容", "请确定是否将" + variabl2603 + "换成所显示内容",
JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null,
options, options[1]));
if (variabl4043 == 0) {
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "drop table " + variabl2603;
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "删除失败！");
}
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "select " + s13 + " into " + variabl2603
+ " from 临时表";
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "更新失败！");
}
}
}
public static void p38() {
if (variabl1375.length() == 0) {
JOptionPane.showMessageDialog(null, "缺少结果字段名！");
return;
}
if (variabl26030.length() == 0) {
JOptionPane.showMessageDialog(null, "缺少表名！");
return;
}
if (variabl2053.length() == 0) {
JOptionPane.showMessageDialog(null, "缺少关键字段名称！");
return;
}
String[] s11 = new String[500];
String sk = variabl1633;
if (s8.length() > 0)
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s4 = "drop table 临时表";
PreparedStatement stat5 = con.prepareStatement(s4);
stat3.executeUpdate(s4);
stat3.close();
con.close();
} catch (SQLException e1) {
}
s1 = "select " + variabl1251 + " into 临时表 from " + variabl26030;
if (variabl2395.length() > 0)
s1 = s1 + " where " + variabl2395;
s2 = s1;
try {
Connection con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s2);
stat3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "生成临时表失败！");
}
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "";
String s0 = variabl11290;
String 计算结果 = "";
String[] s3 = variabl2053.split(",");
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
s0 = variabl11290;
for (int j1 = 0; j1 < variabl2517[0].length; j1++) {
s1 = "";
if (s0.indexOf(variabl2517[0][j1]) >= 0) {
s0 = s0.replaceAll(variabl2517[0][j1],
variabl2197[i1][j1]);
}
for (int j2 = 0; j2 < s3.length; j2++)
if (s3[j2].equals(variabl2517[0][j1])) {
if (s1.length() == 0)
s1 = " where " + s3[j2] + "="
+ variabl2197[i1][j1];
else
s1 = s1 + " and " + s3[j2] + "="
+ variabl2197[i1][j1];
}
}
计算结果 = tenanceEval1.tenanceeval1(s0);
{
s1 = "update 临时表 set " + variabl1375 + " = " + 计算结果 + s1;
sta4.executeUpdate(s1);
}
}
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null,
"更新出错！请检查表中数据情况，是否存在计算式结果为空值的情况。");
}
}
static void variabl1005(String variabl1103) {
variabl1251 = "";
String[] s14;
int s15 = 0;
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1 = "select * from " + variabl1103;
rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
s15 = rsmd4.getColumnCount();
s14 = new String[s15];
for (int i = 0; i < s15; i++) {
s14[i] = rsmd4.getColumnName(i + 1);
if (variabl1251.length() == 0)
variabl1251 = s14[i];
else
variabl1251 = variabl1251 + "," + s14[i];
}
rs.absolute(1);
rs.close();
sta4.close();
con1.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错！");
}
}
}
60.源码60，公用程序，四则表达式求值宏替换程序。应用双精度或整型常量加上运算符（+、-、*、/、%、(、)、）及函数：sqrt,square,ceil,sin,cos,asin,acon.tan.atan,log,exp构成表达式，求其运算结果。
/**
* 程序文件名：tenanceEval1.java
* 作者：程学先
* 功能：四则表达式求值宏替换程序
* 完成日期：2015年3月11日
* 修改时间2018.5.25
* 数学表达式中运算符可包括：+、-、*、/、%、(、)、
* 支持函数：sqrt,square,ceil,sin,cos,asin,acon.tan.atan,log,exp
* 具体含义见程序代码
* 调用：tenanceEval1.tenanceeval1(String 数学表达式)
* 以字符串形式返回表达式的值
*/
import java.util.Stack;
public class tenanceEval1 {
public static tenanceEval1 be = new tenanceEval1();
public static String variabl1563 = "";
public static String tenanceeval1(String variabl1563) {
int k1 = 0, k2 = 0;
String x1 = variabl1563, s2 = "";
x1 = x1.replaceAll("(sqrt)|(square)|(ceil)|(sin)|(cos)|(asin)|"
+ "(acon)|(tan)|(atan)|(log)|(exp)(sqrt)|(square)|(ceil)|"
+ "(sin)|(cos)|(asin)|(acon)|(tan)|(atan)|(log)|(exp)", "￥");
if (x1.length() != variabl1563.length()) {
variabl1563 = be.variabl1567(x1, variabl1563);
}
while (variabl1563.indexOf("(") >= 0) {
variabl1563 = be.variabl15652(variabl1563);
}
x1 = variabl1563;
x1 = x1.replaceAll("[-/%]", "");
x1 = x1.replaceAll("[\\+]", "");
x1 = x1.replaceAll("[\\*]", "");
if (x1.length() != variabl1563.length()) {
variabl1563 = variabl1563(variabl1563);
}
return variabl1563;
}
protected String variabl15652(String s) {
String[] s0 = s.split("\\(");
String[] s1 = s0[s0.length - 1].split("\\)");
int n1 = 0, n2 = 0;
String s2 = "", s3 = "";
for (int i = 0; i < s0.length - 1; i++) {
n1 = n1 + s0[i].length() + 1;
s2 = s2 + s0[i];
if (i < s0.length - 2)
s2 = s2 + "(";
}
n2 = n1 + s1[0].length() + 1;
s3 = s.substring(n2, s.length());
s = s.substring(n1 - 1, n2);
n1--;
s = s.replaceAll("(\\()|(\\))", "");
variabl1563(s);
variabl1563 = s2 + variabl1563 + s3;
return variabl1563;
}
public static String variabl1563(String s) {
String s1 = s.replaceAll("[-/%]", "*");
s1 = s1.replaceAll("[\\+]", "*");
String[] s0 = s1.split("\\*");
int[] l0 = new int[s0.length];
String[] s01 = new String[s0.length];
String[] l1 = new String[s0.length];
String[] l2 = new String[s0.length];
Stack variabl15671 = new Stack();
Stack variabl15672 = new Stack();
Stack variabl15673 = new Stack();
Stack variabl15674 = new Stack();
String sm1 = "", sm2 = "", sn1, sn2, sn3, sn4;
int n = 0, n1 = 0;
double d1 = 0.0, d2 = 0.0;
l2[0] = "";
for (int i = 0; i < s0.length; i++) {
l0[i] = s0[i].length();
n = n + s0[i].length();
s01[i] = s0[i];
if (i < s0.length - 1) {
l2[i + 1] = s.substring(n, n + 1);
n++;
}
}
for (int i = s0.length - 1; i >= 0; i--) {
variabl15671.push(s0[i]);
variabl15672.push(l2[i]);
}
n = variabl15671.size();
for (int i = 0; i < n; i++) {
sn1 = variabl15671.pop().toString();
sn2 = variabl15672.pop().toString();
if (sn2.equals("*")) {
d1 = Double.parseDouble(sm1) * Double.parseDouble(sn1);
sm1 = d1 + "";
s01[i] = sm1;
s01[i - 1] = "";
l2[i] = l2[i - 1];
l2[i - 1] = "";
} else if (sn2.equals("/")) {
d1 = Double.parseDouble(sm1) / Double.parseDouble(sn1);
sm1 = d1 + "";
s01[i] = sm1;
s01[i - 1] = "";
l2[i] = l2[i - 1];
l2[i - 1] = "";
} else if (sn2.equals("%")) {
d1 = Double.parseDouble(sm1) % Double.parseDouble(sn1);
sm1 = d1 + "";
s01[i] = sm1;
l2[i] = l2[i - 1];
s01[i - 1] = "";
l2[i - 1] = "";
} else
sm1 = sn1;
variabl1563 = d1 + "";
}
for (int i = s01.length - 1; i >= 0; i--) {
if (s01[i].length() > 0) {
variabl15673.push(s01[i]);
variabl15674.push(l2[i]);
}
}
if (variabl15673.size() > 1) {
d1 = 0.0;
sm1 = "";
n = variabl15673.size();
for (int i = 0; i < n; i++) {
sn1 = variabl15673.pop().toString();
sn2 = variabl15674.pop().toString();
if (sn2.equals("+")) {
d1 = Double.parseDouble(sm1) + Double.parseDouble(sn1);
sm1 = d1 + "";
s01[i] = sm1;
s01[i - 1] = "";
l2[i] = l2[i - 1];
l2[i - 1] = "";
} else if (sn2.equals("-")) {
d1 = Double.parseDouble(sm1) - Double.parseDouble(sn1);
sm1 = d1 + "";
s01[i] = sm1;
s01[i - 1] = "";
l2[i] = l2[i - 1];
l2[i - 1] = "";
} else {
sm1 = sn1;
}
}
variabl1563 = d1 + "";
}
return variabl1563;
}
protected String variabl1567(String variabl15631, String variabl15633) {
String[] s1 = variabl15631.split("￥");
String variabl15634 = "", variabl15635 = "", variabl15636 = "", variabl15637 = "", x1;
int n1 = 0, n2 = 0, n3 = 0;
double db = 0.0;
for (int i = 0; i < s1.length; i++) {
n3 = n1 + s1[i].length();
n1 = variabl15633.indexOf("(", n2 + s1[i].length());
if (n1 < 0)
break;
n2 = variabl15633.indexOf(")", n1);
variabl15634 = variabl15633.substring(n1 + 1, n2);
variabl15635 = variabl15633.substring(n3, n1);
variabl15637 = variabl15633.substring(n3, n2 + 1);
if (variabl15634.indexOf("(") > 0)
variabl15634 = be.variabl15652(variabl15634);
else {
x1 = variabl15634;
x1 = x1.replaceAll("[-/%]", "");
x1 = x1.replaceAll("[\\+]", "");
x1 = x1.replaceAll("[\\*]", "");
if (x1.length() != variabl15634.length())
variabl15634 = variabl1563(variabl15634);
}
try {
db = Double.valueOf(variabl15634).doubleValue();
if (variabl15635.equals("log")) {
variabl15636 = Math.log(db) + "";
} else if (variabl15635.equals("square")) {
variabl15636 = Math.pow(db, 2) + "";
} else if (variabl15635.equals("sqrt")) {
variabl15636 = Math.sqrt(db) + "";
} else if (variabl15635.equals("sin")) {
variabl15636 = Math.sin(db) + "";
} else if (variabl15635.equals("asin")) {
variabl15636 = Math.asin(db) + "";
} else if (variabl15635.equals("cos")) {
variabl15636 = Math.cos(db) + "";
} else if (variabl15635.equals("tan")) {
variabl15636 = Math.tan(db) + "";
} else if (variabl15635.equals("atan")) {
variabl15636 = Math.atan(db) + "";
} else if (variabl15635.equals("ceil")) {
variabl15636 = Math.ceil(db) + "";
} else if (variabl15635.equals("exp")) {
variabl15636 = Math.exp(db) + "";
}
} catch (Exception e) {
}
int l1 = variabl15633.indexOf(variabl15637);
int l2 = variabl15637.length();
variabl15633 = variabl15633.substring(0, l1)
+ (variabl15636 + " ").substring(0, l2)
+ variabl15633.substring(l1 + l2, variabl15633.length());
variabl15633 = variabl15633.replaceAll(" ", "");
n2--;
}
variabl1563 = variabl15633;
return variabl15633;
}
}
61.源码61，部件程序，高度综合纵向计算程序，可对全表按某些字段分组后对每组及全部数据进行统计计算，可以进行ABC分析。
/**
* 程序文件名：dataStatistic4.java
* 作者：程学先
* 完成时间：2013年12月3日
* 部件功能：对全表按某些字段分组后对每组及全部数据的若干字段进行纵向计算，
* 是数据处理1、2综合成程序，可以进行ABC分析。
* 求和或求平均或求最大或最小或记录条数或标准偏差或填充标准偏差 或统计方差或填充统计方差等，
* 被调用语句：dataStatistic4.means(parameter);
* 必须提供的参数：数据库“表名”、要求统计的字段“统计字段名”
* 可选参数：“分组字段名”、“字段号表”、“按钮号表”、“分类比例”。
* 本程序包括：求和、求平均、求最大、求最小、求记录条数、求平均偏差,variabl1521,
* variabl1095,求填充统计标准偏差,variabl1483,求填充统计方差 、退出等12个按钮。
* 其中打印要求要求先利用程序printFormat1.java生成格式文件
* 操作方法与注意事项：
* 在“字段号表2”处可以输入多个字段名，为准备求和等统计的字段名。
* 在“字段号表3”处可以输入多个字段名，为分组要求的字段名。
* 可以联系代码表、字典表进行查询。
* 如果涉及代码表，在生成菜单程序时，在填表名时，应当先在列表框中选主表，再依次选代码表。
* 如果涉及字典表，将根据字典表给定的对应关系变换标签。
* 要求在当前数据库中有一个表的名字为某某某字典表，
* 即表名最后3个字是“字典表”，本程序将根据该表变换。
* 要求该表中只有二个字段，第一个字段（命名为字段名）中内容为所查询的数据表中字段名，
* 第二个字段（命名为标签名）内容为变换后的标签名。
* 所有统计字段名称要按变换前字段名提供。
* 如果进行ABC分析，要求输入“分类比例”，可以是3个数，也可以是更多的数，之间用逗号分隔。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import java.util.ArrayList;
public class dataStatistic4 extends JFrame {
static dataStatistic4 frame = new dataStatistic4();
static dataStatistic4 frame1 = new dataStatistic4();
static JPanel panel1 = new JPanel(false);
static String variabl2603;
static String variabl1873;
static String variabl2429;
static DefaultTableModel tableModel;
static ArrayList variabl1895 = new ArrayList();
static JTable table;
static JScrollPane scrollPane = new JScrollPane();
static String s1 = "";
static ResultSet rs;
static int b = 0, c = 0;
static int variabl2651;
static String[][] variabl2517;
static String[] variabl1501;
static int[] variabl1489;
static int variabl1853, variabl18531, 分组个数, 分组个数1;
static String[][] variabl26154;
static String[][] variabl2197;
static String[][] variabl21971;
static String variabl2093;
static String variabl1677;
static int[] variabl1495;
static String variabl1735;
static String variabl1987;
static int[] variabl1407;
static String variabl2049;
static String variabl1325;
static String variabl1779, 分类比例;
static int variabl2337 = 80;
static Connection con;
static ResultSetMetaData rsmd3;
static Statement sta3;
static int variabl2483 = main1.variabl2483 + 300,
variabl2503 = main1.variabl2503;
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
frame = new dataStatistic4();
frame1 = new dataStatistic4();
panel1 = new JPanel(false);
variabl1895 = new ArrayList();
scrollPane = new JScrollPane();
s1 = "";
b = 0;
c = 0;
variabl2337 = 80;
variabl2483 = 1400;
variabl2503 = main1.variabl2503;
String[] variabl240501 = { "求和", "求平均", "求最大", "求最小", "求记录条数", "求平均偏差",
"求相对偏差", "标准偏差", "填充标准偏差", "统计方差", "填充统计方差", "求ABC分类", "退出",
"打印预览", "打印", "导出" };
variabl2405 = new String[variabl240501.length];
variabl2851 = 0;
for (int i0 = 0; i0 < variabl240501.length; i0++)
variabl2405[i0] = variabl240501[i0];
if (parameter[11].length() > 0) {
variabl1187 = parameter[11];
variabl1187 = variabl1187.replaceAll("；", ";");
variabl1187 = variabl1187.replaceAll("。", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
variabl1187 = variabl1187.replaceAll("：", ";");
if (variabl1187.indexOf(";") > 0) {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
variabl2405[Integer.parseInt((s602[0]))] = s602[1];
variabl1187 = variabl1187 + "," + s602[0];
variabl2851++;
} else {
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
variabl1187 = s601[i01];
else
variabl1187 = variabl1187 + "," + s601[i01];
variabl2851++;
}
}
} else {
variabl1187 = "";
for (int i1 = 0; i1 < variabl2405.length; i1++) {
if (i1 == 0)
variabl1187 = variabl1187 + i1;
else
variabl1187 = variabl1187 + "," + i1;
variabl2851++;
}
}
variabl1187 = "," + variabl1187 + ",";
variabl2483 = main1.variabl2483;
variabl2503 = main1.variabl2503;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
variabl2483 = m1;
variabl2503 = m2;
}
} catch (Exception e2) {
}
分组个数1 = 0;
variabl2603 = parameter[4];
variabl2049 = parameter[20];
variabl1325 = parameter[19];
variabl1677 = parameter[10];
if (variabl1325.lastIndexOf(",") == variabl1325.length() - 1)
variabl1325 = variabl1325.substring(0, variabl1325.length() - 1);
variabl2429 = parameter[0];
variabl1735 = parameter[8];
variabl2093 = parameter[9];
variabl1779 = "," + parameter[11] + ",";
分类比例 = parameter[14];
variabl1873 = "";
String[] t1;
String s11 = variabl2603;
if (variabl2603.indexOf(",") > 0) {
String[] s12 = variabl2603.split(",");
s11 = s12[0];
}
if (variabl2429.lastIndexOf(s11 + "字典表") > 0) {
t1 = variabl2429.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(s11 + "字典表") >= 0)
variabl1873 = t1[i];
}
String[] l1;
String[] l3 = variabl1325.split(",");
if (variabl1735.length() > 0) {
l1 = variabl1735.split(",");
int[] l2 = new int[l1.length];
for (int i = 0; i < l1.length; i++) {
l2[i] = Integer.valueOf(l1[i]);
}
variabl2651 = l1.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[l2[i]];
variabl2517[1][i] = variabl2517[0][i];
}
} else {
variabl2651 = l3.length;
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = l3[i];
variabl2517[1][i] = variabl2517[0][i];
}
}
s1 = "";
for (int i = 0; i < variabl2651; i++)
s1 = s1 + variabl2517[0][i] + ",";
s1 = s1.substring(0, s1.length() - 1);
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s = "";
if (variabl2603.lastIndexOf(",") > 0)
s = "select " + s1 + " from " + variabl2603 + " where "
+ variabl2049;
else
s = "select " + s1 + " from " + variabl2603;
ResultSet rs = sta3.executeQuery(s);
rsmd3 = rs.getMetaData();
variabl2651 = rsmd3.getColumnCount();
variabl2517 = new String[2][variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = rsmd3.getColumnName(i + 1);
variabl2517[1][i] = variabl2517[0][i];
variabl1501[i] = rsmd3.getColumnTypeName(i + 1);
variabl1489[i] = rsmd3.getColumnDisplaySize(i + 1);
}
variabl1853 = 0;
rs.last();
variabl1853 = rs.getRow();
variabl2197 = new String[variabl1853][variabl2651];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "查询数据出错！");
}
s1 = "";
if (variabl1873.length() > 0) {
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl1873;
rs = sta3.executeQuery(s1);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount();
String s14 = "";
String s15 = "";
int b = 1;
while (rs.absolute(b)) {
b++;
s14 = rs.getString(1).trim();
s15 = rs.getString(2).trim();
for (int j = 0; j < variabl2651; j++) {
if (variabl2517[0][j].trim().equalsIgnoreCase(
s14.trim())) {
variabl2517[1][j] = s15;
break;
} else if ((variabl2517[0][j].trim() + ",").indexOf("."
+ s14 + ",") > 0) {
variabl2517[1][j] = variabl2517[1][j].replace(s14,
s15);
break;
}
}
}
rs.close();
con.close();
sta3.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错！" + s1);
}
}
String[] s71 = variabl1325.split(",");
String s4[];
s4 = variabl2093.split(",");
for (int i = 0; i < s4.length; i++)
s4[i] = s71[Integer.parseInt(s4[i])];
variabl1407 = new int[s4.length];
for (int i = 0; i < s4.length; i++) {
for (int j = 0; j < variabl2651; j++) {
if (s4[i].trim().equalsIgnoreCase(variabl2517[0][j].trim()))
variabl1407[i] = j;
}
for (int j = 0; j < variabl1853; j++)
if ((variabl2197[j][variabl1407[i]] == null)
|| (variabl2197[j][variabl1407[i]].length() < 1))
variabl2197[j][variabl1407[i]] = "0";
}
String s5[];
s5 = variabl1677.split(",");
variabl1495 = new int[s5.length];
for (int i = 0; i < s5.length; i++)
for (int j = 0; j < variabl2651; j++) {
if (s5[i].trim().equalsIgnoreCase(variabl2517[0][j].trim()))
variabl1495[i] = j;
}
variabl26154 = new String[variabl1853][6];
for (int i = 0; i < variabl1853; i++)
for (int j = 0; j < 6; j++)
variabl26154[i][j] = "";
分组个数1 = 0;
String s6 = "", s7 = "";
String[] variabl2615 = new String[variabl2651];
for (int i0 = 0; i0 < variabl1853 - 1; i0++) {
for (int i = 0; i < variabl1853 - 1 - i0; i++) {
s6 = "";
s7 = "";
for (int j = 0; j < s5.length; j++)
s6 = s6 + variabl2197[i][variabl1495[j]].trim();
for (int j = 0; j < s5.length; j++)
s7 = s7 + variabl2197[i + 1][variabl1495[j]].trim();
if (s6.compareTo(s7) > 0)
for (int k = 0; k < variabl2651; k++) {
variabl2615[k] = variabl2197[i][k];
variabl2197[i][k] = variabl2197[i + 1][k];
variabl2197[i + 1][k] = variabl2615[k];
}
}
}
frame.setTitle("查询统计部件程序 作者：程学先");
frame.setBounds(10, 10, variabl2483 - 10, variabl2503 - 10);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.getContentPane().setLayout(null);
frame1.setTitle(" ABC分类表");
frame1.setBounds(100, 10, variabl2483 - 10, variabl2503 - 10);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame1.getContentPane().setLayout(null);
final JPanel panel = new JPanel(false);
panel1 = new JPanel(false);
panel.setLayout(null);
panel.setBounds(20, 20, variabl2483 - 50, variabl2503 - 20);
panel1.setLayout(null);
panel1.setBounds(20, 20, variabl2483 - 50, variabl2503 - 20);
String[][] variabl26151 = new String[0][variabl2651];
tableModel = new DefaultTableModel(variabl26151, variabl2517[1]);
table = new JTable(tableModel);
table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = table.getColumn(variabl2517[1][i]);
int g10 = variabl2517[1][i].length();
if (variabl1489[i] > g10)
g10 = variabl1489[i];
tc.setPreferredWidth(g10 * 20);
tc.setMaxWidth(g10 * 20);
tc.sizeWidthToFit();
}
scrollPane.getViewport().add(table, null);
scrollPane.setBounds(30, 30, variabl2483 - 100, variabl2503 - 200);
panel.add(scrollPane);
variabl2339 = (variabl2483 - 60) / variabl2851;
if (variabl2339 < 100)
variabl2339 = 100;
int variabl1423 = 30;
int h0 = variabl2503 - 150, h1 = 1, h2;
variabl1779 = variabl1187;
JButton variabl2689 = new JButton(variabl2405[0]);
variabl2689.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "求和";
variabl2645();
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",0,") >= 0)) {
variabl2689.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl2689);
variabl1423 = variabl1423 + variabl2339;
if (variabl2483 < variabl2339 + variabl1423) {
variabl1423 = 5;
h0 = h0 + 30;
variabl2339 = (variabl2339 * h1) / (variabl2851 - h1);
}
h1++;
}
JButton variabl2295 = new JButton(variabl2405[1]);
variabl2295.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "求平均";
variabl2645();
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",1,") >= 0)) {
variabl2295.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl2295);
variabl1423 = variabl1423 + variabl2339;
if (variabl2483 < variabl2339 + variabl1423) {
variabl1423 = 5;
h0 = h0 + 30;
variabl2339 = (variabl2339 * h1) / (variabl2851 - h1);
}
h1++;
}
JButton variabl2335 = new JButton(variabl2405[2]);
variabl2335.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "求最大";
variabl2645();
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",2,") >= 0)) {
variabl2335.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl2335);
variabl1423 = variabl1423 + variabl2339;
if (variabl2483 < variabl2339 + variabl1423) {
variabl1423 = 5;
h0 = h0 + 30;
variabl2339 = (variabl2339 * h1) / (variabl2851 - h1);
}
h1++;
}
JButton variabl2493 = new JButton(variabl2405[3]);
variabl2493.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "求最小";
variabl2645();
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",3,") >= 0)) {
variabl2493.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl2493);
variabl1423 = variabl1423 + variabl2339;
if (variabl2483 < variabl2339 + variabl1423) {
variabl1423 = 5;
h0 = h0 + 30;
variabl2339 = (variabl2339 * h1) / (variabl2851 - h1);
}
h1++;
}
JButton variabl1279 = new JButton(variabl2405[4]);
variabl1279.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "求记录条数";
variabl2645();
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",4,") >= 0)) {
variabl1279.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl1279);
variabl1423 = variabl1423 + variabl2339;
if (variabl2483 < variabl2339 + variabl1423) {
variabl1423 = 5;
h0 = h0 + 30;
variabl2339 = (variabl2339 * h1) / (variabl2851 - h1);
}
h1++;
}
JButton variabl1295 = new JButton(variabl2405[5]);
variabl1295.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "求平均偏差";
variabl2645();
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",5,") >= 0)) {
variabl1295.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl1295);
variabl1423 = variabl1423 + variabl2339;
if (variabl2483 < variabl2339 + variabl1423) {
variabl1423 = 5;
h0 = h0 + 30;
variabl2339 = (variabl2339 * h1) / (variabl2851 - h1);
}
h1++;
}
JButton variabl1521 = new JButton(variabl2405[6]);
variabl1521.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "求相对偏差";
variabl2645();
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",6,") >= 0)) {
variabl1521.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl1521);
variabl1423 = variabl1423 + variabl2339;
if (variabl2483 < variabl2339 + variabl1423) {
variabl1423 = 5;
h0 = h0 + 30;
variabl2339 = (variabl2339 * h1) / (variabl2851 - h1);
}
h1++;
}
JButton variabl1095 = new JButton(variabl2405[7]);
variabl1095.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "求统计标准偏差";
variabl2645();
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",7,") >= 0)) {
variabl1095.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl1095);
variabl1423 = variabl1423 + variabl2339;
if (variabl2483 < variabl2339 + variabl1423) {
variabl1423 = 5;
h0 = h0 + 30;
variabl2339 = (variabl2339 * h1) / (variabl2851 - h1);
}
}
JButton variabl1041 = new JButton(variabl2405[8]);
variabl1041.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "填充统计标准偏差";
variabl2645();
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",8,") >= 0)) {
variabl1041.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl1041);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1979 = new JButton(variabl2405[9]);
variabl1979.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "填充统计方差";
variabl2645();
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",9,") >= 0)) {
variabl1979.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl1979);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl1483 = new JButton(variabl2405[10]);
variabl1483.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "求统计方差";
variabl2645();
}
});
if ((variabl1779.length() < 3)
|| (variabl1779.lastIndexOf(",10,") >= 0)) {
variabl1483.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl1483);
variabl1423 = variabl1423 + variabl2339;
}
JButton ABC分类 = new JButton(variabl2405[11]);
ABC分类.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1987 = "求ABC分类";
variabl2645();
}
});
if ((variabl1779.length() < 3)
|| (variabl1779.lastIndexOf(",11,") >= 0)) {
ABC分类.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(ABC分类);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl2599 = new JButton(variabl2405[12]);
variabl2599.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame1.setVisible(false);
frame1.dispose();
frame.setVisible(false);
frame.dispose();
}
});
if ((variabl1779.length() < 3)
|| (variabl1779.lastIndexOf(",12,") >= 0)) {
variabl2599.setBounds(variabl1423, h0, variabl2339, 20);
panel.add(variabl2599);
variabl1423 = variabl1423 + variabl2339;
}
final String[] g6 = { "分组数据", "小计值", "记录条数", "分类名称", "小计占比", "记录数占比" };
final int[] g7 = { 100, 100, 50, 50, 100, 100 };
final String[] g8 = { "char", "Double", "int", "char", "Double",
"Double" };
variabl1423 = 50;
JButton variabl20911 = new JButton(variabl2405[13]);
variabl20911.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPreview0.printView1(g6, variabl26154, g7, "ABC分类表");
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",1,") >= 0)) {
variabl20911.setBounds(variabl1423, variabl2503 - 150, variabl2339,
20);
panel1.add(variabl20911);
variabl1423 = variabl1423 + variabl2339;
}
JButton variabl26171 = new JButton(variabl2405[14]);
variabl26171.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPrint0.printView1(g6, variabl26154, g7, "ABC分类表");
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",2,") >= 0)) {
variabl26171.setBounds(variabl1423, variabl2503 - 150, variabl2339,
20);
panel1.add(variabl26171);
variabl1423 = variabl1423 + variabl2339;
}
final int[] g9 = { 20, 20, 6, 6, 20, 20 };
JButton variabl26391 = new JButton(variabl2405[15]);
variabl26391.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataTransfer0.Trans(g6, g8, g9, "", variabl26154, "ABC分类表");
}
});
if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",3,") >= 0)) {
variabl26391.setBounds(variabl1423, variabl2503 - 150, variabl2339,
20);
panel1.add(variabl26391);
variabl1423 = variabl1423 + variabl2339;
}
frame.getContentPane().add(panel, null);
frame.setVisible(true);
frame.getContentPane().add(panel, BorderLayout.SOUTH);
}
public static void variabl2645() {
for (int i = tableModel.getRowCount() - 1; i >= 0; i--)
tableModel.removeRow(i);
String[] variabl2615 = new String[variabl2651];
String[] variabl26152 = new String[variabl2651];
String[] variabl26153 = new String[variabl2651];
double[] x0 = new double[variabl2651];
double[] x1 = new double[variabl2651];
double[] x2 = new double[variabl2651];
double[] x3 = new double[variabl2651];
double[] x4 = new double[variabl2651];
double[][] y0;
double[] y1 = new double[variabl2651];
double[] y2 = new double[variabl2651];
double[] y3 = new double[variabl2651];
double[] y4 = new double[variabl2651];
String s6 = "", s7 = "";
int variabl1523 = 0;
double[] x = new double[variabl2651];
double[] y = new double[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl26152[i] = "";
variabl26153[i] = "";
}
Double 总合计 = 0.0;
int 总记录数 = 0;
s6 = "";
for (int n0 = 0; n0 < variabl1495.length; n0++) {
s6 = s6 + variabl2197[0][variabl1495[n0]].trim();
}
for (int k = 0; k < variabl1407.length; k++) {
x1[variabl1407[k]] = Double
.parseDouble(variabl2197[0][variabl1407[k]]);
y1[variabl1407[k]] = Double
.parseDouble(variabl2197[variabl1523][variabl1407[k]]);
x2[variabl1407[k]] = 0;
y2[variabl1407[k]] = 0;
x3[variabl1407[k]] = 0;
y3[variabl1407[k]] = 0;
x4[variabl1407[k]] = 0;
y4[variabl1407[k]] = 0;
}
for (int n0 = 0; n0 < variabl2651; n0++) {
variabl2615[n0] = "";
}
for (int n = 0; n < variabl1853; n++) {
if (("求最大,variabl2493,求记录数,variabl2689,variabl2295,求ABC分类")
.lastIndexOf(variabl1987) >= 0)
tableModel.addRow(variabl2197[n]);
for (int k = 0; k < variabl1407.length; k++) {
x[variabl1407[k]] = Double
.parseDouble(variabl2197[n][variabl1407[k]]);
if (x[variabl1407[k]] < x1[variabl1407[k]])
x1[variabl1407[k]] = x[variabl1407[k]];
if (x[variabl1407[k]] > x2[variabl1407[k]])
x2[variabl1407[k]] = x[variabl1407[k]];
x3[variabl1407[k]] = x3[variabl1407[k]] + x[variabl1407[k]];
x4[variabl1407[k]]++;
if (x[variabl1407[k]] < y1[variabl1407[k]])
y1[variabl1407[k]] = x[variabl1407[k]];
if (x[variabl1407[k]] > y2[variabl1407[k]])
y2[variabl1407[k]] = x[variabl1407[k]];
y3[variabl1407[k]] = y3[variabl1407[k]] + x[variabl1407[k]];
y4[variabl1407[k]]++;
}
s7 = "";
String s8 = "";
if (n < variabl1853 - 1) {
for (int n1 = 0; n1 < variabl1495.length; n1++) {
s7 = s7 + variabl2197[n + 1][variabl1495[n1]].trim();
if (s8.length() == 0)
s8 = s8 + variabl2197[n][variabl1495[n1]].trim();
else
s8 = s8 + "," + variabl2197[n][variabl1495[n1]].trim();
}
if (!s6.trim().equalsIgnoreCase(s7.trim())) {
s6 = s7;
for (int k = 0; k < variabl1407.length; k++) {
if (variabl1987.trim().equalsIgnoreCase("求最小"))
variabl2615[variabl1407[k]] = ""
+ y1[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求最大"))
variabl2615[variabl1407[k]] = ""
+ y2[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求和"))
variabl2615[variabl1407[k]] = ""
+ y3[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求ABC分类")) {
variabl2615[variabl1407[k]] = ""
+ y3[variabl1407[k]];
} else if (variabl1987.trim().equalsIgnoreCase("求记录数"))
variabl2615[variabl1407[k]] = ""
+ (int) y4[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求平均")) {
variabl2615[variabl1407[k]] = ""
+ y3[variabl1407[k]] / y4[variabl1407[k]];
}
if (k == 0) {
variabl26154[分组个数1][1] = y3[variabl1407[k]] + "";
variabl26154[分组个数1][2] = (int) y4[variabl1407[k]]
+ "";
variabl26154[分组个数1][0] = s8;
分组个数1++;
}
variabl1895
.add(y3[variabl1407[k]] / y4[variabl1407[k]]);
}
if (("求最大,variabl2493,求记录数,variabl2689,求平均")
.lastIndexOf(variabl1987) >= 0)
variabl2615[variabl1495[variabl1495.length - 1]] = variabl2197[n][variabl1495[variabl1495.length - 1]]
.trim()
+ variabl1987
.substring(1, variabl1987.length());
else if (("求ABC分类").lastIndexOf(variabl1987) >= 0)
variabl2615[variabl1495[variabl1495.length - 1]] = variabl2197[n][variabl1495[variabl1495.length - 1]]
.trim() + "分类";
if (("求最大,variabl2493,求记录数,variabl2689,variabl2295,求ABC分类")
.lastIndexOf(variabl1987) >= 0)
tableModel.addRow(variabl2615);
variabl1523 = n + 1;
for (int k = 0; k < variabl1407.length; k++) {
y1[variabl1407[k]] = Double
.parseDouble(variabl2197[variabl1523][variabl1407[k]]);
y2[variabl1407[k]] = 0;
y3[variabl1407[k]] = 0;
y4[variabl1407[k]] = 0;
}
for (int n0 = 0; n0 < variabl2651; n0++) {
variabl2615[n0] = "";
}
}
}
}
for (int k = 0; k < variabl1407.length; k++) {
if (variabl1987.trim().equalsIgnoreCase("求最小"))
variabl2615[variabl1407[k]] = "" + y1[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求最大"))
variabl2615[variabl1407[k]] = "" + y2[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求和"))
variabl2615[variabl1407[k]] = "" + y3[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求ABC分类"))
variabl2615[variabl1407[k]] = "" + y3[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求记录数"))
variabl2615[variabl1407[k]] = "" + (int) y4[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求平均")) {
variabl2615[variabl1407[k]] = "" + y3[variabl1407[k]]
/ y4[variabl1407[k]];
}
String s9 = "";
for (int n1 = 0; n1 < variabl1495.length; n1++) {
if (s9.length() == 0)
s9 = s9
+ variabl2197[variabl1853 - 1][variabl1495[n1]]
.trim();
else
s9 = s9
+ ","
+ variabl2197[variabl1853 - 1][variabl1495[n1]]
.trim();
}
if (k == 0) {
variabl26154[分组个数1][1] = y3[variabl1407[k]] + "";
variabl26154[分组个数1][2] = (int) y4[variabl1407[k]] + "";
variabl26154[分组个数1][0] = s9;
}
}
variabl2615[variabl1495[variabl1495.length - 1]] = variabl2197[variabl1853 - 1][variabl1495[variabl1495.length - 1]]
.trim() + variabl1987.substring(1, variabl1987.length());
if (("求最大,variabl2493,求记录数,variabl2689,variabl2295,求ABC分类")
.lastIndexOf(variabl1987) >= 0) {
tableModel.addRow(variabl2615);
for (int k = 0; k < variabl1407.length; k++) {
if (variabl1987.trim().equalsIgnoreCase("求最小"))
variabl2615[variabl1407[k]] = "" + x1[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求最大"))
variabl2615[variabl1407[k]] = "" + x2[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求和"))
variabl2615[variabl1407[k]] = "" + x3[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求ABC分类"))
variabl2615[variabl1407[k]] = "" + x3[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求记录数"))
variabl2615[variabl1407[k]] = "" + (int) x4[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求平均")) {
variabl2615[variabl1407[k]] = "" + x0[variabl1407[k]];
y4[variabl1407[k]]++;
x4[variabl1407[k]]++;
}
if (variabl1987.trim().equalsIgnoreCase("求平均")) {
x0[variabl1407[k]] = x3[variabl1407[k]] / variabl1853;
variabl2615[variabl1407[k]] = "" + x0[variabl1407[k]];
}
if (k == 0)
总合计 = Double.valueOf(variabl2615[variabl1407[k]]);
}
}
if (("求最大,variabl2493,求记录数,variabl2689,求平均").lastIndexOf(variabl1987) >= 0) {
variabl2615[variabl1495[variabl1495.length - 1]] = "总"
+ variabl1987.substring(1, variabl1987.length());
tableModel.addRow(variabl2615);
} else if (("求ABC分类").lastIndexOf(variabl1987) >= 0) {
variabl2615[variabl1495[variabl1495.length - 1]] = "总分类";
tableModel.addRow(variabl2615);
}
y0 = new double[variabl1895.size() / variabl1407.length + 1][variabl1407.length];
int i1 = 0;
for (int i = 0; i < variabl1895.size() / variabl1407.length; i++)
for (int j = 0; j < variabl1407.length; j++) {
y0[i][j] = Double.parseDouble(""
+ variabl1895.get(i * variabl1407.length + j));
}
int variabl2543 = 0;
if (("求最大,variabl2493,求记录数,variabl2689,variabl2295,求ABC分类")
.lastIndexOf(variabl1987) < 0) {
for (int k1 = 0; k1 < variabl1407.length; k1++) {
x2[variabl1407[k1]] = 0;
x3[variabl1407[k1]] = 0;
y2[variabl1407[k1]] = 0;
y3[variabl1407[k1]] = 0;
x4[variabl1407[k1]] = 0;
y4[variabl1407[k1]] = 0;
}
s6 = "";
for (int n0 = 0; n0 < variabl1495.length; n0++) {
s6 = s6 + variabl2197[0][variabl1495[n0]].trim();
}
for (int n = 0; n < variabl1853; n++) {
tableModel.addRow(variabl2197[n]);
for (int k = 0; k < variabl1407.length; k++) {
x[variabl1407[k]] = Math.abs(Double
.parseDouble(variabl2197[n][variabl1407[k]])
- x0[variabl1407[k]]);
x2[variabl1407[k]] = x2[variabl1407[k]] + x[variabl1407[k]];
x3[variabl1407[k]] = x3[variabl1407[k]] + x[variabl1407[k]]
* x[variabl1407[k]];
y[variabl1407[k]] = Math.abs(Double
.parseDouble(variabl2197[n][variabl1407[k]])
- y0[variabl2543][k]);
y2[variabl1407[k]] = y2[variabl1407[k]] + y[variabl1407[k]];
y3[variabl1407[k]] = y3[variabl1407[k]] + y[variabl1407[k]]
* y[variabl1407[k]];
x4[variabl1407[k]]++;
y4[variabl1407[k]]++;
}
s7 = "";
if (n < variabl1853 - 1) {
for (int n1 = 0; n1 < variabl1495.length; n1++)
s7 = s7 + variabl2197[n + 1][variabl1495[n1]].trim();
if (!s6.equalsIgnoreCase(s7)) {
s6 = s7;
for (int k = 0; k < variabl1407.length; k++) {
if (variabl1987.trim().equalsIgnoreCase("求平均偏差"))
variabl2615[variabl1407[k]] = ""
+ y2[variabl1407[k]]
/ y4[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase(
"求相对偏差"))
variabl2615[variabl1407[k]] = ""
+ y2[variabl1407[k]]
/ y4[variabl1407[k]]
/ y0[variabl2543][k] * 100;
else if (variabl1987.trim().equalsIgnoreCase(
"求统计标准偏差stdev"))
variabl2615[variabl1407[k]] = ""
+ Math.sqrt(y3[variabl1407[k]]
/ (y4[variabl1407[k]] - 1));
else if (variabl1987.trim().equalsIgnoreCase(
"求填充统计标准偏差stdevp"))
variabl2615[variabl1407[k]] = ""
+ Math.sqrt(y3[variabl1407[k]]
/ y4[variabl1407[k]]);
else if (variabl1987.trim().equalsIgnoreCase(
"求统计方差var"))
variabl2615[variabl1407[k]] = ""
+ y3[variabl1407[k]]
/ (y4[variabl1407[k]] - 1);
else if (variabl1987.trim().equalsIgnoreCase(
"求填充统计方差varp"))
variabl2615[variabl1407[k]] = ""
+ y3[variabl1407[k]]
/ y4[variabl1407[k]];
}
variabl2615[variabl1495[variabl1495.length - 1]] = variabl2197[n][variabl1495[variabl1495.length - 1]]
.trim()
+ variabl1987
.substring(1, variabl1987.length());
tableModel.addRow(variabl2615);
variabl2543++;
for (int n3 = 0; n3 < variabl2651; n3++) {
variabl26153[n3] = "";
y2[n3] = 0;
y3[n3] = 0;
y4[n3] = 0;
}
}
}
}
for (int k = 0; k < variabl1407.length; k++) {
if (variabl1987.trim().equalsIgnoreCase("求平均偏差"))
variabl2615[variabl1407[k]] = "" + y2[variabl1407[k]]
/ y4[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求相对偏差"))
variabl2615[variabl1407[k]] = "" + y2[variabl1407[k]]
/ y4[variabl1407[k]] / y0[variabl2543][k] * 100;
else if (variabl1987.trim().equalsIgnoreCase("求统计标准偏差"))
variabl2615[variabl1407[k]] = ""
+ Math.sqrt(y3[variabl1407[k]]
/ (y4[variabl1407[k]] - 1));
else if (variabl1987.trim().equalsIgnoreCase("求填充统计标准偏差"))
variabl2615[variabl1407[k]] = ""
+ Math.sqrt(y3[variabl1407[k]] / y4[variabl1407[k]]);
else if (variabl1987.trim().equalsIgnoreCase("求统计方差"))
variabl2615[variabl1407[k]] = "" + y3[variabl1407[k]]
/ (y4[variabl1407[k]] - 1);
else if (variabl1987.trim().equalsIgnoreCase("求填充统计方差"))
variabl2615[variabl1407[k]] = "" + y3[variabl1407[k]]
/ y4[variabl1407[k]];
}
tableModel.addRow(variabl2615);
for (int k = 0; k < variabl1407.length; k++) {
if (variabl1987.trim().equalsIgnoreCase("求平均偏差"))
variabl2615[variabl1407[k]] = "" + x2[variabl1407[k]]
/ x4[variabl1407[k]];
else if (variabl1987.trim().equalsIgnoreCase("求相对偏差"))
variabl2615[variabl1407[k]] = "" + x2[variabl1407[k]]
/ x4[variabl1407[k]] / x0[variabl1407[k]] * 100;
else if (variabl1987.trim().equalsIgnoreCase("求统计标准偏差"))
variabl2615[variabl1407[k]] = ""
+ Math.sqrt(x3[variabl1407[k]]
/ (x4[variabl1407[k]] - 1));
else if (variabl1987.trim().equalsIgnoreCase("求填充统计标准偏差"))
variabl2615[variabl1407[k]] = ""
+ Math.sqrt(x3[variabl1407[k]] / x4[variabl1407[k]]);
else if (variabl1987.trim().equalsIgnoreCase("求统计方差"))
variabl2615[variabl1407[k]] = "" + x3[variabl1407[k]]
/ (x4[variabl1407[k]] - 1);
else if (variabl1987.trim().equalsIgnoreCase("求填充统计方差"))
variabl2615[variabl1407[k]] = "" + x3[variabl1407[k]]
/ x4[variabl1407[k]];
}
variabl2615[variabl1495[variabl1495.length - 1]] = "总"
+ variabl1987.substring(1, variabl1987.length());
tableModel.addRow(variabl2615);
}
variabl21971 = new String[tableModel.getRowCount()][variabl2651];
for (int i = 0; i < tableModel.getRowCount(); i++)
for (int j = 0; j < variabl2651; j++) {
if (tableModel.getValueAt(i, j) == null)
variabl21971[i][j] = "";
else
variabl21971[i][j] = tableModel.getValueAt(i, j).toString()
.trim();
}
if (("求ABC分类").lastIndexOf(variabl1987) >= 0) {
String g0 = "";
for (int i = 0; i <= 分组个数1; i++) {
for (int j = i; j <= 分组个数1; j++) {
if (Double.parseDouble(variabl26154[j][1]) > Double
.parseDouble(variabl26154[i][1])) {
for (int k = 0; k < 6; k++) {
g0 = variabl26154[i][k];
variabl26154[i][k] = variabl26154[j][k];
variabl26154[j][k] = g0;
}
}
}
}
Double g1 = 0.0;
String g2[];
if (分类比例.indexOf(",") > 0)
g2 = 分类比例.split(",");
else
g2 = 分类比例.split("，");
String[] g3 = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" };
int g4 = 0;
Double g5[] = new Double[g2.length];
总记录数 = 0;
for (int i = 0; i < g2.length; i++)
g5[i] = Double.parseDouble(g2[i]);
for (int i = 0; i <= 分组个数1; i++) {
g1 = g1 + Double.parseDouble(variabl26154[i][1]);
variabl26154[i][3] = g3[g4];
if (g1 > (总合计 * g5[g4] / 100)) {
g1 = 0.0;
g4++;
}
总记录数 = 总记录数 + Integer.parseInt(variabl26154[i][2]);
}
for (int i = 0; i <= 分组个数1; i++) {
variabl26154[i][4] = Double.parseDouble(variabl26154[i][1])
/ 总合计 * 100 + "";
variabl26154[i][4] = (variabl26154[i][4] + " ")
.substring(0, 6);
variabl26154[i][5] = Double.parseDouble(variabl26154[i][2])
* 100 / 总记录数 + "";
variabl26154[i][5] = (variabl26154[i][5] + " ")
.substring(0, 6);
}
String[] g6 = { "分组数据", "小计值", "记录条数", "分类名称", "小计占比", "记录数占比" };
DefaultTableModel tableModel1 = new DefaultTableModel(variabl26154,
g6);
JTable table1 = new JTable(tableModel1);
table1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
table1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table1.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < g6.length; i++) {
TableColumn tc1 = table1.getColumn(g6[i]);
tc1.setPreferredWidth(10 * 8);
tc1.setMaxWidth(10 * 8);
tc1.sizeWidthToFit();
}
JScrollPane scrollPane1 = new JScrollPane();
scrollPane1.getViewport().add(table1, null);
scrollPane1.setBounds(30, 30, variabl2483 - 100, variabl2503 - 200);
panel1.add(scrollPane1);
frame1.getContentPane().add(panel1, null);
frame1.setVisible(true);
}
}
}
https://blog.sciencenet.cn/blog-2551-1119203.html
上一篇：管理信息系统软件生产线源码56-58
下一篇：管理信息系统软件生产线源码62-66
