博文
管理信息系统软件生产线源码62-66
|||
版本1
62.源码62，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/**
* 程序文件名：dataStatistic5.java
* 作者：程学先
* 功能：删除重复记录，可针对指定的多个字段寻找重复记录，求字段中不得包含大数据类型。
* 完成日期：2013年1月22日
* 必须提供的参数：数据库“表名”。
* 可选择参数：“字段号表”（parameter[8]）、
* 为防误操作请做好备份。如果所选字段中包含大数据类型，操作将失败。
*/
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.util.HashSet;
import java.io.UnsupportedEncodingException;
public class dataStatistic5 extends JFrame {
static dataStatistic5 frame = new dataStatistic5(); // 创建窗体
private static JTable table;
static Connection con1; // 连接数据库
static ResultSetMetaData rsmd4;
static Statement sta4;
static int 窗口宽 = 800, 窗口高 = 630;
static int 列数, 列数2;
static String[][] 列名; // 数据表列名
static String[] 列数据类型, 列数据类型2, 一条记录1, 列名2; // 存放当前记录各字段数据类型的数组
static int[] 列数据宽度, 列小数位数; // 存放当前记录各字段数据宽度的数组
static int 记录条数 = 0;
static int 当前记录号;
static String[][] 表格数据, 表格数据2;
static DefaultTableModel model, 表格模型2;
static String 表名; // 数据表名
static String 字典表名;
static String 字段号表, 字段名字串, 字段名字串0;
static String s1 = "", s2 = "", s3 = "";
static String s4 = "", T1 = "";
static int c = 0, b = 0, 表格宽度 = 0;
static ResultSet rs;
static JPanel panel = new JPanel(false); // 定义面板
static JScrollPane scrollPane = new JScrollPane();
private static HashSet set1 = new HashSet();
static String[] 按钮集 = null;
static String 要求按钮号表;
static int 按钮数 = 0, 按钮宽 = 0;
public static void means(String[] parameter) {
frame = new dataStatistic5();
窗口宽 = 800;
窗口高 = 630;
记录条数 = 0;
s1 = "";
s2 = "";
s3 = "";
s4 = "";
T1 = "";
c = 0;
b = 0;
表格宽度 = 0;
panel = new JPanel(false); // 定义面板
scrollPane = new JScrollPane();
set1 = new HashSet();
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) {
}
表名 = parameter[4]; // 数据表名
字段号表 = parameter[8];
字段名字串 = parameter[19];
字段名字串0 = 字段名字串;
String[] t2 = parameter[19].split(","); // 字段名数组
String 字段名字串1 = "";
if (字段号表.length() > 0) {
String[] t3 = 字段号表.split(","); // 字段号数组
for (int i = 0; i < t3.length; i++) {
if (i > 0)
字段名字串1 = 字段名字串1 + "," + t2[Integer.parseInt(t3[i])];
else
字段名字串1 = t2[Integer.parseInt(t3[i])];
}
字段名字串 = 字段名字串1;
} else
字段名字串 = "*";
String 表名表 = parameter[0];
字典表名 = "";
String[] t1;
b = 0;
c = 0;
if (表名表.lastIndexOf(表名 + "字典表") >= 0) {
t1 = 表名表.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(表名 + "字典表") >= 0)
字典表名 = t1[i];
}
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + 字段名字串 + " from " + 表名;
rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
列数 = rsmd4.getColumnCount(); // 获取列数
列名 = new String[2][列数];
for (int i = 0; i < 列数; i++) {
列名[0][i] = rsmd4.getColumnName(i + 1);
列名[1][i] = 列名[0][i];
}
列数据类型 = new String[列数];
列数据宽度 = new int[列数]; // 定义列数据宽度
表格宽度 = 0;
for (int i = 0; i < 列数; i++) {
列数据类型[i] = rsmd4.getColumnTypeName(i + 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;
if (列数据宽度[i] < 5)
列数据宽度[i] = 5;
表格宽度 = 表格宽度 + 列数据宽度[i];
}
记录条数 = 0;
rs.last();
记录条数 = rs.getRow();
一条记录1 = new String[记录条数];
表格数据 = new String[记录条数][列数];
rs.absolute(1);
c = 0; // 行号
b = 0; // 列号
while (c < 记录条数) {
rs.absolute(c + 1);
一条记录1[c] = "";
while (b < 列数) {
表格数据[c][b] = rs.getString(b + 1);
if (b == 0)
一条记录1[c] = 表格数据[c][b];
else
一条记录1[c] = 一条记录1[c] + "," + 表格数据[c][b];
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "a读取数据出错！" + s1);
}
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 表名;
rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
列数2 = rsmd4.getColumnCount(); // 获取列数
列名2 = new String[列数2];
字段名字串0 = "";
列数据类型2 = new String[列数2];
for (int i = 0; i < 列数2; i++) {
列名2[i] = rsmd4.getColumnName(i + 1);
列数据类型2[i] = rsmd4.getColumnTypeName(i + 1);
if (",image,".indexOf("," + 列数据类型2[i] + ",") < 0)
if (字段名字串0.length() == 0)
字段名字串0 = 列名2[i];
else
字段名字串0 = 字段名字串0 + "," + 列名2[i];
}
表格数据2 = new String[记录条数][列数2];
rs.absolute(1);
c = 0; // 行号
b = 0; // 列号
while (c < 记录条数) {
rs.absolute(c + 1);
while (b < 列数2) {
表格数据2[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "a读取数据出错！" + s1);
}
表格模型2 = new DefaultTableModel(表格数据2, 列名2);
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 s4 = "";
String s5 = "";
b = 1;
while (rs.absolute(b)) {
b++;
s4 = rs.getString(1); // 字段名
s5 = rs.getString(2);
for (int j = 0; j < 列数; j++) {
if (列名[0][j].trim().equals(s4.trim())) {
列名[1][j] = s5;
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);
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);
按钮宽 = (窗口宽 - 200) / 按钮数;
int 左边距 = 150;
JButton 删除重复记录 = new JButton(按钮集[0]);
删除重复记录.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// 设计思想：前面根据全表将全部数据存到了表格模型2中
// 将显示的可能是表的部分字段的子表数据存入set（本设计根据选择的字段号删除重复值）
// 利用set去掉重复值的功能删除显示的表的重复值，同时
// 根据set元素个数的变化确定删除的行号，记录这些删除的行号
// 从表格模型中根据行号将保留的行的数据写回数据表
String mn = ","; // 删除的行号集
int k = 0;
try {
String 类型1 = main1.数字数据类型;
s1 = "delete from " + 表名; // 删除原来的表
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
int n = 0;
String sk = "";
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
s2 = "";
for (int j = 0; j < 列数; j++)
if (model.getValueAt(i1, j) != null)
s2 = s2 + model.getValueAt(i1, j).toString();
set1.add(s2); // 删除重复值
if (set1.size() != n) { // 如果n增加表示新加入了一行
n = set1.size();
s1 = "insert into " + 表名 + "(" + 字段名字串0
+ ") values (";
sk = "";
for (int j = 0; j < 列数2; j++) {
if (类型1.lastIndexOf("," + 列数据类型2[j] + ",") >= 0) // 数字类型
if (表格模型2.getValueAt(i1, j) != null)
if (sk.length() > 0)
sk = sk + ","
+ 表格模型2.getValueAt(i1, j);
else
sk = sk + ","
+ 表格模型2.getValueAt(i1, j);
else // 根据表格1确定行号，在确定表格模型2那些行恢复到表中去
if (sk.length() > 0)
sk = sk + ",0";
else
sk = sk + "0";
else if ((main1.文本数据类型+main1.图形数据类型).indexOf("," + 列数据类型2[j]
+ ",") < 0) // 非数类型字
if (表格模型2.getValueAt(i1, j) != null)
if (sk.length() > 0)
sk = sk + ",'"
+ 表格模型2.getValueAt(i1, j)
+ "'";
else
sk = sk + "'"
+ 表格模型2.getValueAt(i1, j)
+ "'";
else if (sk.length() > 0)
sk = sk + ",' '";
else
sk = sk + "' '";
}
sk = sk + ")";
s1 = s1 + sk;
sta4.executeUpdate(s1);
} else {
当前记录号 = i1;
model.removeRow(i1);
}
}
sta4.close(); // 关闭连接
con1.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "操作出错，请录入语句是否正确！" + s1);
}
}
});
删除重复记录.setBounds(左边距, 窗口高 - 90, 按钮宽, 20);
if (要求按钮号表.indexOf(",0,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel.add(删除重复记录);
}
JButton 退出 = new JButton(按钮集[1]);
退出.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
退出.setBounds(左边距, 窗口高 - 90, 按钮宽, 20);
if (要求按钮号表.indexOf(",1,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel.add(退出);
}
frame.getContentPane().add(panel, null);
frame.setVisible(true);
frame.getContentPane().add(panel, BorderLayout.SOUTH);
}
}
63.源码63，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/*
* 程序文件名：dataStatistic6.java
* 作者：程学先
* 功能：求当前表中的在另一个表中没有的记录（求二个关系的差集），可以进一步删除与第二表相同的记录。
* 必须提供的参数：表1名称，表2名称。
* 在第一页表现源表数据，关系运算结果在第二页显示。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Vector;
public class dataStatistic6 extends JFrame {
private static ItemListener ItemListener = null;
private static dataStatistic6 frame1 = new dataStatistic6(); //定义窗口
private static dataStatistic6 frame3 = new dataStatistic6();
private static JPanel panel1 = new JPanel(); //定义面板
private static JPanel panel3 = new JPanel();
private static DefaultTableModel 表格模型1; // 定义表格模型对象
private static DefaultTableModel 表格模型2;
private static DefaultTableModel 表格模型3;
private static JTable 表格1;
private static JTable 表格2;
private static JTable 表格3;
private static JScrollPane scrollPane1 = new JScrollPane();
private static JScrollPane scrollPane2 = new JScrollPane();
private static JScrollPane scrollPane3 = new JScrollPane();
private static String[][] 表格数据1;
private static String[][] 表格数据2;
private static String[][] 表格数据3;
private static String 表名1;
private static String 表名2;
private static String 结果表名;
private static String 表名表,要求字段号表,要求字段号表0;
private static String[] 列名1;
private static String[] 列名2;
private static String[] 列名3;
private static int 列数1,宽度系数=8;
private static int 列数2,列数3;
private static int c=0,b=0;
private static int 选中行号1;
private static int 选中行号2;
private static int 记录条数1=0,记录条数2=0,记录条数3=0;
private static int 当前列号1=0;
private static int 当前列号2=0;
private static String[] 列数据类型1;
private static String[] 列数据类型2;
private static String[] 列数据类型3;
private static int[] 列数据宽度1;
private static int[] 列数据宽度2;
private static int[] 列数据宽度3;
private static int 表1宽度=0;
private static int 表2宽度=0;
private static int 表3宽度=0;
private static String[] 一条记录1;
private static String[] 一条记录2;
private static String[] 一条记录3;
private static ArrayList list1=new ArrayList();
private static Choice fa0=new Choice();
private static HashSet set1=new HashSet();
private static HashSet set2=new HashSet();
static Connection con;
private static Statement sta3;
static Connection con2;
private static Statement sta5;
private static ResultSet rs;
static String s1="",s2="",s3="",s4="",当前值="";
private static ResultSetMetaData rsmd;
static String [] 按钮集=null;
static String 要求按钮号表;
static int 窗口宽=0,窗口高=0,按钮数=0,按钮宽=0;
public static void means(String[] parameter) {
frame1 = new dataStatistic6(); //定义窗口
frame3 = new dataStatistic6();
panel1 = new JPanel(); //定义面板
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
c=0;b=0;
记录条数1=0;记录条数2=0;记录条数3=0;
当前列号1=0;当前列号2=0;
list1=new ArrayList();
fa0=new Choice();
set1=new HashSet();
set2=new HashSet();
s1="";s2="";s3="";s4="";当前值="";
表1宽度=0;表2宽度=0;表3宽度=0;
String [] 按钮集01={"表1减表2","退出"};
按钮集=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){}
宽度系数=15;
ItemListener = null;frame1 = new dataStatistic6();frame3 = new dataStatistic6();
panel1 = new JPanel();panel3 = new JPanel();scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();scrollPane3 = new JScrollPane();
记录条数1=0;记录条数2=0;记录条数3=0;
表1宽度=0;表2宽度=0;表3宽度=0;list1=new ArrayList();
fa0=new Choice();set1=new HashSet();set2=new HashSet();
s1="";s2="";s3="";s4="";当前值="";
表名1=parameter[4];
表名2=parameter[2];
结果表名=parameter[5];
表名表=parameter[0];
String 字段名字串=parameter[19];
String [] t2=parameter[19].split(","); //字段名数组
要求字段号表=parameter[8] ; // 需要显示的字段的顺序号
要求字段号表0=parameter[9] ; // 需要显示的子表字段的顺序号
String 字段名字串0="",字段名字串1="";
String [] t3;
if (要求字段号表.length()>0){
t3=要求字段号表.split(","); //字段号数组
for (int i=0;i<t3.length;i++){
if (i>0)
字段名字串0=字段名字串0+","+t2[Integer.parseInt(t3[i])];
else 字段名字串0=t2[Integer.parseInt(t3[i])];
}
字段名字串=字段名字串0;
}
else {
要求字段号表="";
for (int i=0;i<t2.length;i++)
if (要求字段号表.length()==0) 要求字段号表=i+"";
else 要求字段号表=要求字段号表+","+i;
}
main1.driver1();
frame1.setTitle("表1 作者：程学先");
frame3.setTitle("运算结果 ");
frame1.setBounds(10, 10, 1200, 600);
frame3.setBounds(200, 160, 1200, 500);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel1.setBounds(10, 10, 1200, 600);
panel3.setBounds(200, 10, 1200, 660);
panel1.setLayout(null);
panel3.setLayout(null);
if ((表名1!=null)&&(表名1.length()>0)){
c=0;
b=0;
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select "+字段名字串+" from "+表名1;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数1=rsmd.getColumnCount();
列名1 = new String[列数1];
列数据类型1 = new String[列数1];
列数据宽度1 = new int[列数1];
for(int i=0; i<列数1; i++) {
列名1[i] = rsmd.getColumnName(i + 1);
列数据类型1[i] = rsmd.getColumnTypeName(i+1);
列数据宽度1[i] = rsmd.getColumnDisplaySize(i + 1);
if (列数据宽度1[i]<5) 列数据宽度1[i]=5;
表1宽度=表1宽度+列数据宽度1[i]*宽度系数;
}
rs.last();
记录条数1=rs.getRow();
一条记录1= new String[记录条数1];
表格数据1=new String[记录条数1][列数1];
rs.absolute(1);
while(c<记录条数1) {
rs.absolute(c+1);
一条记录1[c]="";
while(b<列数1){
表格数据1[c][b]=rs.getString(b+1);
if (b==0) 一条记录1[c]=表格数据1[c][b];
else 一条记录1[c]=一条记录1[c]+","+表格数据1[c][b];
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null,"读取表1失败！"+s1);
return;
}
scrollPane1.setBounds(20,10,表1宽度,450);
表格模型1 = new DefaultTableModel(表格数据1, 列名1);
表格1 = new JTable(表格模型1);
表格1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(表格1, null);
for (int i=0;i<列数1;i++) {
TableColumn tc = 表格1.getColumn(列名1[i]);
tc.setPreferredWidth(列数据宽度1[i]*宽度系数);
}
panel1.add(scrollPane1);
表格1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
选中行号1=表格1.rowAtPoint(e.getPoint());
当前列号1=表格1.columnAtPoint(e.getPoint());
}
}
});
} //以上主表
if ((表名2!=null)&&(表名2.length()>0)){
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select * from "+表名2;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数2=rsmd.getColumnCount();
列名2 = new String[列数2];
for(int i=0; i<列数2; i++) {
列名2[i] = rsmd.getColumnName(i + 1);
}
if (要求字段号表0.length()>0){
t3=要求字段号表0.split(","); //字段号数组要求字段号表0
字段名字串1="";
for (int i=0;i<t3.length;i++){
if (i>0)
字段名字串1=字段名字串1+","+列名2[Integer.parseInt(t3[i])];
else 字段名字串1=列名2[Integer.parseInt(t3[i])];
}
字段名字串0=字段名字串1;
}
else 字段名字串0=" * "; //以上得到子表字段名串
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null,"读取表2失败！"+s1);
return;
}
c=0;
b=0;
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select "+字段名字串0+" from "+表名2;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数2=rsmd.getColumnCount();
列名2 = new String[列数2];
列数据类型2 = new String[列数2];
列数据宽度2 = new int[列数2];
for(int i=0; i<列数2; i++) {
列名2[i] = rsmd.getColumnName(i + 1);
列数据类型2[i] = rsmd.getColumnTypeName(i+1);
列数据宽度2[i] = rsmd.getColumnDisplaySize(i + 1);
if (列数据宽度2[i]<5) 列数据宽度2[i]=5;
表2宽度=表2宽度+列数据宽度2[i]*宽度系数;
}
rs.last();
记录条数2=rs.getRow();
一条记录2= new String[记录条数2];
表格数据2=new String[记录条数2][列数2];
rs.absolute(1);
while(c<记录条数2) {
rs.absolute(c+1);
一条记录2[c]="";
while(b<列数2){
表格数据2[c][b]=rs.getString(b+1);
if (b==0) 一条记录2[c]=表格数据2[c][b];
else 一条记录2[c]=一条记录2[c]+","+表格数据2[c][b];
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null," 读取表2失败！ "+s1);
return;
}
表格模型2 = new DefaultTableModel(表格数据2, 列名2);
表格2 = new JTable(表格模型2);
表格2.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
表格2.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(表格2, null);
scrollPane2.setBounds(表1宽度+40,10,表2宽度,450);
for (int i=0;i<列数2;i++) {
TableColumn tc = 表格2.getColumn(列名2[i]);
tc.setPreferredWidth(列数据宽度2[i]*宽度系数);
}
panel1.add(scrollPane2);
表格2.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
选中行号2=表格2.rowAtPoint(e.getPoint());
当前列号2=表格2.columnAtPoint(e.getPoint());
}
}
});
}
按钮宽=(窗口宽-200)/按钮数;
int 左边距=150;
final JButton 表1减表2 = new JButton(按钮集[0]);
表1减表2.setBounds(左边距,500,按钮宽, 20);
if (要求按钮号表.indexOf(",0,")>=0) 左边距=左边距+按钮宽;
表1减表2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
表3宽度=表1宽度;
int 表3记录数=0;
set1.clear();
if (列数1!=列数2){
JOptionPane.showMessageDialog( null,"二表列数不相等，不能求差集！"+s1);
return;
}
列数3=列数1;
列名3=new String[列数3];
列数据宽度3=new int[列数3];
列数据类型3=new String[列数3];
表格数据3=new String[一条记录2.length][列数1];
for (int j=0;j<列数1;j++){
列数据类型3[j]=列数据类型1[j];
列名3[j]=列名1[j];
列数据宽度3[j]=列数据宽度1[j];
}
String []t4;
b=0;
m: for (int i=0;i<一条记录1.length;i++){
for (int j=0;j<一条记录2.length;j++)
if (一条记录1[i].equals(一条记录2[j]))
continue m; //找到相同的去掉
t4=一条记录1[i].split(",");
for (int k=0;k<列数1;k++)
表格数据3[b][k]=t4[k];
b++;
}
表格模型3 = new DefaultTableModel(表格数据3, 列名1);
scrollPane3.setBounds(20,60,表3宽度*4,450);
表格3 = new JTable(表格模型3);
表格3.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(表格3, null);
for (int i=0;i<列数3;i++) {
TableColumn tc = 表格3.getColumn(列名3[i]);
tc.setPreferredWidth(列数据宽度3[i]*宽度系数);
}
panel3.add(scrollPane3);
frame3.setVisible(true);
}
});
if (要求按钮号表.indexOf(",0,")>=0)
panel1.add(表1减表2);
final JButton 退出1 = new JButton(按钮集[1]);
退出1.setBounds(左边距,500,按钮宽, 20);
if (要求按钮号表.indexOf(",0,")>=0) 左边距=左边距+按钮宽;
退出1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (要求按钮号表.indexOf(",1,")>=0)
panel1.add(退出1);
final JButton 退出3 = new JButton(按钮集[1]);
退出3.setBounds(1000,400,120, 20);
退出3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
panel3.add(退出3);
frame3.add(panel3);
frame1.add(panel1);
frame3.setVisible(true);
frame1.setVisible(true);
}
public static void createNew() {
String 类型1 = main1.数字数据类型;
if ((结果表名!=null)&&(结果表名.length()>0)){
if ((","+表名表).lastIndexOf(","+结果表名+",")<0) {
try {
s1="CREATE TABLE "+ 结果表名+" (";
for (int i=0;i<列名3.length;i++){
s1=s1+列名3[i]+" "+列数据类型3[i];
if (main1.类型.lastIndexOf(","+列数据类型3[i]+",")>=0)
s1=s1+"("+列数据宽度3[i]+")";
if (i!=列名3.length-1) s1=s1+",";
}
s1=s1+")";
con=main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s1);
sta3.close(); //关闭连接
con.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "建表失败！"+s1);
}
}
else {
try {
s1="delete from "+结果表名;
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
sta3.close(); //关闭连接
con.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "删除操作失败！"+s1);
}
}
try {
con2=main1.getConn();
sta5 = con2.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s3="";
for (int j=0;j<列数3;j++)
if (j<列数3-1) s3=s3+列名3[j]+",";
else s3=s3+列名3[j];
int n=0;
for (int i1=0;i1<表格模型3.getRowCount();i1++){
s2="";
for (int j=0;j<列数3;j++)
if (表格模型3.getValueAt(i1,j)!=null)
s2=s2+ 表格模型3.getValueAt(i1,j).toString();
s1="insert into "+结果表名+" ("+s3+") values (";
for (int j=0;j<列数3;j++){
if (类型1.lastIndexOf(","+列数据类型3[j]+",")>=0)
if (表格模型3.getValueAt(i1,j)!=null)
if (j<列数3-1) s1=s1+表格模型3.getValueAt(i1,j)+",";
else s1=s1+表格模型3.getValueAt(i1,j);
else
if (j<列数3-1) s1=s1+"0,";
else s1=s1+"0";
else
if (表格模型3.getValueAt(i1,j)!=null)
if (j<列数3-1) s1=s1+"'"+表格模型3.getValueAt(i1,j)+"',";
else s1=s1+"'"+表格模型3.getValueAt(i1,j)+"'";
else
if (j<列数3-1) s1=s1+"' ',";
else s1=s1+"' '";
}
s1=s1+")";
sta5.executeUpdate(s1);
}
sta5.close(); //关闭连接
con2.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "操作出错，请查看录入语句是否正确！"+s1);
}
}
}
}
64.源码64，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/*
* 程序文件名：dataStatistic6.java
* 作者：程学先
* 功能：求将二个表的数据合并到一个表中（求二个关系的并集）。
* 必须提供的参数：表1名称，表2名称。
* 在第一页表现源表数据，关系运算结果在第二页显示。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Vector;
public class dataStatistic7 extends JFrame {
private static ItemListener ItemListener = null;
private static dataStatistic7 frame1 = new dataStatistic7(); //定义窗口
private static dataStatistic7 frame3 = new dataStatistic7();
private static JPanel panel1 = new JPanel(); //定义面板
private static JPanel panel3 = new JPanel();
private static DefaultTableModel 表格模型1; // 定义表格模型对象
private static DefaultTableModel 表格模型2;
private static DefaultTableModel 表格模型3;
private static JTable 表格1;
private static JTable 表格2;
private static JTable 表格3;
private static JScrollPane scrollPane1 = new JScrollPane();
private static JScrollPane scrollPane2 = new JScrollPane();
private static JScrollPane scrollPane3 = new JScrollPane();
private static String[][] 表格数据1;
private static String[][] 表格数据2;
private static String[][] 表格数据3;
private static String 表名1;
private static String 表名2;
private static String 结果表名;
private static String 表名表,要求字段号表,要求字段号表0;
private static String[] 列名1;
private static String[] 列名2;
private static String[] 列名3;
private static int 列数1,宽度系数=8;
private static int 列数2,列数3;
private static int c=0,b=0;
private static int 选中行号1;
private static int 选中行号2;
private static int 记录条数1=0,记录条数2=0,记录条数3=0;
private static int 当前列号1=0;
private static int 当前列号2=0;
private static String[] 列数据类型1;
private static String[] 列数据类型2;
private static String[] 列数据类型3;
private static int[] 列数据宽度1;
private static int[] 列数据宽度2;
private static int[] 列数据宽度3;
private static int 表1宽度=0;
private static int 表2宽度=0;
private static int 表3宽度=0;
private static String[] 一条记录1;
private static String[] 一条记录2;
private static String[] 一条记录3;
private static ArrayList list1=new ArrayList();
private static Choice fa0=new Choice();
private static HashSet set1=new HashSet();
private static HashSet set2=new HashSet();
static Connection con;
private static Statement sta3;
static Connection con2;
private static Statement sta5;
private static ResultSet rs;
static String s1="",s2="",s3="",s4="",当前值="";
private static ResultSetMetaData rsmd;
static String [] 按钮集=null;
static String 要求按钮号表;
static int 窗口宽=0,窗口高=0,按钮数=0,按钮宽=0;
public static void means(String[] parameter) {
frame1 = new dataStatistic7(); //定义窗口
frame3 = new dataStatistic7();
panel1 = new JPanel(); //定义面板
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
c=0;b=0;
记录条数1=0;记录条数2=0;记录条数3=0;
当前列号1=0;当前列号2=0;
list1=new ArrayList();
fa0=new Choice();
set1=new HashSet();
set2=new HashSet();
s1="";s2="";s3="";s4="";当前值="";
表1宽度=0;表2宽度=0;表3宽度=0;
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){}
宽度系数=15;
ItemListener = null;frame1 = new dataStatistic7();frame3 = new dataStatistic7();
panel1 = new JPanel();panel3 = new JPanel();scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();scrollPane3 = new JScrollPane();
记录条数1=0;记录条数2=0;记录条数3=0;
表1宽度=0;表2宽度=0;表3宽度=0;list1=new ArrayList();
fa0=new Choice();set1=new HashSet();set2=new HashSet();
s1="";s2="";s3="";s4="";当前值="";
表名1=parameter[4];
表名2=parameter[2];
表名表=parameter[0];
结果表名=parameter[5];
String 字段名字串=parameter[19];
String [] t2=parameter[19].split(","); //字段名数组
要求字段号表=parameter[8] ; // 需要显示的字段的顺序号
要求字段号表0=parameter[9] ; // 需要显示的子表字段的顺序号
String 字段名字串0="",字段名字串1="";
String [] t3;
if (要求字段号表.length()>0){
t3=要求字段号表.split(","); //字段号数组
for (int i=0;i<t3.length;i++){
if (i>0)
字段名字串0=字段名字串0+","+t2[Integer.parseInt(t3[i])];
else 字段名字串0=t2[Integer.parseInt(t3[i])];
}
字段名字串=字段名字串0;
}
要求字段号表=parameter[8] ; // 需要显示的字段的顺序号
要求字段号表0=parameter[9] ; // 需要显示的子表字段的顺序号
main1.driver1();
frame1.setTitle("表1 作者：程学先");
frame3.setTitle("运算结果 作者：程学先");
frame1.setBounds(10, 10, 1200, 600);
frame3.setBounds(200, 160, 1200, 560);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel1.setBounds(10, 10, 1200, 600);
panel3.setBounds(200, 10, 1200, 660);
panel1.setLayout(null);
panel3.setLayout(null);
if ((表名1!=null)&&(表名1.length()>0)){
c=0;
b=0;
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select "+字段名字串+" from "+表名1;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数1=rsmd.getColumnCount();
列名1 = new String[列数1];
列数据类型1 = new String[列数1];
列数据宽度1 = new int[列数1];
for(int i=0; i<列数1; i++) {
列名1[i] = rsmd.getColumnName(i + 1);
列数据类型1[i] = rsmd.getColumnTypeName(i+1);
列数据宽度1[i] = rsmd.getColumnDisplaySize(i + 1);
if (列数据宽度1[i]<5) 列数据宽度1[i]=5;
表1宽度=表1宽度+列数据宽度1[i]*宽度系数;
}
rs.last();
记录条数1=rs.getRow();
一条记录1= new String[记录条数1];
表格数据1=new String[记录条数1][列数1];
rs.absolute(1);
while(c<记录条数1) {
rs.absolute(c+1);
一条记录1[c]="";
while(b<列数1){
表格数据1[c][b]=rs.getString(b+1);
if (b==0) 一条记录1[c]=表格数据1[c][b];
else 一条记录1[c]=一条记录1[c]+","+表格数据1[c][b];
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null,"读取表1失败！"+s1);
return;
}
scrollPane1.setBounds(20,10,表1宽度,450);
表格模型1 = new DefaultTableModel(表格数据1, 列名1);
表格1 = new JTable(表格模型1);
表格1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(表格1, null);
for (int i=0;i<列数1;i++) {
TableColumn tc = 表格1.getColumn(列名1[i]);
tc.setPreferredWidth(列数据宽度1[i]*宽度系数);
}
panel1.add(scrollPane1);
表格1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
选中行号1=表格1.rowAtPoint(e.getPoint());
当前列号1=表格1.columnAtPoint(e.getPoint());
}
}
});
}
if ((表名2!=null)&&(表名2.length()>0)){
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select * from "+表名2;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数2=rsmd.getColumnCount();
列名2 = new String[列数2];
for(int i=0; i<列数2; i++) {
列名2[i] = rsmd.getColumnName(i + 1);
}
if (要求字段号表0.length()>0){
t3=要求字段号表0.split(","); //字段号数组要求字段号表0
字段名字串1="";
for (int i=0;i<t3.length;i++){
if (i>0)
字段名字串1=字段名字串1+","+列名2[Integer.parseInt(t3[i])];
else 字段名字串1=列名2[Integer.parseInt(t3[i])];
}
字段名字串0=字段名字串1;
}
else 字段名字串0=" * "; //以上得到子表字段名串
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null,"读取表2失败！"+s1);
return;
}
c=0;
b=0;
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select "+字段名字串0+" from "+表名2;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数2=rsmd.getColumnCount();
列名2 = new String[列数2];
列数据类型2 = new String[列数2];
列数据宽度2 = new int[列数2];
for(int i=0; i<列数2; i++) {
列名2[i] = rsmd.getColumnName(i + 1);
列数据类型2[i] = rsmd.getColumnTypeName(i+1);
列数据宽度2[i] = rsmd.getColumnDisplaySize(i + 1);
if (列数据宽度2[i]<5) 列数据宽度2[i]=5;
表2宽度=表2宽度+列数据宽度2[i]*宽度系数;
}
rs.last();
记录条数2=rs.getRow();
一条记录2= new String[记录条数2];
表格数据2=new String[记录条数2][列数2];
rs.absolute(1);
while(c<记录条数2) {
rs.absolute(c+1);
一条记录2[c]="";
while(b<列数2){
表格数据2[c][b]=rs.getString(b+1);
if (b==0) 一条记录2[c]=表格数据2[c][b];
else 一条记录2[c]=一条记录2[c]+","+表格数据2[c][b];
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null," 读取表2失败！ "+s1);
return;
}
表格模型2 = new DefaultTableModel(表格数据2, 列名2);
表格2 = new JTable(表格模型2);
表格2.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
表格2.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(表格2, null);
scrollPane2.setBounds(表1宽度+40,10,表2宽度,450);
for (int i=0;i<列数2;i++) {
TableColumn tc = 表格2.getColumn(列名2[i]);
tc.setPreferredWidth(列数据宽度2[i]*宽度系数);
}
panel1.add(scrollPane2);
表格2.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
选中行号2=表格2.rowAtPoint(e.getPoint());
当前列号2=表格2.columnAtPoint(e.getPoint());
}
}
});
}
按钮宽=(窗口宽-200)/按钮数;
int 左边距=150;
final JButton 求并集 = new JButton(按钮集[0]);
求并集.setBounds(左边距,500,按钮宽, 20);
if (要求按钮号表.indexOf(",0,")>=0) 左边距=左边距+按钮宽;
求并集.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
表3宽度=表1宽度;
int 表3记录数=0;
if (列数1!=列数2){
JOptionPane.showMessageDialog( null,"二表列数不相等，不能求并集！"+s1);
return;
}
列数3=列数1;
列名3=new String[列数3];
列数据宽度3=new int[列数3];
列数据类型3=new String[列数3];
表格数据3=new String[一条记录2.length+一条记录2.length][列数1];
for (int j=0;j<列数1;j++){
列名3[j]=列名1[j];
列数据宽度3[j]=列数据宽度1[j];
列数据类型3[j]=列数据类型1[j];
}
String []t4;
b=0;
for (int i=0;i<一条记录1.length;i++){//全部加入表1记录
t4=一条记录1[i].split(",");
for (int k=0;k<列数1;k++)
表格数据3[b][k]=t4[k];
b++;
}
m: for (int j=0;j<一条记录2.length;j++){
for (int i=0;i<一条记录1.length;i++)
if (一条记录1[i].equals(一条记录2[j]))
continue m; //找到相同的去掉
t4=一条记录2[j].split(",");
for (int k=0;k<列数1;k++)
表格数据3[b][k]=t4[k];
b++;
}
表格模型3 = new DefaultTableModel(表格数据3, 列名1);
scrollPane3.setBounds(20,60,表3宽度*4,450);
表格3 = new JTable(表格模型3);
表格3.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(表格3, null);
for (int i=0;i<列数3;i++) {
TableColumn tc = 表格3.getColumn(列名3[i]);
tc.setPreferredWidth(列数据宽度3[i]*宽度系数);
}
panel3.add(scrollPane3);
frame3.setVisible(true);
}
});
if (要求按钮号表.indexOf(",0,")>=0)
panel1.add(求并集);
final JButton 退出1 = new JButton(按钮集[1]);
退出1.setBounds(左边距,500,按钮宽, 20);
if (要求按钮号表.indexOf(",0,")>=0) 左边距=左边距+按钮宽;
退出1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (要求按钮号表.indexOf(",1,")>=0)
panel1.add(退出1);
final JButton 退出3 = new JButton(按钮集[1]);
退出3.setBounds(1000,400,120, 20);
退出3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
panel3.add(退出3);
frame3.add(panel3);
frame1.add(panel1);
frame3.setVisible(true);
frame1.setVisible(true);
}
public static void createNew() {
String 类型1 = main1.数字数据类型;
if ((结果表名!=null)&&(结果表名.length()>0)){
if ((","+表名表).lastIndexOf(","+结果表名+",")<0) {
try {
s1="CREATE TABLE "+ 结果表名+" (";
for (int i=0;i<列名3.length;i++){
s1=s1+列名3[i]+" "+列数据类型3[i];
if (main1.类型.lastIndexOf(","+列数据类型3[i]+",")>=0)
s1=s1+"("+列数据宽度3[i]+")";
if (i!=列名3.length-1) s1=s1+",";
}
s1=s1+")";
con=main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s1);
sta3.close(); //关闭连接
con.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "建表失败！"+s1);
}
}
else {
try {
s1="delete from "+结果表名;
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
sta3.close(); //关闭连接
con.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "删除操作失败！"+s1);
}
}
try {
con2=main1.getConn();
sta5 = con2.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s3="";
for (int j=0;j<列数3;j++)
if (j<列数3-1) s3=s3+列名3[j]+",";
else s3=s3+列名3[j];
int n=0;
for (int i1=0;i1<表格模型3.getRowCount();i1++){
s2="";
for (int j=0;j<列数3;j++)
if (表格模型3.getValueAt(i1,j)!=null)
s2=s2+ 表格模型3.getValueAt(i1,j).toString();
s1="insert into "+结果表名+" ("+s3+") values (";
for (int j=0;j<列数3;j++){
if (类型1.lastIndexOf(","+列数据类型3[j]+",")>=0)
if (表格模型3.getValueAt(i1,j)!=null)
if (j<列数3-1) s1=s1+表格模型3.getValueAt(i1,j)+",";
else s1=s1+表格模型3.getValueAt(i1,j);
else
if (j<列数3-1) s1=s1+"0,";
else s1=s1+"0";
else
if (表格模型3.getValueAt(i1,j)!=null)
if (j<列数3-1) s1=s1+"'"+表格模型3.getValueAt(i1,j)+"',";
else s1=s1+"'"+表格模型3.getValueAt(i1,j)+"'";
else
if (j<列数3-1) s1=s1+"' ',";
else s1=s1+"' '";
}
s1=s1+")";
sta5.executeUpdate(s1);
}
sta5.close(); //关闭连接
con2.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "操作出错，请查看录入语句是否正确！"+s1);
}
}
}
}
65.源码65，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/*
* 程序文件名：dataStatistic6.java
* 作者：程学先
* 功能：求二个表共同都有的记录（求二个关系的交集）。
* 必须提供的参数：表1名称，表2名称。
* 在第一页表现源表数据，关系运算结果在第二页显示。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Vector;
public class dataStatistic8 extends JFrame {
private static ItemListener ItemListener = null;
private static dataStatistic8 frame1 = new dataStatistic8(); //定义窗口
private static dataStatistic8 frame3 = new dataStatistic8();
private static JPanel panel1 = new JPanel(); //定义面板
private static JPanel panel3 = new JPanel();
private static DefaultTableModel 表格模型1; // 定义表格模型对象
private static DefaultTableModel 表格模型2;
private static DefaultTableModel 表格模型3;
private static JTable 表格1;
private static JTable 表格2;
private static JTable 表格3;
private static JScrollPane scrollPane1 = new JScrollPane();
private static JScrollPane scrollPane2 = new JScrollPane();
private static JScrollPane scrollPane3 = new JScrollPane();
private static String[][] 表格数据1;
private static String[][] 表格数据2;
private static String[][] 表格数据3;
private static String 表名1;
private static String 表名2;
private static String 结果表名;
private static String 表名表,要求字段号表,要求字段号表0;
private static String[] 列名1;
private static String[] 列名2;
private static String[] 列名3;
private static int 列数1,宽度系数=8;
private static int 列数2,列数3;
private static int c=0,b=0;
private static int 选中行号1;
private static int 选中行号2;
private static int 记录条数1=0,记录条数2=0,记录条数3=0;
private static int 当前列号1=0;
private static int 当前列号2=0;
private static String[] 列数据类型1;
private static String[] 列数据类型2;
private static String[] 列数据类型3;
private static int[] 列数据宽度1;
private static int[] 列数据宽度2;
private static int[] 列数据宽度3;
private static int 表1宽度=0;
private static int 表2宽度=0;
private static int 表3宽度=0;
private static String[] 一条记录1;
private static String[] 一条记录2;
private static String[] 一条记录3;
private static ArrayList list1=new ArrayList();
private static Choice fa0=new Choice();
private static HashSet set1=new HashSet();
private static HashSet set2=new HashSet();
static Connection con;
static Connection con2;
private static Statement sta5;
private static Statement sta3;
private static ResultSet rs;
static String s1="",s2="",s3="",s4="",当前值="";
private static ResultSetMetaData rsmd;
static String [] 按钮集=null;
static String 要求按钮号表;
static int 窗口宽=0,窗口高=0,按钮数=0,按钮宽=0;
public static void means(String[] parameter) {
frame1 = new dataStatistic8(); //定义窗口
frame3 = new dataStatistic8();
panel1 = new JPanel(); //定义面板
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
c=0;b=0; 宽度系数=8;
记录条数1=0;记录条数2=0;记录条数3=0;
当前列号1=0;当前列号2=0;
list1=new ArrayList();
fa0=new Choice();
set1=new HashSet();
set2=new HashSet();
s1="";s2="";s3="";s4="";当前值="";
表1宽度=0;表2宽度=0;表3宽度=0;
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){}
宽度系数=15;
ItemListener = null;frame1 = new dataStatistic8();frame3 = new dataStatistic8();
panel1 = new JPanel();panel3 = new JPanel();scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();scrollPane3 = new JScrollPane();
记录条数1=0;记录条数2=0;记录条数3=0;
表1宽度=0;表2宽度=0;表3宽度=0;list1=new ArrayList();
fa0=new Choice();set1=new HashSet();set2=new HashSet();
s1="";s2="";s3="";s4="";当前值="";
表名1=parameter[4];
表名2=parameter[2];
结果表名=parameter[5];
表名表=parameter[0];
main1.driver1();
String 字段名字串=parameter[19];
String [] t2=parameter[19].split(","); //字段名数组
要求字段号表=parameter[8] ; // 需要显示的字段的顺序号
要求字段号表0=parameter[9] ; // 需要显示的子表字段的顺序号
String 字段名字串0="",字段名字串1="";
String [] t3;
if (要求字段号表.length()>0){
t3=要求字段号表.split(","); //字段号数组
for (int i=0;i<t3.length;i++){
if (i>0)
字段名字串0=字段名字串0+","+t2[Integer.parseInt(t3[i])];
else 字段名字串0=t2[Integer.parseInt(t3[i])];
}
字段名字串=字段名字串0;
}
frame1.setTitle("表1 作者：程学先");
frame3.setTitle("运算结果 ");
frame1.setBounds(10, 10, 1200, 600);
frame3.setBounds(200, 160, 1200, 500);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel1.setBounds(10, 10, 1200, 600);
panel3.setBounds(200, 10, 1200, 660);
panel1.setLayout(null);
panel3.setLayout(null);
if ((表名1!=null)&&(表名1.length()>0)){
c=0;
b=0;
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select "+字段名字串+" from "+表名1;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数1=rsmd.getColumnCount();
列名1 = new String[列数1];
列数据类型1 = new String[列数1];
列数据宽度1 = new int[列数1];
for(int i=0; i<列数1; i++) {
列名1[i] = rsmd.getColumnName(i + 1);
列数据类型1[i] = rsmd.getColumnTypeName(i+1);
列数据宽度1[i] = rsmd.getColumnDisplaySize(i + 1);
if (列数据宽度1[i]<5) 列数据宽度1[i]=5;
表1宽度=表1宽度+列数据宽度1[i]*宽度系数;
}
rs.last();
记录条数1=rs.getRow();
一条记录1= new String[记录条数1];
表格数据1=new String[记录条数1][列数1];
rs.absolute(1);
while(c<记录条数1) {
rs.absolute(c+1);
一条记录1[c]="";
while(b<列数1){
表格数据1[c][b]=rs.getString(b+1);
if (b==0) 一条记录1[c]=表格数据1[c][b];
else 一条记录1[c]=一条记录1[c]+","+表格数据1[c][b];
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null,"读取表1失败！"+s1);
return;
}
scrollPane1.setBounds(20,10,表1宽度,450);
表格模型1 = new DefaultTableModel(表格数据1, 列名1);
表格1 = new JTable(表格模型1);
表格1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(表格1, null);
for (int i=0;i<列数1;i++) {
TableColumn tc = 表格1.getColumn(列名1[i]);
tc.setPreferredWidth(列数据宽度1[i]*宽度系数);
}
panel1.add(scrollPane1);
表格1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
选中行号1=表格1.rowAtPoint(e.getPoint());
当前列号1=表格1.columnAtPoint(e.getPoint());
}
}
});
}
if ((表名2!=null)&&(表名2.length()>0)){
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select * from "+表名2;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数2=rsmd.getColumnCount();
列名2 = new String[列数2];
for(int i=0; i<列数2; i++) {
列名2[i] = rsmd.getColumnName(i + 1);
}
if (要求字段号表0.length()>0){
t3=要求字段号表0.split(","); //字段号数组要求字段号表0
字段名字串1="";
for (int i=0;i<t3.length;i++){
if (i>0)
字段名字串1=字段名字串1+","+列名2[Integer.parseInt(t3[i])];
else 字段名字串1=列名2[Integer.parseInt(t3[i])];
}
字段名字串0=字段名字串1;
}
else 字段名字串0=" * "; //以上得到子表字段名串
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null,"读取表2失败！"+s1);
return;
}
c=0;
b=0;
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select "+字段名字串0+" from "+表名2;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数2=rsmd.getColumnCount();
列名2 = new String[列数2];
列数据类型2 = new String[列数2];
列数据宽度2 = new int[列数2];
for(int i=0; i<列数2; i++) {
列名2[i] = rsmd.getColumnName(i + 1);
列数据类型2[i] = rsmd.getColumnTypeName(i+1);
列数据宽度2[i] = rsmd.getColumnDisplaySize(i + 1);
if (列数据宽度2[i]<5) 列数据宽度2[i]=5;
表2宽度=表2宽度+列数据宽度2[i]*宽度系数;
}
rs.last();
记录条数2=rs.getRow();
一条记录2= new String[记录条数2];
表格数据2=new String[记录条数2][列数2];
rs.absolute(1);
while(c<记录条数2) {
rs.absolute(c+1);
一条记录2[c]="";
while(b<列数2){
表格数据2[c][b]=rs.getString(b+1);
if (b==0) 一条记录2[c]=表格数据2[c][b];
else 一条记录2[c]=一条记录2[c]+","+表格数据2[c][b];
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null," 读取表2失败！ "+s1);
return;
}
表格模型2 = new DefaultTableModel(表格数据2, 列名2);
表格2 = new JTable(表格模型2);
表格2.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
表格2.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(表格2, null);
scrollPane2.setBounds(表1宽度+40,10,表2宽度,450);
for (int i=0;i<列数2;i++) {
TableColumn tc = 表格2.getColumn(列名2[i]);
tc.setPreferredWidth(列数据宽度2[i]*宽度系数);
}
panel1.add(scrollPane2);
表格2.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
选中行号2=表格2.rowAtPoint(e.getPoint());
当前列号2=表格2.columnAtPoint(e.getPoint());
}
}
});
}
按钮宽=(窗口宽-200)/按钮数;
int 左边距=150;
final JButton 求交集= new JButton(按钮集[0]);
求交集.setBounds(左边距,500,按钮宽, 20);
if (要求按钮号表.indexOf(",0,")>=0) 左边距=左边距+按钮宽;
求交集.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
表3宽度=表1宽度;
int 表3记录数=0;
set1.clear();
if (列数1!=列数2){
JOptionPane.showMessageDialog( null,"二表列数不相等，不能求交集！"+s1);
return;
}
列数3=列数1;
列名3=new String[列数3];
列数据宽度3=new int[列数3];
列数据类型3=new String[列数3];
表格数据3=new String[一条记录2.length][列数1];
for (int j=0;j<列数1;j++){
列数据类型3[j]=列数据类型1[j];
列名3[j]=列名1[j];
列数据宽度3[j]=列数据宽度1[j];
}
String []t4;
b=0;
for (int i=0;i<一条记录1.length;i++){
for (int j=0;j<一条记录2.length;j++)
if (一条记录1[i].equals(一条记录2[j])){
t4=一条记录1[i].split(",");
for (int k=0;k<列数1;k++)
表格数据3[b][k]=t4[k];
b++;
break;
}
}
表格模型3 = new DefaultTableModel(表格数据3, 列名1);
scrollPane3.setBounds(20,60,表3宽度*4,450);
表格3 = new JTable(表格模型3);
表格3.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(表格3, null);
for (int i=0;i<列数3;i++) {
TableColumn tc = 表格3.getColumn(列名3[i]);
tc.setPreferredWidth(列数据宽度3[i]*宽度系数);
}
panel3.add(scrollPane3);
frame3.setVisible(true);
}
});
if (要求按钮号表.indexOf(",0,")>=0)
panel1.add(求交集);
final JButton 退出1 = new JButton(按钮集[1]);
退出1.setBounds(左边距,500,按钮宽, 20);
if (要求按钮号表.indexOf(",1,")>=0) 左边距=左边距+按钮宽;
退出1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (要求按钮号表.indexOf(",1,")>=0)
panel1.add(退出1);
final JButton 退出3 = new JButton(按钮集[1]);
退出3.setBounds(1000,400,120, 20);
退出3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
panel3.add(退出3);
frame3.add(panel3);
frame1.add(panel1);
frame3.setVisible(true);
frame1.setVisible(true);
}
public static void createNew() {
String 类型1 = main1.数字数据类型;
if ((结果表名!=null)&&(结果表名.length()>0)){
if ((","+表名表).lastIndexOf(","+结果表名+",")<0) {
try {
s1="CREATE TABLE "+ 结果表名+" (";
for (int i=0;i<列名3.length;i++){
s1=s1+列名3[i]+" "+列数据类型3[i];
if (main1.类型.lastIndexOf(","+列数据类型3[i]+",")>=0)
s1=s1+"("+列数据宽度3[i]+")";
if (i!=列名3.length-1) s1=s1+",";
}
s1=s1+")";
con=main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s1);
sta3.close(); //关闭连接
con.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "建表失败！"+s1);
}
}
else {
try {
s1="delete from "+结果表名;
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
sta3.close(); //关闭连接
con.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "删除操作失败！"+s1);
}
}
try {
con2=main1.getConn();
sta5 = con2.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s3="";
for (int j=0;j<列数3;j++)
if (j<列数3-1) s3=s3+列名3[j]+",";
else s3=s3+列名3[j];
int n=0;
for (int i1=0;i1<表格模型3.getRowCount();i1++){
s2="";
for (int j=0;j<列数3;j++)
if (表格模型3.getValueAt(i1,j)!=null)
s2=s2+ 表格模型3.getValueAt(i1,j).toString();
s1="insert into "+结果表名+" ("+s3+") values (";
for (int j=0;j<列数3;j++){
if (类型1.lastIndexOf(","+列数据类型3[j]+",")>=0)
if (表格模型3.getValueAt(i1,j)!=null)
if (j<列数3-1) s1=s1+表格模型3.getValueAt(i1,j)+",";
else s1=s1+表格模型3.getValueAt(i1,j);
else
if (j<列数3-1) s1=s1+"0,";
else s1=s1+"0";
else
if (表格模型3.getValueAt(i1,j)!=null)
if (j<列数3-1) s1=s1+"'"+表格模型3.getValueAt(i1,j)+"',";
else s1=s1+"'"+表格模型3.getValueAt(i1,j)+"'";
else
if (j<列数3-1) s1=s1+"' ',";
else s1=s1+"' '";
}
s1=s1+")";
sta5.executeUpdate(s1);
}
sta5.close(); //关闭连接
con2.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "操作出错，请查看录入语句是否正确！"+s1);
}
}
}
}
66.源码66，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/*
* 程序文件名：dataStatistic6.java
* 作者：程学先
* 功能：按某个字段分组，求完全包含有第二个表的数据的那些组（求二个关系相除的商）。
* 必须提供的参数：表1名称，表2名称。
* 在第一页表现源表数据，关系运算结果在第二页显示。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Vector;
public class dataStatistic9 extends JFrame {
private static ItemListener ItemListener = null;
private static dataStatistic9 frame1 = new dataStatistic9(); //定义窗口
private static dataStatistic9 frame3 = new dataStatistic9();
private static JPanel panel1 = new JPanel(); //定义面板
private static JPanel panel3 = new JPanel();
private static DefaultTableModel 表格模型1; // 定义表格模型对象
private static DefaultTableModel 表格模型2;
private static DefaultTableModel 表格模型3;
private static JTable 表格1;
private static JTable 表格2;
private static JTable 表格3;
private static JScrollPane scrollPane1 = new JScrollPane();
private static JScrollPane scrollPane2 = new JScrollPane();
private static JScrollPane scrollPane3 = new JScrollPane();
private static String[][] 表格数据1;
private static String[][] 表格数据2;
private static String[][] 表格数据3;
private static String 表名1;
private static String 表名2;
private static String 结果表名;
private static String 表名表,要求字段号表,要求字段号表0;
private static String[] 列名1;
private static String[] 列名2;
private static String[] 列名3;
private static int 列数1,宽度系数=8;
private static int 列数2,列数3;
private static int c=0,b=0;
private static int 选中行号1;
private static int 选中行号2;
private static int 记录条数1=0,记录条数2=0,记录条数3=0;
private static int 当前列号1=0;
private static int 当前列号2=0;
private static String[] 列数据类型1;
private static String[] 列数据类型2;
private static String[] 列数据类型3;
private static int[] 列数据宽度1;
private static int[] 列数据宽度2;
private static int[] 列数据宽度3;
private static int 表1宽度=0;
private static int 表2宽度=0;
private static int 表3宽度=0;
private static String[] 一条记录1;
private static String[] 一条记录2;
private static String[] 一条记录3;
private static ArrayList list1=new ArrayList();
private static Choice fa0=new Choice();
private static HashSet set1=new HashSet();
private static HashSet set2=new HashSet();
static Connection con;
private static Statement sta3;
static Connection con2;
private static Statement sta5;
private static ResultSet rs;
static String s1="",s2="",s3="",s4="",当前值="";
private static ResultSetMetaData rsmd;
static String [] 按钮集=null;
static String 要求按钮号表;
static int 窗口宽=0,窗口高=0,按钮数=0,按钮宽=0;
public static void means(String[] parameter) {
String [] 按钮集01={"表1除以表2","退出"};
按钮集=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){}
frame1 = new dataStatistic9(); //定义窗口
frame3 = new dataStatistic9();
panel1 = new JPanel(); //定义面板
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
c=0;b=0;
记录条数1=0;记录条数2=0;记录条数3=0;
当前列号1=0;当前列号2=0;
list1=new ArrayList();
fa0=new Choice();
set1=new HashSet();
set2=new HashSet();
s1="";s2="";s3="";s4="";当前值="";
表1宽度=0;表2宽度=0;表3宽度=0;
宽度系数=15;
ItemListener = null;frame1 = new dataStatistic9();frame3 = new dataStatistic9();
panel1 = new JPanel();panel3 = new JPanel();scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();scrollPane3 = new JScrollPane();
记录条数1=0;记录条数2=0;记录条数3=0;
表1宽度=0;表2宽度=0;表3宽度=0;list1=new ArrayList();
fa0=new Choice();set1=new HashSet();set2=new HashSet();
s1="";s2="";s3="";s4="";当前值="";
表名1=parameter[4];
表名2=parameter[2];
结果表名=parameter[5];
表名表=parameter[0];
String 字段名字串=parameter[19];
String [] t2=parameter[19].split(","); //字段名数组
要求字段号表=parameter[8] ; // 需要显示的字段的顺序号
要求字段号表0=parameter[9] ; // 需要显示的子表字段的顺序号
String 字段名字串0="",字段名字串1="";
String [] t3;
if (要求字段号表.length()>0){
t3=要求字段号表.split(","); //字段号数组
for (int i=0;i<t3.length;i++){
if (i>0)
字段名字串0=字段名字串0+","+t2[Integer.parseInt(t3[i])];
else 字段名字串0=t2[Integer.parseInt(t3[i])];
}
字段名字串=字段名字串0;
}
main1.driver1();
frame1.setTitle("表1 作者：程学先");
frame3.setTitle("运算结果 ");
frame1.setBounds(10, 10, 1200, 600);
frame3.setBounds(200,110, 1200, 560);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel1.setBounds(10, 10, 1200, 600);
panel3.setBounds(200, 10, 1200, 660);
panel1.setLayout(null);
panel3.setLayout(null);
if ((表名1!=null)&&(表名1.length()>0)){
c=0;
b=0;
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select "+字段名字串+" from "+表名1;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数1=rsmd.getColumnCount();
列名1 = new String[列数1];
列数据类型1 = new String[列数1];
列数据宽度1 = new int[列数1];
for(int i=0; i<列数1; i++) {
列名1[i] = rsmd.getColumnName(i + 1);
列数据类型1[i] = rsmd.getColumnTypeName(i+1);
列数据宽度1[i] = rsmd.getColumnDisplaySize(i + 1);
if (列数据宽度1[i]<5) 列数据宽度1[i]=5;
表1宽度=表1宽度+列数据宽度1[i]*宽度系数;
}
rs.last();
记录条数1=rs.getRow();
一条记录1= new String[记录条数1];
表格数据1=new String[记录条数1][列数1];
rs.absolute(1);
while(c<记录条数1) {
rs.absolute(c+1);
一条记录1[c]="";
while(b<列数1){
表格数据1[c][b]=rs.getString(b+1);
if (b==0) 一条记录1[c]=表格数据1[c][b];
else 一条记录1[c]=一条记录1[c]+","+表格数据1[c][b];
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null,"读取表1失败！"+s1);
return;
}
scrollPane1.setBounds(20,10,表1宽度,450);
表格模型1 = new DefaultTableModel(表格数据1, 列名1);
表格1 = new JTable(表格模型1);
表格1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(表格1, null);
for (int i=0;i<列数1;i++) {
TableColumn tc = 表格1.getColumn(列名1[i]);
tc.setPreferredWidth(列数据宽度1[i]*宽度系数);
}
panel1.add(scrollPane1);
表格1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
选中行号1=表格1.rowAtPoint(e.getPoint());
当前列号1=表格1.columnAtPoint(e.getPoint());
}
}
});
}
if ((表名2!=null)&&(表名2.length()>0)){
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select * from "+表名2;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数2=rsmd.getColumnCount();
列名2 = new String[列数2];
for(int i=0; i<列数2; i++) {
列名2[i] = rsmd.getColumnName(i + 1);
}
if (要求字段号表0.length()>0){
t3=要求字段号表0.split(","); //字段号数组要求字段号表0
字段名字串1="";
for (int i=0;i<t3.length;i++){
if (i>0)
字段名字串1=字段名字串1+","+列名2[Integer.parseInt(t3[i])];
else 字段名字串1=列名2[Integer.parseInt(t3[i])];
}
字段名字串0=字段名字串1;
}
else 字段名字串0=" * "; //以上得到子表字段名串
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null,"读取表2失败！"+s1);
return;
}
c=0;
b=0;
try {
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1="select "+字段名字串0+" from "+表名2;
rs=sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数2=rsmd.getColumnCount();
列名2 = new String[列数2];
列数据类型2 = new String[列数2];
列数据宽度2 = new int[列数2];
for(int i=0; i<列数2; i++) {
列名2[i] = rsmd.getColumnName(i + 1);
列数据类型2[i] = rsmd.getColumnTypeName(i+1);
列数据宽度2[i] = rsmd.getColumnDisplaySize(i + 1);
if (列数据宽度2[i]<5) 列数据宽度2[i]=5;
表2宽度=表2宽度+列数据宽度2[i]*宽度系数;
}
rs.last();
记录条数2=rs.getRow();
一条记录2= new String[记录条数2];
表格数据2=new String[记录条数2][列数2];
rs.absolute(1);
while(c<记录条数2) {
rs.absolute(c+1);
一条记录2[c]="";
while(b<列数2){
表格数据2[c][b]=rs.getString(b+1);
if (b==0) 一条记录2[c]=表格数据2[c][b];
else 一条记录2[c]=一条记录2[c]+","+表格数据2[c][b];
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch(Exception e1) {
JOptionPane.showMessageDialog( null," 读取表2失败！ "+s1);
return;
}
表格模型2 = new DefaultTableModel(表格数据2, 列名2);
表格2 = new JTable(表格模型2);
表格2.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
表格2.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(表格2, null);
scrollPane2.setBounds(表1宽度+40,10,表2宽度,450);
for (int i=0;i<列数2;i++) {
TableColumn tc = 表格2.getColumn(列名2[i]);
tc.setPreferredWidth(列数据宽度2[i]*宽度系数);
}
panel1.add(scrollPane2);
表格2.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
选中行号2=表格2.rowAtPoint(e.getPoint());
当前列号2=表格2.columnAtPoint(e.getPoint());
}
}
});
}
按钮宽=(窗口宽-200)/按钮数;
int 左边距=150;
final JButton 表1除以表2 = new JButton(按钮集[0]);
表1除以表2.setBounds(左边距,500,按钮宽, 20);
if (要求按钮号表.indexOf(",0,")>=0) 左边距=左边距+按钮宽;
表1除以表2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
char x1=10,x2=13;
String s6=JOptionPane.showInputDialog("请输入分组字段与要求包含的字段名："+x1+x2+
"格式：<分组字段名集><。><包含字段名集>"+x1+x2+
"其中，分组字段名集是表1中某些列的名字，是商集的字段名，用逗号分隔" +x1+x2+
"要求包含的字段名是表1与表2中都有的某些列的名字。"+x1+x2+
"例如：学号,姓名。课程名");
String [] s8=s6.split("。");
列名3=s8[0].split(",");
列数3=列名3.length;
int [] 分组字段号=new int[列数3];
String [] 包含字段名=s8[1].split(",");
int [] 包含字段号=new int[包含字段名.length];
int [] 包含字段号2=new int[包含字段名.length];
String [][] 临时商=new String[1000][列数3];
int [] 组包含数量=new int[1000];
列数据宽度3=new int[列数3];
列数据类型3=new String[列数3];
表3宽度=0;
for (int i=0;i<列数1;i++){
for (int j=0;j<列名3.length;j++)
if(列名3[j].trim().equals(列名1[i].trim())){
分组字段号[j]=i;
列数据宽度3[j]=列数据宽度1[i];
表3宽度=表3宽度+列数据宽度3[j];
列数据类型3[j]=列数据类型1[i];
}
for (int j=0;j<包含字段名.length;j++)
if(包含字段名[j].trim().equals(列名1[i].trim()))
包含字段号[j]=i;
}
for (int i=0;i<列数2;i++)
for (int j=0;j<包含字段名.length;j++)
if(包含字段名[j].trim().equals(列名2[i].trim()))
包含字段号2[j]=i;
s8=new String[表格模型2.getRowCount()];
for (int i1=0;i1<表格模型2.getRowCount();i1++){
s8[i1]="";
for (int j=0;j<包含字段名.length;j++){
s8[i1]=s8[i1]+表格模型2.getValueAt(i1,包含字段号2[j]).toString().trim();
}
}
int n=0,n1=0;
set1.clear();
记录条数3=0;
for (int i1=0;i1<表格模型1.getRowCount();i1++){
s1="";
for (int j=0;j<列数3;j++){
s1=s1+表格模型1.getValueAt(i1,分组字段号[j]).toString().trim();
}
set1.add(s1);
if (set1.size()!=n){
for (int j=0;j<列数3;j++){
临时商[n][j]=表格模型1.getValueAt(i1,分组字段号[j]).toString().trim();
}
set2.clear();
n1=0;
for (int i2=0;i2<表格模型1.getRowCount();i2++){
s3="";
for (int j1=0;j1<列数3;j1++)
s3=s3+表格模型1.getValueAt(i2,分组字段号[j1]).toString().trim();
s4="";
for (int j1=0;j1<包含字段名.length;j1++)
s4=s4+表格模型1.getValueAt(i2,包含字段号[j1]).toString().trim();
for (int i3=0;i3<表格模型2.getRowCount();i3++)
if ((s3.trim().equals(s1.trim()))&&(s4.trim().equals(s8[i3].trim()))) {
set2.add(s4);
if (set2.size()!=n1){
n1=set2.size();
组包含数量[n]++;
if (组包含数量[n]==表格模型2.getRowCount())
记录条数3++;
}
}
}
n=set1.size();
}
}
表格数据3=new String[记录条数3][列数3];
int n2=0;
for (int i=0;i<n-1;i++)
if (组包含数量[i]==表格模型2.getRowCount()){
for (int j=0;j<列名3.length;j++){
表格数据3[n2][j]=临时商[i][j];
}
n2++;
}
scrollPane3.setBounds(20,60,表3宽度*宽度系数,450);
表格模型3 = new DefaultTableModel(表格数据3, 列名3);
表格3 = new JTable(表格模型3);
表格3.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(表格3, null);
for (int i=0;i<列数3;i++) {
TableColumn tc = 表格3.getColumn(列名3[i]);
tc.setPreferredWidth(列数据宽度3[i]*宽度系数);
}
panel3.add(scrollPane3);
frame3.setVisible(true);
}
});
if (要求按钮号表.indexOf(",0,")>=0)
panel1.add(表1除以表2);
final JButton 退出1 = new JButton(按钮集[1]);
退出1.setBounds(左边距,500,按钮宽, 20);
if (要求按钮号表.indexOf(",1,")>=0) 左边距=左边距+按钮宽;
退出1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (要求按钮号表.indexOf(",1,")>=0)
panel1.add(退出1);
final JButton 退出3 = new JButton(按钮集[1]);
退出3.setBounds(1000,400,120, 20);
退出3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
panel3.add(退出3);
frame3.add(panel3);
frame1.add(panel1);
frame3.setVisible(true);
frame1.setVisible(true);
}
public static void createNew() {
String 类型1 = main1.数字数据类型;
if ((结果表名!=null)&&(结果表名.length()>0)){
if ((","+表名表).lastIndexOf(","+结果表名+",")<0) {
try {
s1="CREATE TABLE "+ 结果表名+" (";
for (int i=0;i<列名3.length;i++){
s1=s1+列名3[i]+" "+列数据类型3[i];
if (main1.类型.lastIndexOf(","+列数据类型3[i]+",")>=0)
s1=s1+"("+列数据宽度3[i]+")";
if (i!=列名3.length-1) s1=s1+",";
}
s1=s1+")";
con=main1.getConn();// 连接目的数据库
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s1); //建表
sta3.close(); //关闭连接
con.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "建表失败！"+s1);
}
}
else {
try {
s1="delete from "+结果表名;
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
sta3.close(); //关闭连接
con.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "删除操作失败！"+s1);
}
}
try {
con2=main1.getConn();// 连接目的数据库
sta5 = con2.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s3="";
for (int j=0;j<列数3;j++)
if (j<列数3-1) s3=s3+列名3[j]+",";
else s3=s3+列名3[j];
int n=0;
for (int i1=0;i1<表格模型3.getRowCount();i1++){
s2="";
for (int j=0;j<列数3;j++)
if (表格模型3.getValueAt(i1,j)!=null)
s2=s2+ 表格模型3.getValueAt(i1,j).toString();
s1="insert into "+结果表名+" ("+s3+") values (";
for (int j=0;j<列数3;j++){
if (类型1.lastIndexOf(","+列数据类型3[j]+",")>=0)
if (表格模型3.getValueAt(i1,j)!=null)
if (j<列数3-1) s1=s1+表格模型3.getValueAt(i1,j)+",";
else s1=s1+表格模型3.getValueAt(i1,j);
else
if (j<列数3-1) s1=s1+"0,";
else s1=s1+"0";
else
if (表格模型3.getValueAt(i1,j)!=null)
if (j<列数3-1) s1=s1+"'"+表格模型3.getValueAt(i1,j)+"',";
else s1=s1+"'"+表格模型3.getValueAt(i1,j)+"'";
else
if (j<列数3-1) s1=s1+"' ',";
else s1=s1+"' '";
}
s1=s1+")";
sta5.executeUpdate(s1);
}
sta5.close(); //关闭连接
con2.close();
}catch(SQLException e1) {
JOptionPane.showMessageDialog( null, "操作出错，请查看录入语句是否正确！"+s1);
}
}
}
}
版本2
62.源码62，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/**
* 程序文件名：dataStatistic5.java
* 作者：程学先
* 功能：删除重复记录，可针对指定的多个字段寻找重复记录，求字段中不得包含大数据类型。
* 完成日期：2013年1月22日
*/
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.util.HashSet;
import java.io.UnsupportedEncodingException;
public class dataStatistic5 extends JFrame {
static dataStatistic5 frame = new dataStatistic5();
private static JTable table;
static Connection con1;
static ResultSetMetaData rsmd4;
static Statement sta4;
static int variabl2483 = 800, variabl2503 = 630;
static int variabl2651, variabl26512;
static String[][] variabl2517;
static String[] variabl1501, variabl15012, variabl19191, variabl25172;
static int[] variabl1489, variabl1571;
static int variabl1853 = 0;
static int variabl1527;
static String[][] variabl2197, variabl21972;
static DefaultTableModel model, variabl19652;
static String variabl2603;
static String variabl1873;
static String variabl1735, variabl1325, variabl13250;
static String s1 = "", s2 = "", s3 = "";
static String s4 = "", T1 = "";
static int c = 0, b = 0, variabl2067 = 0;
static ResultSet rs;
static JPanel panel = new JPanel(false);
static JScrollPane scrollPane = new JScrollPane();
private static HashSet set1 = new HashSet();
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
frame = new dataStatistic5();
variabl2483 = 800;
variabl2503 = 630;
variabl1853 = 0;
s1 = "";
s2 = "";
s3 = "";
s4 = "";
T1 = "";
c = 0;
b = 0;
variabl2067 = 0;
panel = new JPanel(false);
scrollPane = new JScrollPane();
set1 = new HashSet();
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) {
}
variabl2603 = parameter[4];
variabl1735 = parameter[8];
variabl1325 = parameter[19];
variabl13250 = variabl1325;
String[] t2 = parameter[19].split(",");
String variabl13251 = "";
if (variabl1735.length() > 0) {
String[] t3 = variabl1735.split(",");
for (int i = 0; i < t3.length; i++) {
if (i > 0)
variabl13251 = variabl13251 + ","
+ t2[Integer.parseInt(t3[i])];
else
variabl13251 = t2[Integer.parseInt(t3[i])];
}
variabl1325 = variabl13251;
} else
variabl1325 = "*";
String variabl2429 = parameter[0];
variabl1873 = "";
String[] t1;
b = 0;
c = 0;
if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) {
t1 = variabl2429.split(",");
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0)
variabl1873 = t1[i];
}
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + variabl1325 + " from " + variabl2603;
rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
variabl2651 = rsmd4.getColumnCount();
variabl2517 = new String[2][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[0][i] = rsmd4.getColumnName(i + 1);
variabl2517[1][i] = variabl2517[0][i];
}
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
variabl2067 = 0;
for (int i = 0; i < variabl2651; i++) {
variabl1501[i] = rsmd4.getColumnTypeName(i + 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;
if (variabl1489[i] < 5)
variabl1489[i] = 5;
variabl2067 = variabl2067 + variabl1489[i];
}
variabl1853 = 0;
rs.last();
variabl1853 = rs.getRow();
variabl19191 = new String[variabl1853];
variabl2197 = new String[variabl1853][variabl2651];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
variabl19191[c] = "";
while (b < variabl2651) {
variabl2197[c][b] = rs.getString(b + 1);
if (b == 0)
variabl19191[c] = variabl2197[c][b];
else
variabl19191[c] = variabl19191[c] + ","
+ variabl2197[c][b];
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "a读取数据出错！" + s1);
}
try {
con1 = main1.getConn();
sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl2603;
rs = sta4.executeQuery(s1);
rsmd4 = rs.getMetaData();
variabl26512 = rsmd4.getColumnCount();
variabl25172 = new String[variabl26512];
variabl13250 = "";
variabl15012 = new String[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmd4.getColumnName(i + 1);
variabl15012[i] = rsmd4.getColumnTypeName(i + 1);
if (",image,".indexOf("," + variabl15012[i] + ",") < 0)
if (variabl13250.length() == 0)
variabl13250 = variabl25172[i];
else
variabl13250 = variabl13250 + "," + variabl25172[i];
}
variabl21972 = new String[variabl1853][variabl26512];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl26512) {
variabl21972[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta4.close();
con1.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "a读取数据出错！" + s1);
}
variabl19652 = new DefaultTableModel(variabl21972, variabl25172);
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 s4 = "";
String s5 = "";
b = 1;
while (rs.absolute(b)) {
b++;
s4 = rs.getString(1);
s5 = rs.getString(2);
for (int j = 0; j < variabl2651; j++) {
if (variabl2517[0][j].trim().equals(s4.trim())) {
variabl2517[1][j] = s5;
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);
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);
variabl2339 = (variabl2483 - 200) / variabl2851;
int variabl2337 = 150;
JButton variabl1223 = new JButton(variabl2405[0]);
variabl1223.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String mn = ",";
int k = 0;
try {
String variabl25111 = main1.variabl1545;
s1 = "delete from " + variabl2603;
con1 = main1.getConn();
sta4 = con1.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta4.executeUpdate(s1);
int n = 0;
String sk = "";
for (int i1 = 0; i1 < model.getRowCount(); i1++) {
s2 = "";
for (int j = 0; j < variabl2651; j++)
if (model.getValueAt(i1, j) != null)
s2 = s2 + model.getValueAt(i1, j).toString();
set1.add(s2);
if (set1.size() != n) {
n = set1.size();
s1 = "insert into " + variabl2603 + "("
+ variabl13250 + ") values (";
sk = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl25111.lastIndexOf(","
+ variabl15012[j] + ",") >= 0)
if (variabl19652.getValueAt(i1, j) != null)
if (sk.length() > 0)
sk = sk
+ ","
+ variabl19652.getValueAt(
i1, j);
else
sk = sk
+ ","
+ variabl19652.getValueAt(
i1, j);
else if (sk.length() > 0)
sk = sk + ",0";
else
sk = sk + "0";
else if ((main1.variabl1537 + main1.variabl1539)
.indexOf("," + variabl15012[j] + ",") < 0)
if (variabl19652.getValueAt(i1, j) != null)
if (sk.length() > 0)
sk = sk
+ ",'"
+ variabl19652.getValueAt(
i1, j) + "'";
else
sk = sk
+ "'"
+ variabl19652.getValueAt(
i1, j) + "'";
else if (sk.length() > 0)
sk = sk + ",' '";
else
sk = sk + "' '";
}
sk = sk + ")";
s1 = s1 + sk;
sta4.executeUpdate(s1);
} else {
variabl1527 = i1;
model.removeRow(i1);
}
}
sta4.close();
con1.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "操作出错，请录入语句是否正确！" + s1);
}
}
});
variabl1223.setBounds(variabl2337, variabl2503 - 90, variabl2339, 20);
if (variabl1187.indexOf(",0,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel.add(variabl1223);
}
JButton variabl2599 = new JButton(variabl2405[1]);
variabl2599.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
variabl2599.setBounds(variabl2337, variabl2503 - 90, variabl2339, 20);
if (variabl1187.indexOf(",1,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel.add(variabl2599);
}
frame.getContentPane().add(panel, null);
frame.setVisible(true);
frame.getContentPane().add(panel, BorderLayout.SOUTH);
}
}
63.源码63，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/*
* 程序文件名：dataStatistic6.java
* 作者：程学先
* 功能：求当前表中的在另一个表中没有的记录（求二个关系的差集），可以进一步删除与第二表相同的记录。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Vector;
public class dataStatistic6 extends JFrame {
private static ItemListener ItemListener = null;
private static dataStatistic6 frame1 = new dataStatistic6();
private static dataStatistic6 frame3 = new dataStatistic6();
private static JPanel panel1 = new JPanel();
private static JPanel panel3 = new JPanel();
private static DefaultTableModel variabl19651;
private static DefaultTableModel variabl19652;
private static DefaultTableModel variabl19653;
private static JTable variabl26551;
private static JTable variabl26552;
private static JTable variabl26553;
private static JScrollPane scrollPane1 = new JScrollPane();
private static JScrollPane scrollPane2 = new JScrollPane();
private static JScrollPane scrollPane3 = new JScrollPane();
private static String[][] variabl21971;
private static String[][] variabl21972;
private static String[][] variabl21973;
private static String variabl26031;
private static String variabl26032;
private static String variabl2025;
private static String variabl2429, variabl1153, variabl11530;
private static String[] variabl25171;
private static String[] variabl25172;
private static String[] variabl25173;
private static int variabl26511, variabl1605 = 8;
private static int variabl26512, variabl26513;
private static int c = 0, b = 0;
private static int variabl18231;
private static int variabl18232;
private static int variabl18531 = 0, variabl18532 = 0, variabl18533 = 0;
private static int variabl17391 = 0;
private static int variabl17392 = 0;
private static String[] variabl15011;
private static String[] variabl15012;
private static String[] variabl15013;
private static int[] variabl14891;
private static int[] variabl14892;
private static int[] variabl14893;
private static int variabl2187 = 0;
private static int variabl2017 = 0;
private static int variabl1803 = 0;
private static String[] variabl19191;
private static String[] variabl19192;
private static String[] variabl19193;
private static ArrayList list1 = new ArrayList();
private static Choice fa0 = new Choice();
private static HashSet set1 = new HashSet();
private static HashSet set2 = new HashSet();
static Connection con;
private static Statement sta3;
static Connection con2;
private static Statement sta5;
private static ResultSet rs;
static String s1 = "", s2 = "", s3 = "", s4 = "", variabl2327 = "";
private static ResultSetMetaData rsmd;
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2483 = 0, variabl2503 = 0, variabl2851 = 0,
variabl2339 = 0;
public static void means(String[] parameter) {
frame1 = new dataStatistic6();
frame3 = new dataStatistic6();
panel1 = new JPanel();
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
c = 0;
b = 0;
variabl18531 = 0;
variabl18532 = 0;
variabl18533 = 0;
variabl17391 = 0;
variabl17392 = 0;
list1 = new ArrayList();
fa0 = new Choice();
set1 = new HashSet();
set2 = new HashSet();
s1 = "";
s2 = "";
s3 = "";
s4 = "";
variabl2327 = "";
variabl2187 = 0;
variabl2017 = 0;
variabl1803 = 0;
String[] variabl240501 = { "表1减表2", "退出" };
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) {
}
variabl1605 = 15;
ItemListener = null;
frame1 = new dataStatistic6();
frame3 = new dataStatistic6();
panel1 = new JPanel();
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
variabl18531 = 0;
variabl18532 = 0;
variabl18533 = 0;
variabl2187 = 0;
variabl2017 = 0;
variabl1803 = 0;
list1 = new ArrayList();
fa0 = new Choice();
set1 = new HashSet();
set2 = new HashSet();
s1 = "";
s2 = "";
s3 = "";
s4 = "";
variabl2327 = "";
variabl26031 = parameter[4];
variabl26032 = parameter[2];
variabl2025 = parameter[5];
variabl2429 = parameter[0];
String variabl1325 = parameter[19];
String[] t2 = parameter[19].split(",");
variabl1153 = parameter[8];
variabl11530 = parameter[9];
String variabl13250 = "", variabl13251 = "";
String[] t3;
if (variabl1153.length() > 0) {
t3 = variabl1153.split(",");
for (int i = 0; i < t3.length; i++) {
if (i > 0)
variabl13250 = variabl13250 + ","
+ t2[Integer.parseInt(t3[i])];
else
variabl13250 = t2[Integer.parseInt(t3[i])];
}
variabl1325 = variabl13250;
} else {
variabl1153 = "";
for (int i = 0; i < t2.length; i++)
if (variabl1153.length() == 0)
variabl1153 = i + "";
else
variabl1153 = variabl1153 + "," + i;
}
main1.driver1();
frame1.setTitle("表1 作者：程学先");
frame3.setTitle("运算结果 ");
frame1.setBounds(10, 10, 1200, 600);
frame3.setBounds(200, 160, 1200, 500);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel1.setBounds(10, 10, 1200, 600);
panel3.setBounds(200, 10, 1200, 660);
panel1.setLayout(null);
panel3.setLayout(null);
if ((variabl26031 != null) && (variabl26031.length() > 0)) {
c = 0;
b = 0;
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + variabl1325 + " from " + variabl26031;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26511 = rsmd.getColumnCount();
variabl25171 = new String[variabl26511];
variabl15011 = new String[variabl26511];
variabl14891 = new int[variabl26511];
for (int i = 0; i < variabl26511; i++) {
variabl25171[i] = rsmd.getColumnName(i + 1);
variabl15011[i] = rsmd.getColumnTypeName(i + 1);
variabl14891[i] = rsmd.getColumnDisplaySize(i + 1);
if (variabl14891[i] < 5)
variabl14891[i] = 5;
variabl2187 = variabl2187 + variabl14891[i] * variabl1605;
}
rs.last();
variabl18531 = rs.getRow();
variabl19191 = new String[variabl18531];
variabl21971 = new String[variabl18531][variabl26511];
rs.absolute(1);
while (c < variabl18531) {
rs.absolute(c + 1);
variabl19191[c] = "";
while (b < variabl26511) {
variabl21971[c][b] = rs.getString(b + 1);
if (b == 0)
variabl19191[c] = variabl21971[c][b];
else
variabl19191[c] = variabl19191[c] + ","
+ variabl21971[c][b];
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表1失败！" + s1);
return;
}
scrollPane1.setBounds(20, 10, variabl2187, 450);
variabl19651 = new DefaultTableModel(variabl21971, variabl25171);
variabl26551 = new JTable(variabl19651);
variabl26551.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(variabl26551, null);
for (int i = 0; i < variabl26511; i++) {
TableColumn tc = variabl26551.getColumn(variabl25171[i]);
tc.setPreferredWidth(variabl14891[i] * variabl1605);
}
panel1.add(scrollPane1);
variabl26551.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl18231 = variabl26551.rowAtPoint(e.getPoint());
variabl17391 = variabl26551.columnAtPoint(e.getPoint());
}
}
});
}
if ((variabl26032 != null) && (variabl26032.length() > 0)) {
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl26032;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26512 = rsmd.getColumnCount();
variabl25172 = new String[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmd.getColumnName(i + 1);
}
if (variabl11530.length() > 0) {
t3 = variabl11530.split(",");
variabl13251 = "";
for (int i = 0; i < t3.length; i++) {
if (i > 0)
variabl13251 = variabl13251 + ","
+ variabl25172[Integer.parseInt(t3[i])];
else
variabl13251 = variabl25172[Integer.parseInt(t3[i])];
}
variabl13250 = variabl13251;
} else
variabl13250 = " * ";
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表2失败！" + s1);
return;
}
c = 0;
b = 0;
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + variabl13250 + " from " + variabl26032;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26512 = rsmd.getColumnCount();
variabl25172 = new String[variabl26512];
variabl15012 = new String[variabl26512];
variabl14892 = new int[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmd.getColumnName(i + 1);
variabl15012[i] = rsmd.getColumnTypeName(i + 1);
variabl14892[i] = rsmd.getColumnDisplaySize(i + 1);
if (variabl14892[i] < 5)
variabl14892[i] = 5;
variabl2017 = variabl2017 + variabl14892[i] * variabl1605;
}
rs.last();
variabl18532 = rs.getRow();
variabl19192 = new String[variabl18532];
variabl21972 = new String[variabl18532][variabl26512];
rs.absolute(1);
while (c < variabl18532) {
rs.absolute(c + 1);
variabl19192[c] = "";
while (b < variabl26512) {
variabl21972[c][b] = rs.getString(b + 1);
if (b == 0)
variabl19192[c] = variabl21972[c][b];
else
variabl19192[c] = variabl19192[c] + ","
+ variabl21972[c][b];
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, " 读取表2失败！ " + s1);
return;
}
variabl19652 = new DefaultTableModel(variabl21972, variabl25172);
variabl26552 = new JTable(variabl19652);
variabl26552.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl26552.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(variabl26552, null);
scrollPane2.setBounds(variabl2187 + 40, 10, variabl2017, 450);
for (int i = 0; i < variabl26512; i++) {
TableColumn tc = variabl26552.getColumn(variabl25172[i]);
tc.setPreferredWidth(variabl14892[i] * variabl1605);
}
panel1.add(scrollPane2);
variabl26552.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl18232 = variabl26552.rowAtPoint(e.getPoint());
variabl17392 = variabl26552.columnAtPoint(e.getPoint());
}
}
});
}
variabl2339 = (variabl2483 - 200) / variabl2851;
int variabl2337 = 150;
final JButton variabl1449 = new JButton(variabl2405[0]);
variabl1449.setBounds(variabl2337, 500, variabl2339, 20);
if (variabl1187.indexOf(",0,") >= 0)
variabl2337 = variabl2337 + variabl2339;
variabl1449.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1803 = variabl2187;
int variabl1391 = 0;
set1.clear();
if (variabl26511 != variabl26512) {
JOptionPane.showMessageDialog(null, "二表列数不相等，不能求差集！" + s1);
return;
}
variabl26513 = variabl26511;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl15013 = new String[variabl26513];
variabl21973 = new String[variabl19192.length][variabl26511];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl14893[j] = variabl14891[j];
}
String[] t4;
b = 0;
m: for (int i = 0; i < variabl19191.length; i++) {
for (int j = 0; j < variabl19192.length; j++)
if (variabl19191[i].equals(variabl19192[j]))
continue m;
t4 = variabl19191[i].split(",");
for (int k = 0; k < variabl26511; k++)
variabl21973[b][k] = t4[k];
b++;
}
variabl19653 = new DefaultTableModel(variabl21973, variabl25171);
scrollPane3.setBounds(20, 60, variabl1803 * 4, 450);
variabl26553 = new JTable(variabl19653);
variabl26553.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(variabl26553, null);
for (int i = 0; i < variabl26513; i++) {
TableColumn tc = variabl26553.getColumn(variabl25173[i]);
tc.setPreferredWidth(variabl14893[i] * variabl1605);
}
panel3.add(scrollPane3);
frame3.setVisible(true);
}
});
if (variabl1187.indexOf(",0,") >= 0)
panel1.add(variabl1449);
final JButton variabl25991 = new JButton(variabl2405[1]);
variabl25991.setBounds(variabl2337, 500, variabl2339, 20);
if (variabl1187.indexOf(",0,") >= 0)
variabl2337 = variabl2337 + variabl2339;
variabl25991.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (variabl1187.indexOf(",1,") >= 0)
panel1.add(variabl25991);
final JButton variabl25993 = new JButton(variabl2405[1]);
variabl25993.setBounds(1000, 400, 120, 20);
variabl25993.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
panel3.add(variabl25993);
frame3.add(panel3);
frame1.add(panel1);
frame3.setVisible(true);
frame1.setVisible(true);
}
public static void createNew() {
String variabl25111 = main1.variabl1545;
if ((variabl2025 != null) && (variabl2025.length() > 0)) {
if (("," + variabl2429).lastIndexOf("," + variabl2025 + ",") < 0) {
try {
s1 = "CREATE TABLE " + variabl2025 + " (";
for (int i = 0; i < variabl25173.length; i++) {
s1 = s1 + variabl25173[i] + " " + variabl15013[i];
if (main1.variabl2511.lastIndexOf("," + variabl15013[i]
+ ",") >= 0)
s1 = s1 + "(" + variabl14893[i] + ")";
if (i != variabl25173.length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s1);
sta3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "建表失败！" + s1);
}
} else {
try {
s1 = "delete from " + variabl2025;
con = main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
sta3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "删除操作失败！" + s1);
}
}
try {
con2 = main1.getConn();
sta5 = con2.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s3 = "";
for (int j = 0; j < variabl26513; j++)
if (j < variabl26513 - 1)
s3 = s3 + variabl25173[j] + ",";
else
s3 = s3 + variabl25173[j];
int n = 0;
for (int i1 = 0; i1 < variabl19653.getRowCount(); i1++) {
s2 = "";
for (int j = 0; j < variabl26513; j++)
if (variabl19653.getValueAt(i1, j) != null)
s2 = s2 + variabl19653.getValueAt(i1, j).toString();
s1 = "insert into " + variabl2025 + " (" + s3
+ ") values (";
for (int j = 0; j < variabl26513; j++) {
if (variabl25111.lastIndexOf("," + variabl15013[j]
+ ",") >= 0)
if (variabl19653.getValueAt(i1, j) != null)
if (j < variabl26513 - 1)
s1 = s1 + variabl19653.getValueAt(i1, j)
+ ",";
else
s1 = s1 + variabl19653.getValueAt(i1, j);
else if (j < variabl26513 - 1)
s1 = s1 + "0,";
else
s1 = s1 + "0";
else if (variabl19653.getValueAt(i1, j) != null)
if (j < variabl26513 - 1)
s1 = s1 + "'" + variabl19653.getValueAt(i1, j)
+ "',";
else
s1 = s1 + "'" + variabl19653.getValueAt(i1, j)
+ "'";
else if (j < variabl26513 - 1)
s1 = s1 + "' ',";
else
s1 = s1 + "' '";
}
s1 = s1 + ")";
sta5.executeUpdate(s1);
}
sta5.close();
con2.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "操作出错，请查看录入语句是否正确！" + s1);
}
}
}
}
64.源码64，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/*
* 程序文件名：dataStatistic6.java
* 作者：程学先
* 功能：求将二个表的数据合并到一个表中（求二个关系的并集）。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Vector;
public class dataStatistic7 extends JFrame {
private static ItemListener ItemListener = null;
private static dataStatistic7 frame1 = new dataStatistic7();
private static dataStatistic7 frame3 = new dataStatistic7();
private static JPanel panel1 = new JPanel();
private static JPanel panel3 = new JPanel();
private static DefaultTableModel variabl19651;
private static DefaultTableModel variabl19652;
private static DefaultTableModel variabl19653;
private static JTable variabl26551;
private static JTable variabl26552;
private static JTable variabl26553;
private static JScrollPane scrollPane1 = new JScrollPane();
private static JScrollPane scrollPane2 = new JScrollPane();
private static JScrollPane scrollPane3 = new JScrollPane();
private static String[][] variabl21971;
private static String[][] variabl21972;
private static String[][] variabl21973;
private static String variabl26031;
private static String variabl26032;
private static String variabl2025;
private static String variabl2429, variabl1153, variabl11530;
private static String[] variabl25171;
private static String[] variabl25172;
private static String[] variabl25173;
private static int variabl26511, variabl1605 = 8;
private static int variabl26512, variabl26513;
private static int c = 0, b = 0;
private static int variabl18231;
private static int variabl18232;
private static int variabl18531 = 0, variabl18532 = 0, variabl18533 = 0;
private static int variabl17391 = 0;
private static int variabl17392 = 0;
private static String[] variabl15011;
private static String[] variabl15012;
private static String[] variabl15013;
private static int[] variabl14891;
private static int[] variabl14892;
private static int[] variabl14893;
private static int variabl2187 = 0;
private static int variabl2017 = 0;
private static int variabl1803 = 0;
private static String[] variabl19191;
private static String[] variabl19192;
private static String[] variabl19193;
private static ArrayList list1 = new ArrayList();
private static Choice fa0 = new Choice();
private static HashSet set1 = new HashSet();
private static HashSet set2 = new HashSet();
static Connection con;
private static Statement sta3;
static Connection con2;
private static Statement sta5;
private static ResultSet rs;
static String s1 = "", s2 = "", s3 = "", s4 = "", variabl2327 = "";
private static ResultSetMetaData rsmd;
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2483 = 0, variabl2503 = 0, variabl2851 = 0,
variabl2339 = 0;
public static void means(String[] parameter) {
frame1 = new dataStatistic7();
frame3 = new dataStatistic7();
panel1 = new JPanel();
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
c = 0;
b = 0;
variabl18531 = 0;
variabl18532 = 0;
variabl18533 = 0;
variabl17391 = 0;
variabl17392 = 0;
list1 = new ArrayList();
fa0 = new Choice();
set1 = new HashSet();
set2 = new HashSet();
s1 = "";
s2 = "";
s3 = "";
s4 = "";
variabl2327 = "";
variabl2187 = 0;
variabl2017 = 0;
variabl1803 = 0;
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) {
}
variabl1605 = 15;
ItemListener = null;
frame1 = new dataStatistic7();
frame3 = new dataStatistic7();
panel1 = new JPanel();
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
variabl18531 = 0;
variabl18532 = 0;
variabl18533 = 0;
variabl2187 = 0;
variabl2017 = 0;
variabl1803 = 0;
list1 = new ArrayList();
fa0 = new Choice();
set1 = new HashSet();
set2 = new HashSet();
s1 = "";
s2 = "";
s3 = "";
s4 = "";
variabl2327 = "";
variabl26031 = parameter[4];
variabl26032 = parameter[2];
variabl2429 = parameter[0];
variabl2025 = parameter[5];
String variabl1325 = parameter[19];
String[] t2 = parameter[19].split(",");
variabl1153 = parameter[8];
variabl11530 = parameter[9];
String variabl13250 = "", variabl13251 = "";
String[] t3;
if (variabl1153.length() > 0) {
t3 = variabl1153.split(",");
for (int i = 0; i < t3.length; i++) {
if (i > 0)
variabl13250 = variabl13250 + ","
+ t2[Integer.parseInt(t3[i])];
else
variabl13250 = t2[Integer.parseInt(t3[i])];
}
variabl1325 = variabl13250;
}
variabl1153 = parameter[8];
variabl11530 = parameter[9];
main1.driver1();
frame1.setTitle("表1 作者：程学先");
frame3.setTitle("运算结果 作者：程学先");
frame1.setBounds(10, 10, 1200, 600);
frame3.setBounds(200, 160, 1200, 560);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel1.setBounds(10, 10, 1200, 600);
panel3.setBounds(200, 10, 1200, 660);
panel1.setLayout(null);
panel3.setLayout(null);
if ((variabl26031 != null) && (variabl26031.length() > 0)) {
c = 0;
b = 0;
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + variabl1325 + " from " + variabl26031;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26511 = rsmd.getColumnCount();
variabl25171 = new String[variabl26511];
variabl15011 = new String[variabl26511];
variabl14891 = new int[variabl26511];
for (int i = 0; i < variabl26511; i++) {
variabl25171[i] = rsmd.getColumnName(i + 1);
variabl15011[i] = rsmd.getColumnTypeName(i + 1);
variabl14891[i] = rsmd.getColumnDisplaySize(i + 1);
if (variabl14891[i] < 5)
variabl14891[i] = 5;
variabl2187 = variabl2187 + variabl14891[i] * variabl1605;
}
rs.last();
variabl18531 = rs.getRow();
variabl19191 = new String[variabl18531];
variabl21971 = new String[variabl18531][variabl26511];
rs.absolute(1);
while (c < variabl18531) {
rs.absolute(c + 1);
variabl19191[c] = "";
while (b < variabl26511) {
variabl21971[c][b] = rs.getString(b + 1);
if (b == 0)
variabl19191[c] = variabl21971[c][b];
else
variabl19191[c] = variabl19191[c] + ","
+ variabl21971[c][b];
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表1失败！" + s1);
return;
}
scrollPane1.setBounds(20, 10, variabl2187, 450);
variabl19651 = new DefaultTableModel(variabl21971, variabl25171);
variabl26551 = new JTable(variabl19651);
variabl26551.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(variabl26551, null);
for (int i = 0; i < variabl26511; i++) {
TableColumn tc = variabl26551.getColumn(variabl25171[i]);
tc.setPreferredWidth(variabl14891[i] * variabl1605);
}
panel1.add(scrollPane1);
variabl26551.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl18231 = variabl26551.rowAtPoint(e.getPoint());
variabl17391 = variabl26551.columnAtPoint(e.getPoint());
}
}
});
}
if ((variabl26032 != null) && (variabl26032.length() > 0)) {
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl26032;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26512 = rsmd.getColumnCount();
variabl25172 = new String[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmd.getColumnName(i + 1);
}
if (variabl11530.length() > 0) {
t3 = variabl11530.split(",");
variabl13251 = "";
for (int i = 0; i < t3.length; i++) {
if (i > 0)
variabl13251 = variabl13251 + ","
+ variabl25172[Integer.parseInt(t3[i])];
else
variabl13251 = variabl25172[Integer.parseInt(t3[i])];
}
variabl13250 = variabl13251;
} else
variabl13250 = " * ";
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表2失败！" + s1);
return;
}
c = 0;
b = 0;
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + variabl13250 + " from " + variabl26032;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26512 = rsmd.getColumnCount();
variabl25172 = new String[variabl26512];
variabl15012 = new String[variabl26512];
variabl14892 = new int[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmd.getColumnName(i + 1);
variabl15012[i] = rsmd.getColumnTypeName(i + 1);
variabl14892[i] = rsmd.getColumnDisplaySize(i + 1);
if (variabl14892[i] < 5)
variabl14892[i] = 5;
variabl2017 = variabl2017 + variabl14892[i] * variabl1605;
}
rs.last();
variabl18532 = rs.getRow();
variabl19192 = new String[variabl18532];
variabl21972 = new String[variabl18532][variabl26512];
rs.absolute(1);
while (c < variabl18532) {
rs.absolute(c + 1);
variabl19192[c] = "";
while (b < variabl26512) {
variabl21972[c][b] = rs.getString(b + 1);
if (b == 0)
variabl19192[c] = variabl21972[c][b];
else
variabl19192[c] = variabl19192[c] + ","
+ variabl21972[c][b];
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, " 读取表2失败！ " + s1);
return;
}
variabl19652 = new DefaultTableModel(variabl21972, variabl25172);
variabl26552 = new JTable(variabl19652);
variabl26552.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl26552.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(variabl26552, null);
scrollPane2.setBounds(variabl2187 + 40, 10, variabl2017, 450);
for (int i = 0; i < variabl26512; i++) {
TableColumn tc = variabl26552.getColumn(variabl25172[i]);
tc.setPreferredWidth(variabl14892[i] * variabl1605);
}
panel1.add(scrollPane2);
variabl26552.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl18232 = variabl26552.rowAtPoint(e.getPoint());
variabl17392 = variabl26552.columnAtPoint(e.getPoint());
}
}
});
}
variabl2339 = (variabl2483 - 200) / variabl2851;
int variabl2337 = 150;
final JButton variabl2285 = new JButton(variabl2405[0]);
variabl2285.setBounds(variabl2337, 500, variabl2339, 20);
if (variabl1187.indexOf(",0,") >= 0)
variabl2337 = variabl2337 + variabl2339;
variabl2285.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1803 = variabl2187;
int variabl1391 = 0;
if (variabl26511 != variabl26512) {
JOptionPane.showMessageDialog(null, "二表列数不相等，不能求并集！" + s1);
return;
}
variabl26513 = variabl26511;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl15013 = new String[variabl26513];
variabl21973 = new String[variabl19192.length
+ variabl19192.length][variabl26511];
for (int j = 0; j < variabl26511; j++) {
variabl25173[j] = variabl25171[j];
variabl14893[j] = variabl14891[j];
variabl15013[j] = variabl15011[j];
}
String[] t4;
b = 0;
for (int i = 0; i < variabl19191.length; i++) {
t4 = variabl19191[i].split(",");
for (int k = 0; k < variabl26511; k++)
variabl21973[b][k] = t4[k];
b++;
}
m: for (int j = 0; j < variabl19192.length; j++) {
for (int i = 0; i < variabl19191.length; i++)
if (variabl19191[i].equals(variabl19192[j]))
continue m;
t4 = variabl19192[j].split(",");
for (int k = 0; k < variabl26511; k++)
variabl21973[b][k] = t4[k];
b++;
}
variabl19653 = new DefaultTableModel(variabl21973, variabl25171);
scrollPane3.setBounds(20, 60, variabl1803 * 4, 450);
variabl26553 = new JTable(variabl19653);
variabl26553.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(variabl26553, null);
for (int i = 0; i < variabl26513; i++) {
TableColumn tc = variabl26553.getColumn(variabl25173[i]);
tc.setPreferredWidth(variabl14893[i] * variabl1605);
}
panel3.add(scrollPane3);
frame3.setVisible(true);
}
});
if (variabl1187.indexOf(",0,") >= 0)
panel1.add(variabl2285);
final JButton variabl25991 = new JButton(variabl2405[1]);
variabl25991.setBounds(variabl2337, 500, variabl2339, 20);
if (variabl1187.indexOf(",0,") >= 0)
variabl2337 = variabl2337 + variabl2339;
variabl25991.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (variabl1187.indexOf(",1,") >= 0)
panel1.add(variabl25991);
final JButton variabl25993 = new JButton(variabl2405[1]);
variabl25993.setBounds(1000, 400, 120, 20);
variabl25993.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
panel3.add(variabl25993);
frame3.add(panel3);
frame1.add(panel1);
frame3.setVisible(true);
frame1.setVisible(true);
}
public static void createNew() {
String variabl25111 = main1.variabl1545;
if ((variabl2025 != null) && (variabl2025.length() > 0)) {
if (("," + variabl2429).lastIndexOf("," + variabl2025 + ",") < 0) {
try {
s1 = "CREATE TABLE " + variabl2025 + " (";
for (int i = 0; i < variabl25173.length; i++) {
s1 = s1 + variabl25173[i] + " " + variabl15013[i];
if (main1.variabl2511.lastIndexOf("," + variabl15013[i]
+ ",") >= 0)
s1 = s1 + "(" + variabl14893[i] + ")";
if (i != variabl25173.length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s1);
sta3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "建表失败！" + s1);
}
} else {
try {
s1 = "delete from " + variabl2025;
con = main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
sta3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "删除操作失败！" + s1);
}
}
try {
con2 = main1.getConn();
sta5 = con2.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s3 = "";
for (int j = 0; j < variabl26513; j++)
if (j < variabl26513 - 1)
s3 = s3 + variabl25173[j] + ",";
else
s3 = s3 + variabl25173[j];
int n = 0;
for (int i1 = 0; i1 < variabl19653.getRowCount(); i1++) {
s2 = "";
for (int j = 0; j < variabl26513; j++)
if (variabl19653.getValueAt(i1, j) != null)
s2 = s2 + variabl19653.getValueAt(i1, j).toString();
s1 = "insert into " + variabl2025 + " (" + s3
+ ") values (";
for (int j = 0; j < variabl26513; j++) {
if (variabl25111.lastIndexOf("," + variabl15013[j]
+ ",") >= 0)
if (variabl19653.getValueAt(i1, j) != null)
if (j < variabl26513 - 1)
s1 = s1 + variabl19653.getValueAt(i1, j)
+ ",";
else
s1 = s1 + variabl19653.getValueAt(i1, j);
else if (j < variabl26513 - 1)
s1 = s1 + "0,";
else
s1 = s1 + "0";
else if (variabl19653.getValueAt(i1, j) != null)
if (j < variabl26513 - 1)
s1 = s1 + "'" + variabl19653.getValueAt(i1, j)
+ "',";
else
s1 = s1 + "'" + variabl19653.getValueAt(i1, j)
+ "'";
else if (j < variabl26513 - 1)
s1 = s1 + "' ',";
else
s1 = s1 + "' '";
}
s1 = s1 + ")";
sta5.executeUpdate(s1);
}
sta5.close();
con2.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "操作出错，请查看录入语句是否正确！" + s1);
}
}
}
}
65.源码66，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/*
* 程序文件名：dataStatistic6.java
* 作者：程学先
* 功能：求二个表共同都有的记录（求二个关系的交集）。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Vector;
public class dataStatistic8 extends JFrame {
private static ItemListener ItemListener = null;
private static dataStatistic8 frame1 = new dataStatistic8();
private static dataStatistic8 frame3 = new dataStatistic8();
private static JPanel panel1 = new JPanel();
private static JPanel panel3 = new JPanel();
private static DefaultTableModel variabl19651;
private static DefaultTableModel variabl19652;
private static DefaultTableModel variabl19653;
private static JTable variabl26551;
private static JTable variabl26552;
private static JTable variabl26553;
private static JScrollPane scrollPane1 = new JScrollPane();
private static JScrollPane scrollPane2 = new JScrollPane();
private static JScrollPane scrollPane3 = new JScrollPane();
private static String[][] variabl21971;
private static String[][] variabl21972;
private static String[][] variabl21973;
private static String variabl26031;
private static String variabl26032;
private static String variabl2025;
private static String variabl2429, variabl1153, variabl11530;
private static String[] variabl25171;
private static String[] variabl25172;
private static String[] variabl25173;
private static int variabl26511, variabl1605 = 8;
private static int variabl26512, variabl26513;
private static int c = 0, b = 0;
private static int variabl18231;
private static int variabl18232;
private static int variabl18531 = 0, variabl18532 = 0, variabl18533 = 0;
private static int variabl17391 = 0;
private static int variabl17392 = 0;
private static String[] variabl15011;
private static String[] variabl15012;
private static String[] variabl15013;
private static int[] variabl14891;
private static int[] variabl14892;
private static int[] variabl14893;
private static int variabl2187 = 0;
private static int variabl2017 = 0;
private static int variabl1803 = 0;
private static String[] variabl19191;
private static String[] variabl19192;
private static String[] variabl19193;
private static ArrayList list1 = new ArrayList();
private static Choice fa0 = new Choice();
private static HashSet set1 = new HashSet();
private static HashSet set2 = new HashSet();
static Connection con;
static Connection con2;
private static Statement sta5;
private static Statement sta3;
private static ResultSet rs;
static String s1 = "", s2 = "", s3 = "", s4 = "", variabl2327 = "";
private static ResultSetMetaData rsmd;
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2483 = 0, variabl2503 = 0, variabl2851 = 0,
variabl2339 = 0;
public static void means(String[] parameter) {
frame1 = new dataStatistic8();
frame3 = new dataStatistic8();
panel1 = new JPanel();
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
c = 0;
b = 0;
variabl1605 = 8;
variabl18531 = 0;
variabl18532 = 0;
variabl18533 = 0;
variabl17391 = 0;
variabl17392 = 0;
list1 = new ArrayList();
fa0 = new Choice();
set1 = new HashSet();
set2 = new HashSet();
s1 = "";
s2 = "";
s3 = "";
s4 = "";
variabl2327 = "";
variabl2187 = 0;
variabl2017 = 0;
variabl1803 = 0;
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) {
}
variabl1605 = 15;
ItemListener = null;
frame1 = new dataStatistic8();
frame3 = new dataStatistic8();
panel1 = new JPanel();
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
variabl18531 = 0;
variabl18532 = 0;
variabl18533 = 0;
variabl2187 = 0;
variabl2017 = 0;
variabl1803 = 0;
list1 = new ArrayList();
fa0 = new Choice();
set1 = new HashSet();
set2 = new HashSet();
s1 = "";
s2 = "";
s3 = "";
s4 = "";
variabl2327 = "";
variabl26031 = parameter[4];
variabl26032 = parameter[2];
variabl2025 = parameter[5];
variabl2429 = parameter[0];
main1.driver1();
String variabl1325 = parameter[19];
String[] t2 = parameter[19].split(",");
variabl1153 = parameter[8];
variabl11530 = parameter[9];
String variabl13250 = "", variabl13251 = "";
String[] t3;
if (variabl1153.length() > 0) {
t3 = variabl1153.split(",");
for (int i = 0; i < t3.length; i++) {
if (i > 0)
variabl13250 = variabl13250 + ","
+ t2[Integer.parseInt(t3[i])];
else
variabl13250 = t2[Integer.parseInt(t3[i])];
}
variabl1325 = variabl13250;
}
frame1.setTitle("表1 作者：程学先");
frame3.setTitle("运算结果 ");
frame1.setBounds(10, 10, 1200, 600);
frame3.setBounds(200, 160, 1200, 500);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel1.setBounds(10, 10, 1200, 600);
panel3.setBounds(200, 10, 1200, 660);
panel1.setLayout(null);
panel3.setLayout(null);
if ((variabl26031 != null) && (variabl26031.length() > 0)) {
c = 0;
b = 0;
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + variabl1325 + " from " + variabl26031;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26511 = rsmd.getColumnCount();
variabl25171 = new String[variabl26511];
variabl15011 = new String[variabl26511];
variabl14891 = new int[variabl26511];
for (int i = 0; i < variabl26511; i++) {
variabl25171[i] = rsmd.getColumnName(i + 1);
variabl15011[i] = rsmd.getColumnTypeName(i + 1);
variabl14891[i] = rsmd.getColumnDisplaySize(i + 1);
if (variabl14891[i] < 5)
variabl14891[i] = 5;
variabl2187 = variabl2187 + variabl14891[i] * variabl1605;
}
rs.last();
variabl18531 = rs.getRow();
variabl19191 = new String[variabl18531];
variabl21971 = new String[variabl18531][variabl26511];
rs.absolute(1);
while (c < variabl18531) {
rs.absolute(c + 1);
variabl19191[c] = "";
while (b < variabl26511) {
variabl21971[c][b] = rs.getString(b + 1);
if (b == 0)
variabl19191[c] = variabl21971[c][b];
else
variabl19191[c] = variabl19191[c] + ","
+ variabl21971[c][b];
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表1失败！" + s1);
return;
}
scrollPane1.setBounds(20, 10, variabl2187, 450);
variabl19651 = new DefaultTableModel(variabl21971, variabl25171);
variabl26551 = new JTable(variabl19651);
variabl26551.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(variabl26551, null);
for (int i = 0; i < variabl26511; i++) {
TableColumn tc = variabl26551.getColumn(variabl25171[i]);
tc.setPreferredWidth(variabl14891[i] * variabl1605);
}
panel1.add(scrollPane1);
variabl26551.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl18231 = variabl26551.rowAtPoint(e.getPoint());
variabl17391 = variabl26551.columnAtPoint(e.getPoint());
}
}
});
}
if ((variabl26032 != null) && (variabl26032.length() > 0)) {
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl26032;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26512 = rsmd.getColumnCount();
variabl25172 = new String[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmd.getColumnName(i + 1);
}
if (variabl11530.length() > 0) {
t3 = variabl11530.split(",");
variabl13251 = "";
for (int i = 0; i < t3.length; i++) {
if (i > 0)
variabl13251 = variabl13251 + ","
+ variabl25172[Integer.parseInt(t3[i])];
else
variabl13251 = variabl25172[Integer.parseInt(t3[i])];
}
variabl13250 = variabl13251;
} else
variabl13250 = " * ";
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表2失败！" + s1);
return;
}
c = 0;
b = 0;
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + variabl13250 + " from " + variabl26032;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26512 = rsmd.getColumnCount();
variabl25172 = new String[variabl26512];
variabl15012 = new String[variabl26512];
variabl14892 = new int[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmd.getColumnName(i + 1);
variabl15012[i] = rsmd.getColumnTypeName(i + 1);
variabl14892[i] = rsmd.getColumnDisplaySize(i + 1);
if (variabl14892[i] < 5)
variabl14892[i] = 5;
variabl2017 = variabl2017 + variabl14892[i] * variabl1605;
}
rs.last();
variabl18532 = rs.getRow();
variabl19192 = new String[variabl18532];
variabl21972 = new String[variabl18532][variabl26512];
rs.absolute(1);
while (c < variabl18532) {
rs.absolute(c + 1);
variabl19192[c] = "";
while (b < variabl26512) {
variabl21972[c][b] = rs.getString(b + 1);
if (b == 0)
variabl19192[c] = variabl21972[c][b];
else
variabl19192[c] = variabl19192[c] + ","
+ variabl21972[c][b];
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, " 读取表2失败！ " + s1);
return;
}
variabl19652 = new DefaultTableModel(variabl21972, variabl25172);
variabl26552 = new JTable(variabl19652);
variabl26552.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl26552.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(variabl26552, null);
scrollPane2.setBounds(variabl2187 + 40, 10, variabl2017, 450);
for (int i = 0; i < variabl26512; i++) {
TableColumn tc = variabl26552.getColumn(variabl25172[i]);
tc.setPreferredWidth(variabl14892[i] * variabl1605);
}
panel1.add(scrollPane2);
variabl26552.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl18232 = variabl26552.rowAtPoint(e.getPoint());
variabl17392 = variabl26552.columnAtPoint(e.getPoint());
}
}
});
}
variabl2339 = (variabl2483 - 200) / variabl2851;
int variabl2337 = 150;
final JButton variabl2287 = new JButton(variabl2405[0]);
variabl2287.setBounds(variabl2337, 500, variabl2339, 20);
if (variabl1187.indexOf(",0,") >= 0)
variabl2337 = variabl2337 + variabl2339;
variabl2287.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1803 = variabl2187;
int variabl1391 = 0;
set1.clear();
if (variabl26511 != variabl26512) {
JOptionPane.showMessageDialog(null, "二表列数不相等，不能求交集！" + s1);
return;
}
variabl26513 = variabl26511;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl15013 = new String[variabl26513];
variabl21973 = new String[variabl19192.length][variabl26511];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl14893[j] = variabl14891[j];
}
String[] t4;
b = 0;
for (int i = 0; i < variabl19191.length; i++) {
for (int j = 0; j < variabl19192.length; j++)
if (variabl19191[i].equals(variabl19192[j])) {
t4 = variabl19191[i].split(",");
for (int k = 0; k < variabl26511; k++)
variabl21973[b][k] = t4[k];
b++;
break;
}
}
variabl19653 = new DefaultTableModel(variabl21973, variabl25171);
scrollPane3.setBounds(20, 60, variabl1803 * 4, 450);
variabl26553 = new JTable(variabl19653);
variabl26553.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(variabl26553, null);
for (int i = 0; i < variabl26513; i++) {
TableColumn tc = variabl26553.getColumn(variabl25173[i]);
tc.setPreferredWidth(variabl14893[i] * variabl1605);
}
panel3.add(scrollPane3);
frame3.setVisible(true);
}
});
if (variabl1187.indexOf(",0,") >= 0)
panel1.add(variabl2287);
final JButton variabl25991 = new JButton(variabl2405[1]);
variabl25991.setBounds(variabl2337, 500, variabl2339, 20);
if (variabl1187.indexOf(",1,") >= 0)
variabl2337 = variabl2337 + variabl2339;
variabl25991.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (variabl1187.indexOf(",1,") >= 0)
panel1.add(variabl25991);
final JButton variabl25993 = new JButton(variabl2405[1]);
variabl25993.setBounds(1000, 400, 120, 20);
variabl25993.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
panel3.add(variabl25993);
frame3.add(panel3);
frame1.add(panel1);
frame3.setVisible(true);
frame1.setVisible(true);
}
public static void createNew() {
String variabl25111 = main1.variabl1545;
if ((variabl2025 != null) && (variabl2025.length() > 0)) {
if (("," + variabl2429).lastIndexOf("," + variabl2025 + ",") < 0) {
try {
s1 = "CREATE TABLE " + variabl2025 + " (";
for (int i = 0; i < variabl25173.length; i++) {
s1 = s1 + variabl25173[i] + " " + variabl15013[i];
if (main1.variabl2511.lastIndexOf("," + variabl15013[i]
+ ",") >= 0)
s1 = s1 + "(" + variabl14893[i] + ")";
if (i != variabl25173.length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s1);
sta3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "建表失败！" + s1);
}
} else {
try {
s1 = "delete from " + variabl2025;
con = main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
sta3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "删除操作失败！" + s1);
}
}
try {
con2 = main1.getConn();
sta5 = con2.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s3 = "";
for (int j = 0; j < variabl26513; j++)
if (j < variabl26513 - 1)
s3 = s3 + variabl25173[j] + ",";
else
s3 = s3 + variabl25173[j];
int n = 0;
for (int i1 = 0; i1 < variabl19653.getRowCount(); i1++) {
s2 = "";
for (int j = 0; j < variabl26513; j++)
if (variabl19653.getValueAt(i1, j) != null)
s2 = s2 + variabl19653.getValueAt(i1, j).toString();
s1 = "insert into " + variabl2025 + " (" + s3
+ ") values (";
for (int j = 0; j < variabl26513; j++) {
if (variabl25111.lastIndexOf("," + variabl15013[j]
+ ",") >= 0)
if (variabl19653.getValueAt(i1, j) != null)
if (j < variabl26513 - 1)
s1 = s1 + variabl19653.getValueAt(i1, j)
+ ",";
else
s1 = s1 + variabl19653.getValueAt(i1, j);
else if (j < variabl26513 - 1)
s1 = s1 + "0,";
else
s1 = s1 + "0";
else if (variabl19653.getValueAt(i1, j) != null)
if (j < variabl26513 - 1)
s1 = s1 + "'" + variabl19653.getValueAt(i1, j)
+ "',";
else
s1 = s1 + "'" + variabl19653.getValueAt(i1, j)
+ "'";
else if (j < variabl26513 - 1)
s1 = s1 + "' ',";
else
s1 = s1 + "' '";
}
s1 = s1 + ")";
sta5.executeUpdate(s1);
}
sta5.close();
con2.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "操作出错，请查看录入语句是否正确！" + s1);
}
}
}
}
66.源码66，部件程序，横向计算程序。对数据表每条记录中有关字段中的数据进行变换或计算，将结果放到某一列中。
/*
* 程序文件名：dataStatistic6.java
* 作者：程学先
* 功能：按某个字段分组，求完全包含有第二个表的数据的那些组（求二个关系相除的商）。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.io.*;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Vector;
public class dataStatistic9 extends JFrame {
private static ItemListener ItemListener = null;
private static dataStatistic9 frame1 = new dataStatistic9();
private static dataStatistic9 frame3 = new dataStatistic9();
private static JPanel panel1 = new JPanel();
private static JPanel panel3 = new JPanel();
private static DefaultTableModel variabl19651;
private static DefaultTableModel variabl19652;
private static DefaultTableModel variabl19653;
private static JTable variabl26551;
private static JTable variabl26552;
private static JTable variabl26553;
private static JScrollPane scrollPane1 = new JScrollPane();
private static JScrollPane scrollPane2 = new JScrollPane();
private static JScrollPane scrollPane3 = new JScrollPane();
private static String[][] variabl21971;
private static String[][] variabl21972;
private static String[][] variabl21973;
private static String variabl26031;
private static String variabl26032;
private static String variabl2025;
private static String variabl2429, variabl1153, variabl11530;
private static String[] variabl25171;
private static String[] variabl25172;
private static String[] variabl25173;
private static int variabl26511, variabl1605 = 8;
private static int variabl26512, variabl26513;
private static int c = 0, b = 0;
private static int variabl18231;
private static int variabl18232;
private static int variabl18531 = 0, variabl18532 = 0, variabl18533 = 0;
private static int variabl17391 = 0;
private static int variabl17392 = 0;
private static String[] variabl15011;
private static String[] variabl15012;
private static String[] variabl15013;
private static int[] variabl14891;
private static int[] variabl14892;
private static int[] variabl14893;
private static int variabl2187 = 0;
private static int variabl2017 = 0;
private static int variabl1803 = 0;
private static String[] variabl19191;
private static String[] variabl19192;
private static String[] variabl19193;
private static ArrayList list1 = new ArrayList();
private static Choice fa0 = new Choice();
private static HashSet set1 = new HashSet();
private static HashSet set2 = new HashSet();
static Connection con;
private static Statement sta3;
static Connection con2;
private static Statement sta5;
private static ResultSet rs;
static String s1 = "", s2 = "", s3 = "", s4 = "", variabl2327 = "";
private static ResultSetMetaData rsmd;
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2483 = 0, variabl2503 = 0, variabl2851 = 0,
variabl2339 = 0;
public static void means(String[] parameter) {
String[] variabl240501 = { "表1除以表2", "退出" };
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) {
}
frame1 = new dataStatistic9();
frame3 = new dataStatistic9();
panel1 = new JPanel();
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
c = 0;
b = 0;
variabl18531 = 0;
variabl18532 = 0;
variabl18533 = 0;
variabl17391 = 0;
variabl17392 = 0;
list1 = new ArrayList();
fa0 = new Choice();
set1 = new HashSet();
set2 = new HashSet();
s1 = "";
s2 = "";
s3 = "";
s4 = "";
variabl2327 = "";
variabl2187 = 0;
variabl2017 = 0;
variabl1803 = 0;
variabl1605 = 15;
ItemListener = null;
frame1 = new dataStatistic9();
frame3 = new dataStatistic9();
panel1 = new JPanel();
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
variabl18531 = 0;
variabl18532 = 0;
variabl18533 = 0;
variabl2187 = 0;
variabl2017 = 0;
variabl1803 = 0;
list1 = new ArrayList();
fa0 = new Choice();
set1 = new HashSet();
set2 = new HashSet();
s1 = "";
s2 = "";
s3 = "";
s4 = "";
variabl2327 = "";
variabl26031 = parameter[4];
variabl26032 = parameter[2];
variabl2025 = parameter[5];
variabl2429 = parameter[0];
String variabl1325 = parameter[19];
String[] t2 = parameter[19].split(",");
variabl1153 = parameter[8];
variabl11530 = parameter[9];
String variabl13250 = "", variabl13251 = "";
String[] t3;
if (variabl1153.length() > 0) {
t3 = variabl1153.split(",");
for (int i = 0; i < t3.length; i++) {
if (i > 0)
variabl13250 = variabl13250 + ","
+ t2[Integer.parseInt(t3[i])];
else
variabl13250 = t2[Integer.parseInt(t3[i])];
}
variabl1325 = variabl13250;
}
main1.driver1();
frame1.setTitle("表1 作者：程学先");
frame3.setTitle("运算结果 ");
frame1.setBounds(10, 10, 1200, 600);
frame3.setBounds(200, 110, 1200, 560);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel1.setBounds(10, 10, 1200, 600);
panel3.setBounds(200, 10, 1200, 660);
panel1.setLayout(null);
panel3.setLayout(null);
if ((variabl26031 != null) && (variabl26031.length() > 0)) {
c = 0;
b = 0;
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + variabl1325 + " from " + variabl26031;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26511 = rsmd.getColumnCount();
variabl25171 = new String[variabl26511];
variabl15011 = new String[variabl26511];
variabl14891 = new int[variabl26511];
for (int i = 0; i < variabl26511; i++) {
variabl25171[i] = rsmd.getColumnName(i + 1);
variabl15011[i] = rsmd.getColumnTypeName(i + 1);
variabl14891[i] = rsmd.getColumnDisplaySize(i + 1);
if (variabl14891[i] < 5)
variabl14891[i] = 5;
variabl2187 = variabl2187 + variabl14891[i] * variabl1605;
}
rs.last();
variabl18531 = rs.getRow();
variabl19191 = new String[variabl18531];
variabl21971 = new String[variabl18531][variabl26511];
rs.absolute(1);
while (c < variabl18531) {
rs.absolute(c + 1);
variabl19191[c] = "";
while (b < variabl26511) {
variabl21971[c][b] = rs.getString(b + 1);
if (b == 0)
variabl19191[c] = variabl21971[c][b];
else
variabl19191[c] = variabl19191[c] + ","
+ variabl21971[c][b];
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表1失败！" + s1);
return;
}
scrollPane1.setBounds(20, 10, variabl2187, 450);
variabl19651 = new DefaultTableModel(variabl21971, variabl25171);
variabl26551 = new JTable(variabl19651);
variabl26551.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(variabl26551, null);
for (int i = 0; i < variabl26511; i++) {
TableColumn tc = variabl26551.getColumn(variabl25171[i]);
tc.setPreferredWidth(variabl14891[i] * variabl1605);
}
panel1.add(scrollPane1);
variabl26551.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl18231 = variabl26551.rowAtPoint(e.getPoint());
variabl17391 = variabl26551.columnAtPoint(e.getPoint());
}
}
});
}
if ((variabl26032 != null) && (variabl26032.length() > 0)) {
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl26032;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26512 = rsmd.getColumnCount();
variabl25172 = new String[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmd.getColumnName(i + 1);
}
if (variabl11530.length() > 0) {
t3 = variabl11530.split(",");
variabl13251 = "";
for (int i = 0; i < t3.length; i++) {
if (i > 0)
variabl13251 = variabl13251 + ","
+ variabl25172[Integer.parseInt(t3[i])];
else
variabl13251 = variabl25172[Integer.parseInt(t3[i])];
}
variabl13250 = variabl13251;
} else
variabl13250 = " * ";
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表2失败！" + s1);
return;
}
c = 0;
b = 0;
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + variabl13250 + " from " + variabl26032;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26512 = rsmd.getColumnCount();
variabl25172 = new String[variabl26512];
variabl15012 = new String[variabl26512];
variabl14892 = new int[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmd.getColumnName(i + 1);
variabl15012[i] = rsmd.getColumnTypeName(i + 1);
variabl14892[i] = rsmd.getColumnDisplaySize(i + 1);
if (variabl14892[i] < 5)
variabl14892[i] = 5;
variabl2017 = variabl2017 + variabl14892[i] * variabl1605;
}
rs.last();
variabl18532 = rs.getRow();
variabl19192 = new String[variabl18532];
variabl21972 = new String[variabl18532][variabl26512];
rs.absolute(1);
while (c < variabl18532) {
rs.absolute(c + 1);
variabl19192[c] = "";
while (b < variabl26512) {
variabl21972[c][b] = rs.getString(b + 1);
if (b == 0)
variabl19192[c] = variabl21972[c][b];
else
variabl19192[c] = variabl19192[c] + ","
+ variabl21972[c][b];
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, " 读取表2失败！ " + s1);
return;
}
variabl19652 = new DefaultTableModel(variabl21972, variabl25172);
variabl26552 = new JTable(variabl19652);
variabl26552.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl26552.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(variabl26552, null);
scrollPane2.setBounds(variabl2187 + 40, 10, variabl2017, 450);
for (int i = 0; i < variabl26512; i++) {
TableColumn tc = variabl26552.getColumn(variabl25172[i]);
tc.setPreferredWidth(variabl14892[i] * variabl1605);
}
panel1.add(scrollPane2);
variabl26552.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl18232 = variabl26552.rowAtPoint(e.getPoint());
variabl17392 = variabl26552.columnAtPoint(e.getPoint());
}
}
});
}
variabl2339 = (variabl2483 - 200) / variabl2851;
int variabl2337 = 150;
final JButton variabl1151 = new JButton(variabl2405[0]);
variabl1151.setBounds(variabl2337, 500, variabl2339, 20);
if (variabl1187.indexOf(",0,") >= 0)
variabl2337 = variabl2337 + variabl2339;
variabl1151.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
char x1 = 10, x2 = 13;
String s6 = JOptionPane.showInputDialog("请输入分组字段与要求包含的字段名："
+ x1 + x2 + "格式：<分组字段名集><。><包含字段名集>" + x1 + x2
+ "其中，分组字段名集是表1中某些列的名字，是商集的字段名，用逗号分隔" + x1 + x2
+ "要求包含的字段名是表1与表2中都有的某些列的名字。" + x1 + x2
+ "例如：学号,姓名。课程名");
String[] s8 = s6.split("。");
variabl25173 = s8[0].split(",");
variabl26513 = variabl25173.length;
int[] variabl1495 = new int[variabl26513];
String[] variabl1311 = s8[1].split(",");
int[] variabl1543 = new int[variabl1311.length];
int[] variabl15432 = new int[variabl1311.length];
String[][] variabl2391 = new String[1000][variabl26513];
int[] variabl1373 = new int[1000];
variabl14893 = new int[variabl26513];
variabl15013 = new String[variabl26513];
variabl1803 = 0;
for (int i = 0; i < variabl26511; i++) {
for (int j = 0; j < variabl25173.length; j++)
if (variabl25173[j].trim().equals(
variabl25171[i].trim())) {
variabl1495[j] = i;
variabl14893[j] = variabl14891[i];
variabl1803 = variabl1803 + variabl14893[j];
variabl15013[j] = variabl15011[i];
}
for (int j = 0; j < variabl1311.length; j++)
if (variabl1311[j].trim()
.equals(variabl25171[i].trim()))
variabl1543[j] = i;
}
for (int i = 0; i < variabl26512; i++)
for (int j = 0; j < variabl1311.length; j++)
if (variabl1311[j].trim()
.equals(variabl25172[i].trim()))
variabl15432[j] = i;
s8 = new String[variabl19652.getRowCount()];
for (int i1 = 0; i1 < variabl19652.getRowCount(); i1++) {
s8[i1] = "";
for (int j = 0; j < variabl1311.length; j++) {
s8[i1] = s8[i1]
+ variabl19652.getValueAt(i1, variabl15432[j])
.toString().trim();
}
}
int n = 0, n1 = 0;
set1.clear();
variabl18533 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
s1 = "";
for (int j = 0; j < variabl26513; j++) {
s1 = s1
+ variabl19651.getValueAt(i1, variabl1495[j])
.toString().trim();
}
set1.add(s1);
if (set1.size() != n) {
for (int j = 0; j < variabl26513; j++) {
variabl2391[n][j] = variabl19651
.getValueAt(i1, variabl1495[j]).toString()
.trim();
}
set2.clear();
n1 = 0;
for (int i2 = 0; i2 < variabl19651.getRowCount(); i2++) {
s3 = "";
for (int j1 = 0; j1 < variabl26513; j1++)
s3 = s3
+ variabl19651
.getValueAt(i2, variabl1495[j1])
.toString().trim();
s4 = "";
for (int j1 = 0; j1 < variabl1311.length; j1++)
s4 = s4
+ variabl19651
.getValueAt(i2, variabl1543[j1])
.toString().trim();
for (int i3 = 0; i3 < variabl19652.getRowCount(); i3++)
if ((s3.trim().equals(s1.trim()))
&& (s4.trim().equals(s8[i3].trim()))) {
set2.add(s4);
if (set2.size() != n1) {
n1 = set2.size();
variabl1373[n]++;
if (variabl1373[n] == variabl19652
.getRowCount())
variabl18533++;
}
}
}
n = set1.size();
}
}
variabl21973 = new String[variabl18533][variabl26513];
int n2 = 0;
for (int i = 0; i < n - 1; i++)
if (variabl1373[i] == variabl19652.getRowCount()) {
for (int j = 0; j < variabl25173.length; j++) {
variabl21973[n2][j] = variabl2391[i][j];
}
n2++;
}
scrollPane3.setBounds(20, 60, variabl1803 * variabl1605, 450);
variabl19653 = new DefaultTableModel(variabl21973, variabl25173);
variabl26553 = new JTable(variabl19653);
variabl26553.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(variabl26553, null);
for (int i = 0; i < variabl26513; i++) {
TableColumn tc = variabl26553.getColumn(variabl25173[i]);
tc.setPreferredWidth(variabl14893[i] * variabl1605);
}
panel3.add(scrollPane3);
frame3.setVisible(true);
}
});
if (variabl1187.indexOf(",0,") >= 0)
panel1.add(variabl1151);
final JButton variabl25991 = new JButton(variabl2405[1]);
variabl25991.setBounds(variabl2337, 500, variabl2339, 20);
if (variabl1187.indexOf(",1,") >= 0)
variabl2337 = variabl2337 + variabl2339;
variabl25991.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (variabl1187.indexOf(",1,") >= 0)
panel1.add(variabl25991);
final JButton variabl25993 = new JButton(variabl2405[1]);
variabl25993.setBounds(1000, 400, 120, 20);
variabl25993.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
panel3.add(variabl25993);
frame3.add(panel3);
frame1.add(panel1);
frame3.setVisible(true);
frame1.setVisible(true);
}
public static void createNew() {
String variabl25111 = main1.variabl1545;
if ((variabl2025 != null) && (variabl2025.length() > 0)) {
if (("," + variabl2429).lastIndexOf("," + variabl2025 + ",") < 0) {
try {
s1 = "CREATE TABLE " + variabl2025 + " (";
for (int i = 0; i < variabl25173.length; i++) {
s1 = s1 + variabl25173[i] + " " + variabl15013[i];
if (main1.variabl2511.lastIndexOf("," + variabl15013[i]
+ ",") >= 0)
s1 = s1 + "(" + variabl14893[i] + ")";
if (i != variabl25173.length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
con = main1.getConn();
Statement stat3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
stat3.executeUpdate(s1);
sta3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "建表失败！" + s1);
}
} else {
try {
s1 = "delete from " + variabl2025;
con = main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
sta3.close();
con.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "删除操作失败！" + s1);
}
}
try {
con2 = main1.getConn();
sta5 = con2.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s3 = "";
for (int j = 0; j < variabl26513; j++)
if (j < variabl26513 - 1)
s3 = s3 + variabl25173[j] + ",";
else
s3 = s3 + variabl25173[j];
int n = 0;
for (int i1 = 0; i1 < variabl19653.getRowCount(); i1++) {
s2 = "";
for (int j = 0; j < variabl26513; j++)
if (variabl19653.getValueAt(i1, j) != null)
s2 = s2 + variabl19653.getValueAt(i1, j).toString();
s1 = "insert into " + variabl2025 + " (" + s3
+ ") values (";
for (int j = 0; j < variabl26513; j++) {
if (variabl25111.lastIndexOf("," + variabl15013[j]
+ ",") >= 0)
if (variabl19653.getValueAt(i1, j) != null)
if (j < variabl26513 - 1)
s1 = s1 + variabl19653.getValueAt(i1, j)
+ ",";
else
s1 = s1 + variabl19653.getValueAt(i1, j);
else if (j < variabl26513 - 1)
s1 = s1 + "0,";
else
s1 = s1 + "0";
else if (variabl19653.getValueAt(i1, j) != null)
if (j < variabl26513 - 1)
s1 = s1 + "'" + variabl19653.getValueAt(i1, j)
+ "',";
else
s1 = s1 + "'" + variabl19653.getValueAt(i1, j)
+ "'";
else if (j < variabl26513 - 1)
s1 = s1 + "' ',";
else
s1 = s1 + "' '";
}
s1 = s1 + ")";
sta5.executeUpdate(s1);
}
sta5.close();
con2.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "操作出错，请查看录入语句是否正确！" + s1);
}
}
}
}
https://blog.sciencenet.cn/blog-2551-1119421.html
上一篇：管理信息系统软件生产线源码59-61
下一篇：管理信息系统软件生产线源码67-70
