博文
管理信息系统软件生产线源码67-70
|||
版本1
67.源码67，部件程序，生成单数据交叉表或转置表, 之后可转存数据表、转存文件、打印图表。
/*
* 程序文件名：dataStatistic10.java
* 作者：程学先
* 程序功能：生成单数据交叉表或转置表，之后可打印、转存数据表、转存文件、打印图表。
* 必选参数包括：“表名”，“字段号表”;
* 可选参数:“要求按钮号表” ;
* 实现过程：首先生成单一一个表格，本程序生成的单一表格有二类，一类是转置表，
* 另一类是单数据交叉表。
* 转置表：
* 转置表指原数据表的行变成列，列变成行后形成的表。
* 例如工资条生成程序，假如工资数据表结构为姓名、基本工资、职务工资、
* 绩效工资、公积金、……，除姓名外其他数据均为数字类型。
* 生成的转置表第一列为原字段名称，内容例如为姓名、基本工资、职务工资、
* 积效工资、公积金、……。
* 其他各列为原表各行记录中对应的数据。
* 交叉表：
* 交叉表第一列为原数据表某列的数据，其他各列的名字为原表另一列的数据
* 表中数据为原表中上述二个数据对应的原表第3个字段的数据或有关数据的统计值。
* 例如成绩单生成程序，
* 假如数据表结构为姓名、课名、分数。
* 操作时选行为姓名，生成的交叉表第一列内容为原表”姓名“字段中的数据（去掉重复值）
* （例如：王平、李明、张旺……）
* 选列为课名，生成的交叉表第一行内容为原表“课名”字段中的数据（去掉重复值）
* （例如：姓名、C语言、数学、英语、……），
* 交叉点数据为原表中各姓名值与课程值相关的分数的的数据（相关的分数值）。
* 本程序要求操作者预设置4个参数：行、列、交叉数据、聚合函数。
* 行指在交叉表第1列中展示的数据；列指在交叉表中除第1列外在第1行中展示的数据
* 数据指行、列交叉有关的数据，
* 该数据可以是原表中某种交叉相关的数据，也可以是这些数据的个数或求和。
* 在生成转置表时可以不填任何数据，“行”、“列”、“交叉数据”、“聚合函数”等四框均空置。
* 例如，工资条生成时，不输入任何参数。
* 如果转置表只涉及原数据表部分字段，要求在生成菜单时在“字段号表”中说明。
* 要求在“字段号表”中将构成第一列数据的字段名的字段号放在最前面，其后按显示要求顺序填写序号。
* 工资条生成时，在“字段号表”中将姓名的号排在第一位。
* 在生成交叉表时，在“行”、“列”和“交叉数据”中各分别填一个字段名，
* 在“聚合函数"中可空(表示取值)、可填：“条数”或“和”；
* 如果填“和”，交叉数据必须为数字类型（目前只限整形）。
* 例如生成成绩单，在“行”中输入”姓名”；“列”中输入”课程“
* 在“交叉数据”中输入“分数”，“聚合函数”中保持为空。
* 在显示交叉表页设置了转存数据表、转存文件、显示图表等按钮。
* 转生成新数据表将交叉表存放到数据库中，注意第一行内容将作为字段名，不得重复，不能以数字等开头。
* 转存文件将连接转存二级部件，其中有转存txt文件、转存Excel、word、pdf文件等按钮，
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
public class dataStatistic10 extends JFrame{
static dataStatistic10 frame1 = new dataStatistic10();
static dataStatistic10 frame2 = new dataStatistic10();
static dataStatistic10 frame3 = new dataStatistic10();
static String 表名="";
static DefaultTableModel 表格模型1;
static DefaultTableModel 表格模型2;
static DefaultTableModel 表格模型3;
static JTable 表格1;
static JTable 表格2;
static JTable 表格3;
static JScrollPane scrollPane1 = new JScrollPane();
static JScrollPane scrollPane2 = new JScrollPane();
static JScrollPane scrollPane3 = new JScrollPane();
static String s1="",s2="";
static ResultSet rs;
static int 当前列号=0, c=0;
static int 列数;
static int 表格列数1;
static String[] 列名;
static String 字段号表;
static String[] 表格列名1;
static String[] 表格列名2;
static String[] 列标题;
static String[] 列数据类型;
static String[] 表列数据类型;
static String[] 表列数据类型2;
static int[] 列数据宽度;
static int[] 表列数据宽度;
static int[] 表列数据宽度2;
static int 记录条数, 记录条数1,记录号;
static String[][] 表格数据1;// 存放表格数据的数组
static String[][] 表格数据2;
static String 表格标题;
static String 表名表;
static String[] 关键字;
static String 字段名字串;
static String 连接条件;
static String [] 按钮集01;
static Connection con; // 连接数据库
static ResultSetMetaData rsmd3;
static Statement sta3;
static int 窗口宽 = 800, 窗口高 = 600;// 窗口高
private static JScrollPane scrollPaneL1 = new JScrollPane();
private static List list1 = new List();
private static JLabel fl0,fl1,fl2,fl3,fl4,fl5,fl6,fl7,fl8,fl9,fl10,fl11,fl12;
private static JTextField fa0,fa1,fa2,fa3,fa4,fa5,fa6,fa7,fa8,fa9,fa10,fa11,fa12;
static String [] 按钮集=null;
static String 要求按钮号表;
static int 按钮数=0,按钮宽=0;
public static void means(String [] parameter) {
frame1 = new dataStatistic10();
frame2 = new dataStatistic10();
frame3 = new dataStatistic10();
表名="";
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
s1="";s2="";
当前列号=0; c=0;
窗口宽 = 800; 窗口高 = 600;
scrollPaneL1 = new JScrollPane();
list1 = new List();
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){}
frame1=new dataStatistic10();frame2=new dataStatistic10();
frame3 = new dataStatistic10();scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();scrollPane3 = new JScrollPane();
s1="";s2="";当前列号=0;c=0;窗口宽 = 800;窗口高 = 600;
scrollPaneL1 = new JScrollPane();list1 = new List();
表名=parameter[4] ; // 数据表名
表名表=parameter[0] ;
表格标题=表名;
字段号表=parameter[8];
字段名字串=parameter[19];
列名=parameter[19].split(",");
if (字段号表.length()>0){
String[] s6=字段号表.split(",");
字段名字串="";
for (int i=0;i<s6.length;i++)
if (字段名字串.length()>0)
字段名字串=字段名字串+","+列名[Integer.parseInt(s6[i])];
else 字段名字串=列名[Integer.parseInt(s6[i])];
}
连接条件=parameter[20];
try
{
con=main1.getConn();// 连接数据库
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (字段名字串.lastIndexOf(",")==字段名字串.length()-1 )
字段名字串=字段名字串.substring(0,字段名字串.length()-1);
if (连接条件.trim().length()>0)
s1="select "+字段名字串+" from "+表名+" where "+连接条件;
else
s1="select "+字段名字串+" from "+表名;
ResultSet rs=sta3.executeQuery(s1);
rsmd3 = rs.getMetaData();
列数=rsmd3.getColumnCount();
列名=new String[列数];
列数据类型 = new String[列数];
列数据宽度 = new int[列数];
for (int i=0;i<列数;i++) {
列名[i] = rsmd3.getColumnName(i + 1);
列数据类型[i] = rsmd3.getColumnTypeName(i + 1); // 获取列数据类型名存到数组中
列数据宽度[i] = rsmd3.getPrecision(i + 1); // 获取列数据宽度存到数组中
}
rs.last();
记录条数=rs.getRow();
表格列数1=列数;
表格列名1=new String[表格列数1];
表列数据类型=new String[表格列数1];
表列数据宽度=new int[表格列数1];
for (int i=0;i<表格列数1;i++) {
表格列名1[i] = 列名[i];
表列数据类型[i] = 列数据类型[i]; // 获取列数据类型名存到数组中
表列数据宽度[i] = 列数据宽度[i]; // 获取列数据宽度存到数组中
}
表格数据1=new String[记录条数][列数];
rs.absolute(1);
for (int i=0;i<记录条数;i++) {
rs.absolute(i+1);
for (int j=0;j<表格列数1;j++) {
表格数据1[i][j]=rs.getString(j+1);
}
}
rs.close(); //关闭查询结果集
sta3.close(); //关闭连接
}
catch(Exception e)
{
e.printStackTrace();
}
frame1.setTitle("单交叉表程序 作者：程学先"); //窗口标题
frame1.setBounds(10, 10,窗口宽-10,窗口高-10); //窗口位置大小
frame1.getContentPane().setLayout(null); //关闭窗口布局管理器
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
final JPanel panel = new JPanel(false); //定义面板
panel.setLayout(null); //关闭面板布局管理器
panel.setBounds(20, 20,窗口宽-50,窗口高-20);
表格模型1 = new DefaultTableModel(表格数据1,表格列名1); // 创建表格模型1
表格1 = new JTable(表格模型1);
表格1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
表格1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(表格1, null);
scrollPane1.setBounds(20, 20,窗口宽-180,窗口高-200);
panel.add(scrollPane1);
list1.setBounds(窗口宽-140, 20,80,窗口高-200);
panel.add(list1);
list1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (list1.getSelectedIndex()>=0){
int w1,w2,h1,h2;
switch (当前列号) {
case 1:
fa1.setText(list1.getSelectedItem());
break;
case 2:
fa2.setText(list1.getSelectedItem());
break;
case 3:
fa3.setText(list1.getSelectedItem());
break;
case 4:
fa4.setText(list1.getSelectedItem());
break;
}
}
}
});
fl1=new JLabel("行");
fl1.setBounds(30,窗口高-170,40, 20);
panel.add(fl1);
fa1 = new JTextField("",20);
fa1.setBounds(70,窗口高-170,100, 20);
panel.add(fa1);
fa1.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号=1;
list1.removeAll();
for (int j=0;j<表格列数1;j++) {
list1.add(表格列名1[j]);
}
}
});
fl2=new JLabel("列");
fl2.setBounds(170,窗口高-170,40, 20);
panel.add(fl2);
fa2 = new JTextField("",20);
fa2.setBounds(210,窗口高-170,100, 20);
panel.add(fa2);
fa2.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号=2;
list1.removeAll();
for (int j=0;j<表格列数1;j++) {
list1.add(表格列名1[j]);
}
}
});
fl3=new JLabel("交叉数据");
fl3.setBounds(310,窗口高-170,60, 20);
panel.add(fl3);
fa3 = new JTextField("",20);
fa3.setBounds(370,窗口高-170,100, 20);
panel.add(fa3);
fa3.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号=3;
list1.removeAll();
for (int j=0;j<表格列数1;j++) {
list1.add(表格列名1[j]);
}
}
});
fl4=new JLabel("聚集函数");
fl4.setBounds(470,窗口高-170,60, 20);
panel.add(fl4);
fa4 = new JTextField("",20);
fa4.setBounds(530,窗口高-170,100, 20);
panel.add(fa4);
fa4.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号=4;
list1.removeAll();
list1.add(" ");
list1.add("和");
list1.add("条数");
}
});
按钮宽=(窗口宽-60)/按钮数;
int 左边距=30;
final JButton transformButton1 = new JButton(按钮集[0]);
transformButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
try{
int 行序号=0;
for (int i=0;i<表格列数1;i++)
if (表格列名1[i].trim().equalsIgnoreCase(fa1.getText().trim())){
行序号=i;
break;
}
int 列序号=0;
for (int i=0;i<表格列数1;i++)
if (表格列名1[i].trim().equalsIgnoreCase(fa2.getText().trim())){
列序号=i;
break;
}
int 行元素数=0;
int mark=0;
String [] 行元素=new String[记录条数+1];
int [] 行元素1=new int[记录条数];
for (int i=0;i<记录条数;i++){
mark=0;
for (int j=i-1;j>=0;j--)
if (表格数据1[i][行序号].trim().equalsIgnoreCase(表格数据1[j][行序号].trim())){
mark=1;
行元素1[i]=行元素1[j];
break;
}
if (mark==0) {
行元素数++;
行元素[行元素数]=表格数据1[i][行序号];
行元素1[i]=行元素数;
}
}
int 列元素数=0;
String [] 列元素=new String[记录条数+1];
int [] 列元素1=new int[记录条数];
for (int i=0;i<记录条数;i++){
mark=0;
for (int j=i-1;j>=0;j--)
if (表格数据1[i][列序号].trim().equalsIgnoreCase(表格数据1[j][列序号].trim())){
mark=1;
列元素1[i]=列元素1[j];
break;
}
if (mark==0) {
列元素数++;
列元素[列元素数]=表格数据1[i][列序号];
列元素1[i]=列元素数;
}
}
int 交叉元素序号=0;
for (int i=0;i<表格列数1;i++)
if (表格列名1[i].trim().equalsIgnoreCase(fa3.getText().trim())){
交叉元素序号=i;
break;
}
表格数据2=new String[行元素数][列元素数+1];
for (int k=0;k<记录条数;k++)
o: for (int i=1;i<=行元素数;i++)
for (int j=1;j<=列元素数;j++)
if ((i==行元素1[k])&&(j==列元素1[k])){
if (fa4.getText().trim().equals("和")){
if ((表格数据2[i-1][j]!=null)&&(表格数据2[i-1][j].length()>0))
表格数据2[i-1][j]=""+(Integer.valueOf(表格数据2[i-1][j])+Integer.valueOf(表格数据1[k][交叉元素序号]));
else
表格数据2[i-1][j]=表格数据1[k][交叉元素序号];
break o;
}
else if (fa4.getText().trim().equals("条数")){
if ((表格数据2[i-1][j]!=null)&&(表格数据2[i-1][j].length()>0))
表格数据2[i-1][j]=""+(Integer.valueOf(表格数据2[i-1][j])+1);
else
表格数据2[i-1][j]="1";
break o;
}
else 表格数据2[i-1][j]=表格数据1[k][交叉元素序号];
}
for (int i=1;i<=行元素数;i++)
表格数据2[i-1][0]=行元素[i];
表格列名2=new String[列元素数+1];
列数=列元素数+1;
表列数据类型2=new String[列元素数+1];
表列数据宽度2=new int[列元素数+1];
表格列名2[0]=fa1.getText().trim();
for (int i=0;i<列元素数;i++){
表格列名2[i+1]=列元素[i+1];
表列数据类型2[i+1]=表列数据类型[交叉元素序号];
表列数据宽度2[i+1]=表列数据宽度[交叉元素序号];
}
int 列名最大宽度=0;
for (int i=0;i<表格列名2.length;i++){
if (表格列名2[i].length() > 列名最大宽度) 列名最大宽度=表格列名2[i].length();
}
表列数据类型2[0]="nchar";
表列数据宽度2[0]=列名最大宽度;
for (int i=0;i<表格数据2.length;i++)
for (int j=1;j<列数;j++){
if ((表格数据2[i][j]==null)||(表格数据2[i][j].length()<0))
表格数据2[i][j]="0";
}
}
catch(Exception e1)
{
e1.printStackTrace();
}
page2();
}
});
transformButton1.setBounds(30,窗口高-120 ,150, 20);
if (要求按钮号表.indexOf(",0,")>=0){
左边距=左边距+按钮宽;
panel.add(transformButton1);
}
final JButton transformButton2 = new JButton(按钮集[1]);
transformButton2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int 最大宽度1=0,最大宽度2=0;
for (int i=0;i<表格列数1;i++)
if (表格列名1[i].length()>最大宽度1) 最大宽度1=表格列名1[i].length();
最大宽度2=最大宽度1;
for (int i=0;i<表格列数1;i++)
if (表列数据宽度[i]>最大宽度2) 最大宽度2=表列数据宽度[i];
try{
表格数据2=new String[表格列数1-1][记录条数+1];
表格列名2=new String[记录条数+1];
列数=记录条数+1;
表列数据类型2=new String[记录条数+1];
表列数据宽度2=new int[记录条数+1];
表格列名2[0]=表格列名1[0];
表列数据类型2[0]="nchar";
表列数据宽度2[0]=最大宽度1+1;
for (int i=0;i<记录条数;i++){
for (int j=1;j<表格列数1;j++){
表格数据2[j-1][i+1]=表格数据1[i][j];
}
表格列名2[i+1]=表格数据1[i][0];
表列数据宽度2[i+1]=最大宽度2;
}
for (int j=1;j<表格列数1;j++)
表格数据2[j-1][0]=表格列名1[j];
page2();
}
catch(Exception e1)
{
e1.printStackTrace();
}
}
});
transformButton2.setBounds(180,窗口高-120 ,150, 20);
if (要求按钮号表.indexOf(",1,")>=0){
左边距=左边距+按钮宽;
panel.add(transformButton2);
}
final JButton exitButton = new JButton(按钮集[5]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
}
});
exitButton.setBounds(330, 窗口高-120 ,150, 20);
if (要求按钮号表.indexOf(",5,")>=0){
左边距=左边距+按钮宽;
panel.add(exitButton);
}
frame1.getContentPane().add(panel, null); //安装面板
frame1.setVisible(true); //安装窗口
frame1.getContentPane().add(panel, BorderLayout.SOUTH);
}
public static void page2(){
frame2.setTitle("交叉表或转置表"); //窗口标题
frame2.setBounds(100, 10,窗口宽-10,窗口高-10); //窗口位置大小
frame2.getContentPane().setLayout(null); //关闭窗口布局管理器
final JPanel panel2 = new JPanel(false); //定义面板
panel2.setLayout(null); //关闭面板布局管理器
panel2.setBounds(20, 20,窗口宽-20,窗口高-20);
表格模型2 = new DefaultTableModel(表格数据2,表格列名2); // 创建表格模型2
表格2 = new JTable(表格模型2);
表格2.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
表格2.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(表格2, null);
scrollPane2.setBounds(20, 20,窗口宽-180,窗口高-200);
panel2.add(scrollPane2);
记录号=-1;
表格2.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
记录号 = 表格2.getSelectedRow();
}});
int 左边距=270;
int 按钮宽=frame1.按钮宽;
final JButton printButton5 = new JButton(按钮集[2]);
printButton5.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String 表名1="";
表名1=JOptionPane.showInputDialog("请输入新数据表名称：");
s1="CREATE TABLE "+ 表名1+" (";
for (int i=0;i<表格列名2.length;i++){
s1=s1+表格列名2[i]+" "+表列数据类型2[i];
if (main1.类型.lastIndexOf(","+表列数据类型2[i]+",")>=0)
s1=s1+"("+表列数据宽度2[0]+")";
if (i!=表格列名2.length-1) s1=s1+",";
}
s1=s1+")";
try
{
con=main1.getConn();// 连接数据库
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
String 类型1=main1.数字数据类型;
for (int i=0;i<表格数据2.length;i++){
s1="insert into "+表名1+" values (";
for (int j=0;j<表格列名2.length;j++){
if (类型1.lastIndexOf(","+表列数据类型2[j]+",")>=0){
if (表格数据2[i][j]==null) 表格数据2[i][j]="0";
s1=s1+表格数据2[i][j];
}
else{
if (表格数据2[i][j]==null) 表格数据2[i][j]=" ";
s1=s1+"'"+表格数据2[i][j]+"'";
}
if (j!=表格列名2.length-1) s1=s1+",";
}
s1=s1+")";
sta3.executeUpdate(s1);
}
sta3.close(); //关闭连接
}
catch(SQLException e1)
{
JOptionPane.showMessageDialog( null, "操作出错，请检查数据表名是否重复，录入语句是否正确！"+s1);
}
}
});
printButton5.setBounds(左边距, 窗口高-140 ,按钮宽, 20);
if (要求按钮号表.indexOf(",2,")>=0){
左边距=左边距+按钮宽;
panel2.add(printButton5);
}
final JButton printButton6 = new JButton(按钮集[3]);
printButton6.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataTransfer0.Trans(表格列名2,表列数据类型2,表列数据宽度2,"",表格数据2,表名);
}
});
printButton6.setBounds(左边距, 窗口高-140 ,按钮宽, 20);
if (要求按钮号表.indexOf(",3,")>=0){
左边距=左边距+按钮宽;
panel2.add(printButton6);
}
final JButton printButton7 = new JButton(按钮集[4]);
printButton7.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
boolean b1=true;
String x="";
while(b1) {
x=JOptionPane.showInputDialog(null,"请输入选择序号：" +
"1、显示单柱面统计图；2、显示多柱面统计图" +
"3、显示饼形统计图；4、显示折线图");
if ("1234".lastIndexOf(x)<0)
JOptionPane.showMessageDialog( null, "输入序号不是1到4中间的数，请重新输入！");
else b1=false;
}
if (("134".lastIndexOf(x)>=0)&&(记录号<0)){
JOptionPane.showMessageDialog( null, "您所选图形只对一条记录，请点击表格中某一行后重新操作！");
return;
}
int 图类型=Integer.valueOf(x);
int a=0,列数0=0;
if (表列数据类型2[0].lastIndexOf("int")<0){
列数0=列数-1;
a=1;
}
else 列数0=列数;
String[] 列名0=new String[列数0];
int[][] 交叉数据=new int[表格数据2.length][列数0];
try{
for (int j=0;j<列数;j++){
if (a==0) 列名0[j]=表格列名2[j];
else if (j!=0) 列名0[j-1]=表格列名2[j];
}
关键字=new String[表格模型2.getRowCount()+1];
关键字[0]=表格列名2[0];
for (int i=0;i<表格数据2.length;i++){
for (int j=0;j<列数;j++){
交叉数据[i][列数0-1]=0;
if (a==0) {
交叉数据[i][j]=Integer.valueOf(表格数据2[i][j]);
}
else if (j!=0){
交叉数据[i][j-1]=Integer.valueOf(表格数据2[i][j]);
}
}
关键字[i+1]=表格数据2[i][0];
}
}catch(Exception e1){
JOptionPane.showMessageDialog( null, "表中交叉数据部分不能全部转为数字类型，不能绘制统计图！");
return;
}
statisticalChart.GDisplay(交叉数据,记录号,列名0,图类型,关键字);
}
});
printButton7.setBounds(左边距, 窗口高-140 ,按钮宽, 20);
if (要求按钮号表.indexOf(",4,")>=0){
左边距=左边距+按钮宽;
panel2.add(printButton7);
}
final JButton exitButton1 = new JButton(按钮集[5]);
exitButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel2.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame2.setVisible(false);
frame2.dispose();
}
});
exitButton1.setBounds(左边距, 窗口高-140 ,按钮宽, 20);
if (要求按钮号表.indexOf(",5,")>=0){
左边距=左边距+按钮宽;
panel2.add(exitButton1);
}
frame2.getContentPane().add(panel2, null); //安装面板
frame2.setVisible(true); //安装窗口
frame2.getContentPane().add(panel2, BorderLayout.SOUTH);
}
}
68.源码68，部件程序，生成多数据交叉表，之后可打印、转存数据表、转存文件、打印图表。
/*
* 程序文件名：dataStatistic11.java
* 作者：程学先
* 程序功能：生成多数据交叉表，之后可打印、转存数据表、转存文件、打印图表。
* 必选参数包括：表名表、字段号表
* 可选参数：打印格式文件名;
* 在表名表中可输入多个表名，之间用逗号分隔，注意每相邻二表之间必须有一个同名字段为连接字段。
* 实现过程：首先生成多数据交叉表表格。
* 交叉表前若干列为原数据表某若干列的数据，
* 第一行（相当于之后的新字段名）为原表另一列的数据
* 表中数据为原表中上述二类数据对应的原表第3个字段的数据或有关数据的统计值。
* 例如成绩单生成程序，
* 假如数据表结构为班级、姓名、课名、分数。
* 生成的交叉表第一、二列内容为原表“班级、姓名”字段中的数据（去掉重复值）
* （例如：2301 王平、2301 李明、2302 张旺……）
* 第一行内容为原表“课名”字段中的数据（去掉重复值）
* （例如：班级、姓名、C语言、数学、英语、……），
* 交叉点数据为原表中各班级姓名值与课程值相关的分数的的数据（相关的分数值）。
* 本程序要求操作者预设置4个参数：行、列、交叉数据、聚合函数。
* 行指在交叉表第1、2、……等k列中展示的数据；列指在交叉表中除前k列外在第1行中展示的数据
* 数据指行、列交叉有关的数据，
* 该数据可以是原表中某种交叉相关的数据，也可以是这些数据的个数或求和。
* 在显示交叉表页设置了打印、转存数据表、转存文件、打印图表等按钮。
* 打印通过简单打印部件打印交叉表内容，自动根据页宽与交叉表宽度决定字号。
* “生成新数据表”将交叉表存放到数据库中，注意第一行内容将作为字段名，不得重复，不能以数字等开头。
* 转存文件可转存txt文件、转存Excel、word、pdf文件等按钮，
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
public class dataStatistic11 extends JFrame {
static dataStatistic11 frame1 = new dataStatistic11();
static dataStatistic11 frame2 = new dataStatistic11();
static dataStatistic11 frame3 = new dataStatistic11();
static String 表名="";
static DefaultTableModel 表格模型1;
static DefaultTableModel 表格模型2;
static DefaultTableModel 表格模型3;
static JTable 表格1;
static JTable 表格2;
static JTable 表格3;
static JScrollPane scrollPane1 = new JScrollPane();
static JScrollPane scrollPane2 = new JScrollPane();
static JScrollPane scrollPane3 = new JScrollPane();
static String s1="",s2="";
static ResultSet rs;
static int 当前列号=0,c=0;
static int 列数,列数2;
static int 表格列数1;
static String[] 列名;
static String [] 列元素;
static String 字段号表;
static String[] 表格列名1;
static String[] 表格列名2;
static String[] x1001; //分组、排序后返回值
static int x1002; //分组、排序后返回值的个数
static String[] 列标题;
static String[] 列数据类型;
static String[] 表列数据类型;
static String[] 表列数据类型2;
static int[] 列数据宽度;
static int[] 表列数据宽度;
static int[] 表列数据宽度2;
static int 记录条数, 记录条数1,记录号,记录条数2;
static int 列元素数=0,行元素数=0;
static String[][] 表格数据1;
static String[][] 表格数据2;
static String 表格标题;
static String [] 行字段名;
static String 表名表;
static String[] 关键字;
static String 字段名字串;
static String 连接条件;
static String [] 按钮集01;
static String 打印格式文件名;
static Connection con; // 连接数据库
static ResultSetMetaData rsmd3;
static Statement sta3;
static int 窗口宽 = 800, 窗口高 = 600;// 窗口高
private static JScrollPane scrollPaneL1 = new JScrollPane();
private static List list1 = new List();
private static JLabel fl0,fl1,fl2,fl3,fl4,fl5,fl6,fl7,fl8,fl9,fl10,fl11,fl12;
private static JTextField fa0,fa1,fa2,fa3,fa4,fa5,fa6,fa7,fa8,fa9,fa10,fa11,fa12;
static String [] 按钮集=null;
static String 要求按钮号表;
static int 按钮数=0,按钮宽=0;
public static void means(String [] parameter) {
frame1 = new dataStatistic11();
frame2 = new dataStatistic11();
frame3 = new dataStatistic11();
表名="";
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
s1="";s2="";
当前列号=0;c=0;
列元素数=0;行元素数=0;
窗口宽 = 800; 窗口高 = 600;// 窗口高
JScrollPane scrollPaneL1 = new JScrollPane();
list1 = new List();
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){}
frame1=new dataStatistic11();frame2=new dataStatistic11();
frame3 = new dataStatistic11();scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();scrollPane3 = new JScrollPane();
s1="";s2="";当前列号=0;c=0;窗口宽 = 800;窗口高 = 600;
scrollPaneL1 = new JScrollPane();list1 = new List();
表名=parameter[4] ; // 数据表名
表名表=parameter[0] ;
表格标题=表名;
字段号表=parameter[8];
打印格式文件名=parameter[15] ;
字段名字串=parameter[19];
列名=parameter[19].split(",");
if (字段号表.length()>0){
String[] s6=字段号表.split(",");
字段名字串="";
for (int i=0;i<s6.length;i++)
if (字段名字串.length()>0)
字段名字串=字段名字串+","+列名[Integer.parseInt(s6[i])];
else 字段名字串=列名[Integer.parseInt(s6[i])];
}
连接条件=parameter[20];
try
{
con=main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (字段名字串.lastIndexOf(",")==字段名字串.length()-1 )
字段名字串=字段名字串.substring(0,字段名字串.length()-1);
if (连接条件.trim().length()>0)
s1="select "+字段名字串+" from "+表名+" where "+连接条件;
else
s1="select "+字段名字串+" from "+表名;
ResultSet rs=sta3.executeQuery(s1);
rsmd3 = rs.getMetaData();
列数=rsmd3.getColumnCount();
列名=new String[列数];
列数据类型 = new String[列数];
列数据宽度 = new int[列数];
for (int i=0;i<列数;i++) {
列名[i] = rsmd3.getColumnName(i + 1);
列数据类型[i] = rsmd3.getColumnTypeName(i + 1);
列数据宽度[i] = rsmd3.getPrecision(i + 1);
}
rs.last();
记录条数=rs.getRow();
表格列数1=列数;
表格列名1=new String[表格列数1];
表列数据类型=new String[表格列数1];
表列数据宽度=new int[表格列数1];
for (int i=0;i<表格列数1;i++) {
表格列名1[i] = 列名[i];
表列数据类型[i] = 列数据类型[i];
表列数据宽度[i] = 列数据宽度[i];
}
表格数据1=new String[记录条数][列数];
表列数据类型2=new String[列数+1];
表列数据宽度2=new int[列数+1];
rs.absolute(1);
for (int i=0;i<记录条数;i++) {
rs.absolute(i+1);
for (int j=0;j<表格列数1;j++) {
表格数据1[i][j]=rs.getString(j+1);
}
}
rs.close(); //关闭查询结果集
sta3.close(); //关闭连接
}
catch(Exception e)
{
e.printStackTrace();
}
frame1.setTitle("多表交叉表程序 作者：程学先"); //窗口标题
frame1.setBounds(10, 10,窗口宽-10,窗口高-10); //窗口位置大小
frame1.getContentPane().setLayout(null); //关闭窗口布局管理器
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
final JPanel panel = new JPanel(false); //定义面板
panel.setLayout(null); //关闭面板布局管理器
panel.setBounds(20, 20,窗口宽-50,窗口高-20);
表格模型1 = new DefaultTableModel(表格数据1,表格列名1); // 创建表格模型1
表格1 = new JTable(表格模型1);
表格1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
表格1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(表格1, null);
scrollPane1.setBounds(20, 20,窗口宽-180,窗口高-200);
panel.add(scrollPane1);
list1.setBounds(窗口宽-140, 20,80,窗口高-200); //列表框大小位置
panel.add(list1);
list1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (list1.getSelectedIndex()>=0){
int w1,w2,h1,h2;
switch (当前列号) {
case 1:
if (fa1.getText().trim().length()>0)
fa1.setText(fa1.getText().trim()+","+list1.getSelectedItem());
else
fa1.setText(list1.getSelectedItem());
break;
case 2:
fa2.setText(list1.getSelectedItem());
break;
case 3:
fa3.setText(list1.getSelectedItem());
break;
case 4:
fa4.setText(list1.getSelectedItem());
break;
}
}
}
});
fl1=new JLabel("行");
fl1.setBounds(30,窗口高-170,40, 20);
panel.add(fl1);
fa1 = new JTextField("",20);
fa1.setBounds(70,窗口高-170,100, 20);
panel.add(fa1);
fa1.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号=1;
list1.removeAll();
for (int j=0;j<表格列数1;j++) {
list1.add(表格列名1[j]);
}
}
});
fl2=new JLabel("列");
fl2.setBounds(170,窗口高-170,40, 20);
panel.add(fl2);
fa2 = new JTextField("",20);
fa2.setBounds(210,窗口高-170,100, 20);
panel.add(fa2);
fa2.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号=2;
list1.removeAll();
for (int j=0;j<表格列数1;j++) {
list1.add(表格列名1[j]);
}
}
});
fl3=new JLabel("交叉数据");
fl3.setBounds(310,窗口高-170,60, 20);
panel.add(fl3);
fa3 = new JTextField("",20);
fa3.setBounds(370,窗口高-170,100, 20);
panel.add(fa3);
fa3.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号=3;
list1.removeAll();
for (int j=0;j<表格列数1;j++) {
list1.add(表格列名1[j]);
}
}
});
fl4=new JLabel("聚集函数");
fl4.setBounds(470,窗口高-170,60, 20);
panel.add(fl4);
fa4 = new JTextField("",20);
fa4.setBounds(530,窗口高-170,100, 20);
panel.add(fa4);
fa4.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号=4;
list1.removeAll();
list1.add(" ");
list1.add("和");
list1.add("条数");
}
});
按钮宽=(窗口宽-60)/按钮数;
int 左边距=30;
final JButton transformButton1 = new JButton(按钮集[0]);
transformButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
try{
行字段名=fa1.getText().trim().split(",");
int 行序号[]=new int[行字段名.length];
int 列序号=0;
int 交叉号=0;
String[] 行组数据=new String[记录条数]; //将每条记录行字段各字段数据加逗号连在一起
列数2=行字段名.length;
for (int i=0;i<表格列数1;i++){ //求行序号与行字段最大宽度
for (int j=0;j<列数2;j++)
if (表格列名1[i].trim().equalsIgnoreCase(行字段名[j].trim())){
行序号[j]=i;
}
if (表格列名1[i].trim().equalsIgnoreCase(fa2.getText().trim())){
列序号=i;
}
if (表格列名1[i].trim().equalsIgnoreCase(fa3.getText().trim())){
交叉号=i;
}
}
for (int i=0;i<记录条数;i++){
行组数据[i]="";
for (int j=0;j<列数2;j++){
if (行组数据[i].length()==0)
行组数据[i]=表格数据1[i][行序号[j]];
else 行组数据[i]=行组数据[i]+","+表格数据1[i][行序号[j]];
}
}
求分组(行组数据); //将行分组去掉重复值、排序，得到第1、2、……列数据
记录条数2=x1002; //行分组去掉重复值后个数是目的表记录数
String [][] lins=new String[记录条数2][列数2];//临时存前二列数据
String [] lins1=new String[记录条数]; //在原表中前二列数据的连接
for (int i=0;i<记录条数2;i++)
lins[i]=x1001[i].split(","); //临时保存行数据
for (int i=0;i<记录条数;i++)
lins1[i]=表格数据1[i][列序号];
求分组(lins1); //新表前二列之后各列标签
列数2=行字段名.length+x1002; //表格2的列数等于行分组字段数加上列分组字段数据分组数
表格列名2=new String[列数2];
for (int i=0;i<行字段名.length;i++){
表格列名2[i]=行字段名[i]; //前二列新字段名
}
for (int i=行字段名.length;i<列数2;i++){
表格列名2[i]=x1001[i-行字段名.length];
} //以上求得新表各列列名
表格数据2=new String[记录条数2][列数2];
String [] x1003=new String[记录条数2];
for (int i=0;i<记录条数2;i++){
x1003[i]="";
for (int j=0;j<行字段名.length;j++){
表格数据2[i][j]=lins[i][j];
if (x1003[i].length()==0)
x1003[i]=lins[i][j];
else x1003[i]=x1003[i]+","+lins[i][j];
}
}
//下面将分数安排到其应当的行、列中去
//行根据新表第i行前二列数据和原表第k行前二列数据相同确定分数所在新表的行i
//列根据分数原来表中行号i相应的列字段的表格中数据和新表列名相同确定列号
for (int k=0;k<记录条数;k++)
for (int i=0;i<记录条数2;i++)
if (行组数据[k].equalsIgnoreCase(x1003[i])){
for (int j=0;j<列数2;j++){
if (表格列名2[j].equalsIgnoreCase(表格数据1[k][列序号])){
表格数据2[i][j]=表格数据1[k][交叉号];
}
}
}
}
catch(Exception e1)
{
e1.printStackTrace();
}
page2();
}
});
transformButton1.setBounds(左边距,窗口高-120 ,按钮宽, 20);
if (要求按钮号表.indexOf(",0,")>=0){
左边距=左边距+按钮宽;
panel.add(transformButton1);
}
final JButton exitButton = new JButton(按钮集[6]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
}
});
exitButton.setBounds(左边距,窗口高-120 ,按钮宽, 20);
if (要求按钮号表.indexOf(",1,")>=0){
左边距=左边距+按钮宽;
panel.add(exitButton);
}
frame1.getContentPane().add(panel, null); //安装面板
frame1.setVisible(true); //安装窗口
frame1.getContentPane().add(panel, BorderLayout.SOUTH);
}
public static void 求分组(String [] a){ //对字符串数组分组并排序
x1001=new String [500];
int b=0;
int k=0;
for (int i=0;i<a.length;i++){
k=0;
for (int j=0;j<=b;j++){
if (x1001[j]==null){
if (k==0) {
x1001[b]=a[i];
b++;
break;
}
}
else if (a[i].equalsIgnoreCase(x1001[j])){
break;
}
}
}
x1002=b;
String sk="";
for (int i=0;i<b;i++) //排序
for (int j=0;j<=i;j++)
if (x1001[i].compareTo(x1001[j])<0){
sk=x1001[i];
x1001[i]=x1001[j];
x1001[j]=sk;
}
}
public static void page2(){
frame2.setTitle("多数据项交叉表"); //窗口标题
frame2.setBounds(100, 10,窗口宽-10,窗口高-10); //窗口位置大小
frame2.getContentPane().setLayout(null); //关闭窗口布局管理器
final JPanel panel2 = new JPanel(false); //定义面板
panel2.setLayout(null); //关闭面板布局管理器
panel2.setBounds(20, 20,窗口宽-20,窗口高-20);
表格模型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(20, 20,窗口宽-180,窗口高-200);
panel2.add(scrollPane2);
记录号=-1;
表格2.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
记录号 = 表格2.getSelectedRow();
}});
int 左边距=30,按钮宽=frame1.按钮宽;
final JButton printButton3 = new JButton(按钮集[1]);
printButton3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPreview0.printView1(表格列名2,表格数据2,表列数据宽度2,表格标题);
}
});
printButton3.setBounds(左边距, 窗口高-140 ,按钮宽, 20);
if (要求按钮号表.indexOf(",1,")>=0){
左边距=左边距+按钮宽;
panel2.add(printButton3);
}
final JButton printButton4 = new JButton(按钮集[2]);
printButton4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPrint0.printView1(表格列名2,表格数据2,表列数据宽度2,表格标题);
}
});
printButton4.setBounds(左边距, 窗口高-140 ,按钮宽, 20);
if (要求按钮号表.indexOf(",2,")>=0){
左边距=左边距+按钮宽;
panel2.add(printButton4);
}
final JButton printButton5 = new JButton(按钮集[3]);
printButton5.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
boolean b0=true;
String 表名1="";
表名1=JOptionPane.showInputDialog("请输入新数据表名称：");
s1="CREATE TABLE "+ 表名1+" (";
for (int i=0;i<表格列名2.length;i++){
s1=s1+表格列名2[i]+" "+表列数据类型2[i];
if (main1.类型.lastIndexOf(","+表列数据类型2[i]+",")>=0)
s1=s1+"("+表列数据宽度2[i]+")";
if (i!=表格列名2.length-1) s1=s1+",";
}
s1=s1+")";
try
{
con=main1.getConn();// 连接数据库
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
String 类型1=main1.数字数据类型;
for (int i=0;i<表格数据2.length;i++){
s1="insert into "+表名1+" values (";
for (int j=0;j<表格列名2.length;j++){
if (类型1.lastIndexOf(","+表列数据类型2[j]+",")>=0){
if (表格数据2[i][j]==null) 表格数据2[i][j]="0";
s1=s1+表格数据2[i][j];
}
else{
if (表格数据2[i][j]==null) 表格数据2[i][j]=" ";
s1=s1+"'"+表格数据2[i][j]+"'";
}
if (j!=表格列名2.length-1) s1=s1+",";
}
s1=s1+")";
sta3.executeUpdate(s1);
}
sta3.close(); //关闭连接
}
catch(SQLException e1)
{
JOptionPane.showMessageDialog( null, "操作出错，请检查数据表名是否重复，录入语句是否正确！"+s1);
}
}
});
printButton5.setBounds(左边距, 窗口高-140 ,按钮宽, 20);
if (要求按钮号表.indexOf(",3,")>=0){
左边距=左边距+按钮宽;
panel2.add(printButton5);
}
final JButton printButton6 = new JButton(按钮集[4]);
printButton6.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataTransfer0.Trans(表格列名2,表列数据类型2,
表列数据宽度2," ",表格数据2,表名);
}
});
printButton6.setBounds(左边距, 窗口高-140 ,按钮宽, 20);
if (要求按钮号表.indexOf(",4,")>=0){
左边距=左边距+按钮宽;
panel2.add(printButton6);
}
final JButton printButton7 = new JButton(按钮集[5]);
printButton7.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
boolean b1=true;
String x="";
while(b1) {
x=JOptionPane.showInputDialog(null,"请输入选择序号：" +
"1、显示单柱面统计图；2、显示多柱面统计图" +
"3、显示饼形统计图；4、显示折线图");
if ("1234".lastIndexOf(x)<0)
JOptionPane.showMessageDialog( null, "输入序号不是1到4中间的数，请重新输入！");
else b1=false;
}
if (("134".lastIndexOf(x)>=0)&&(记录号<0)){
JOptionPane.showMessageDialog( null, "您所选图形只对一条记录，请点击表格中某一行后重新操作！");
return;
}
int 图类型=Integer.valueOf(x);
int a=0,列数0=0;
if (列数据类型[0].lastIndexOf("int")<0){
列数0=列数-1;
a=1;
}
else 列数0=列数;
String[] 列名0=new String[列数0];
int[][] 交叉数据=new int[表格数据2.length][列数0];
try{
for (int j=0;j<列数;j++){
if (a==0) 列名0[j]=表格列名2[j];
else if (j!=0) 列名0[j-1]=表格列名2[j];
}
关键字=new String[表格模型2.getRowCount()+1];
关键字[0]=表格列名2[0];
for (int i=0;i<表格数据2.length;i++){
for (int j=0;j<列数;j++){
交叉数据[i][列数0-1]=0;
if (a==0) {
交叉数据[i][j]=Integer.valueOf(表格数据2[i][j]);
}
else if (j!=0){
交叉数据[i][j-1]=Integer.valueOf(表格数据2[i][j]);
}
}
关键字[i+1]=表格数据2[i][0];
}
}catch(Exception e1){
JOptionPane.showMessageDialog( null, "表中交叉数据部分短缺，绘制统计图失败，请补充缺项，或改用程序10！");
return;
}
statisticalChart.GDisplay(交叉数据,记录号,列名0,图类型,关键字);
}
});
printButton7.setBounds(左边距, 窗口高-140 ,按钮宽, 20);
if (要求按钮号表.indexOf(",6,")>=0){
左边距=左边距+按钮宽;
panel2.add(printButton7);
}
frame2.getContentPane().add(panel2, null); //安装面板
frame2.setVisible(true); //安装窗口
frame2.getContentPane().add(panel2, BorderLayout.SOUTH);
}
}
69.源码69，部件程序，一元线性回归分析程序，可显示拟合曲线。
/*
* 程序文件名：dataStatistic12.java
* 作者：程学先
* 程序功能：对数据库中某数据表中二个字段的数据进行一元线性回归分析并显示拟合曲线。
* 调用： dataStatistic12.
*
*/
import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Insets;
import java.awt.List;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumn;
import javax.swing.table.TableModel;
public class dataStatistic12 extends JFrame {
static String[] 列名;
static float[] 纵向数据;
static float[] 横向数据;
static int 纵向最大值 = 0, 纵向最小值 = 0;
static int 窗口宽度 = 1200, 窗口高度 = 700;
static int 记录条数, 列数, 当前列号;
static Graphics g;
static Graphics2D g2;
static Insets inset;
static int 左边 = 100, 到顶 = 窗口高度;
private static JTable table;
static Connection con;
private static ResultSetMetaData rsmd4;
static String 表名;
static String s1 = "", s2 = "", s3 = "";
static int 窗口宽 = 900, 窗口高 = 600;
static int 表格列数;
static String[] 表格列名;
static int 表格列号1, 表格列号2;
static String[] 列数据类型;
static Object[][] 表格数据;
static List list1 = new List();
static JTextField fa0, fa1, fa2, fa3;
static int 纵向系数 = 1, 横向系数 = 1;
static String[] 按钮集 = null;
static String 要求按钮号表;
static int 按钮数 = 0, 按钮宽 = 0;
public static void means(String[] parameter) {
纵向最大值 = 0;
纵向最小值 = 0;
窗口宽度 = 1200;
窗口高度 = 700;
左边 = 100;
到顶 = 窗口高度;
s1 = "";
s2 = "";
s3 = "";
list1 = new List();
纵向系数 = 1;
横向系数 = 1;
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;
按钮数++;
}
}
要求按钮号表 = "," + 要求按钮号表 + ",";
窗口宽 = 1000;
窗口高 = 700;
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];
main1.driver1();
con = main1.getConn();
try {
Statement sta = con.createStatement(
// 建立连接
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
s1 = "select * from " + 表名;
ResultSet rs = sta.executeQuery(s1);
rs.last();
记录条数 = rs.getRow();
rsmd4 = rs.getMetaData();
表格列数 = rsmd4.getColumnCount(); // 获取列数
表格列名 = new String[表格列数]; // 定义列名数组
String[] 列数据类型 = new String[表格列数]; // 定义列字段类型数组
int[] 列数据宽度 = new int[表格列数]; // 定义列数据宽度
for (int i = 0; i < 表格列数; i++) {
表格列名[i] = rsmd4.getColumnName(i + 1); // 获取列名存到数组中
列数据类型[i] = rsmd4.getColumnTypeName(i + 1); // 获取列数据类型名存到数组中
列数据宽度[i] = rsmd4.getColumnDisplaySize(i + 1);// 指定宽度数据类型列宽度按指定值
}
表格数据 = new String[记录条数][表格列数];
for (int i = 0; i < 记录条数; i++) {
rs.absolute(i + 1);
for (int j = 0; j < 表格列数; j++) {
s3 = rs.getString(j + 1);
表格数据[i][j] = s3;
}
}
rs.close(); // 关闭查询结果集
con.close();
sta.close(); // 关闭连接
} catch (Exception e1) {
e1.printStackTrace();
}
final dataStatistic12 frame1 = new dataStatistic12();
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame1.setTitle("统计程序 作者：程学先");
frame1.setBounds(10, 10, 窗口宽度, 窗口高度 + 50);
frame1.setLayout(null);
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(10, 10, 窗口宽 - 60, 窗口高 - 100);
final TableModel model = new DefaultTableModel(表格数据, 表格列名);
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(表格列名[i]);
tc.setPreferredWidth(100);
tc.setMaxWidth(100);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
frame1.getContentPane().add(scrollPane, BorderLayout.CENTER);
inset = frame1.getInsets();
JLabel fl0 = new JLabel("纵向字段名");
frame1.add(fl0);
fa0 = new JTextField("", 20);
frame1.add(fa0);
fl0.setBounds(30, 窗口高 - 70, 70, 20);
fa0.setBounds(100, 窗口高 - 70, 80, 20);
fa0.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号 = 0;
}
});
JLabel fl1 = new JLabel("纵向相乘系数");
frame1.add(fl1);
fa1 = new JTextField("", 20);
frame1.add(fa1);
fl1.setBounds(185, 窗口高 - 70, 90, 20);
fa1.setBounds(275, 窗口高 - 70, 80, 20);
fa1.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号 = 1;
}
});
JLabel fl2 = new JLabel("横向字段名");
frame1.add(fl2);
fa2 = new JTextField("", 20);
frame1.add(fa2);
fl2.setBounds(360, 窗口高 - 70, 70, 20);
fa2.setBounds(430, 窗口高 - 70, 80, 20);
fa2.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号 = 2;
}
});
JLabel fl3 = new JLabel("横向相乘系数");
frame1.add(fl3);
fa3 = new JTextField("", 20);
frame1.add(fa3);
fl3.setBounds(515, 窗口高 - 70, 80, 20);
fa3.setBounds(595, 窗口高 - 70, 80, 20);
fa3.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
当前列号 = 3;
}
});
list1.setBounds(窗口宽 - 50, 10, 120, 窗口高 - 100);
frame1.add(list1);
list1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (list1.getSelectedIndex() >= 0) {
switch (当前列号) {
case 0: // 表名
fa0.setText(list1.getSelectedItem());
表格列号1 = list1.getSelectedIndex();
break;
case 2: // 表名
fa2.setText(list1.getSelectedItem());
表格列号2 = list1.getSelectedIndex();
break;
}
}
}
});
for (int j = 0; j < 表格列数; j++) {
list1.add(表格列名[j]);
}
按钮宽 = (窗口宽 - 750) / 按钮数;
int 左边距 = 680;
final JButton Button1 = new JButton(按钮集[0]);
Button1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
纵向数据 = new float[记录条数];
横向数据 = new float[记录条数];
纵向系数 = Integer.valueOf(fa1.getText().toString());
横向系数 = Integer.valueOf(fa3.getText().toString());
for (int i = 0; i < 记录条数; i++) {
纵向数据[i] = Float.parseFloat(表格数据[i][表格列号1].toString())
* 纵向系数;
横向数据[i] = Float.parseFloat(表格数据[i][表格列号2].toString())
* 横向系数;
}
calc.calc1();
}
});
Button1.setBounds(左边距, 窗口高 - 70, 按钮宽, 20);
if (要求按钮号表.indexOf(",0,") >= 0) {
左边距 = 左边距 + 按钮宽;
frame1.add(Button1);
}
final JButton Button2 = new JButton(按钮集[1]);
Button2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame1.setVisible(false);
frame1.dispose();
calc.frame2.setVisible(false);
calc.frame2.dispose();
}
});
Button2.setBounds(左边距, 窗口高 - 70, 按钮宽, 20);
if (要求按钮号表.indexOf(",1,") >= 0) {
左边距 = 左边距 + 按钮宽;
frame1.add(Button2);
frame1.setVisible(true);
}
}
}
class calc extends JFrame {
static calc frame2 = new calc();
static Graphics g;
static float[] 纵向数据, 横向数据;
static int 记录条数;
static int 窗口宽度 = 1000, 窗口高度 = 700;
static int 纵向最大值 = 0, 纵向最小值, 横向最大值 = 0, 横向最小值;
static int 纵向分段数 = 20, 横向分段数 = 20;
static int 纵向系数 = 1, 横向系数 = 1;
static void calc1() {
calc frame2 = new calc();
frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame2.setBounds(10, 10, 窗口宽度, 窗口高度 + 50);
frame2.setVisible(true);
}
public void paint(Graphics g1) {
记录条数 = dataStatistic12.记录条数;
纵向数据 = new float[记录条数];
横向数据 = new float[记录条数];
纵向系数 = dataStatistic12.纵向系数;
横向系数 = dataStatistic12.横向系数;
纵向最小值 = (int) (dataStatistic12.纵向数据[1]);
横向最小值 = (int) (dataStatistic12.横向数据[1]);
for (int i = 0; i < 记录条数; i++) {
纵向数据[i] = dataStatistic12.纵向数据[i];
横向数据[i] = dataStatistic12.横向数据[i];
if (纵向数据[i] > 纵向最大值)
纵向最大值 = (int) (纵向数据[i]);
if (纵向数据[i] < 纵向最小值)
纵向最小值 = (int) (纵向数据[i]);
if (横向数据[i] > 横向最大值)
横向最大值 = (int) (横向数据[i]);
if (横向数据[i] < 横向最小值)
横向最小值 = (int) (横向数据[i]);
}
g1.setColor(Color.WHITE);
g1.fillRect(0, 0, getWidth(), getHeight());
g = g1;
brokenLine();
}
static void brokenLine() {
g.setColor(Color.BLACK);
int 可用高度 = 窗口高度 - 100;
float 纵向坐标单位数据 = (float) ((纵向最大值 - 纵向最小值)) / (纵向分段数);
float 纵向单位数据长度 = (float) (可用高度) / (纵向最大值 - 纵向最小值);
int Y线左边距 = 60;
int Y线到顶距 = 60;
float 横向坐标单位数据 = (float) ((横向最大值 - 横向最小值)) / (横向分段数);
float 横向单位数据长度 = (float) ((窗口宽度 - 200)) / (横向最大值 - 横向最小值);
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(new BasicStroke(2f));
g.drawLine(Y线左边距, Y线到顶距 - 10, Y线左边距, 可用高度 + Y线到顶距 + 5);
g.drawLine(Y线左边距, Y线到顶距 - 15, Y线左边距 - 3, Y线到顶距);
g.drawLine(Y线左边距, Y线到顶距 - 15, Y线左边距 + 2, Y线到顶距);
g.setColor(Color.RED);
g.drawString(dataStatistic12.fa0.getText(), Y线左边距 + 10, Y线到顶距 - 5);
// 以下计算回归曲线
int x = 0, y = 0;
int w0 = 5, h0 = 5;
float x和1 = 0f, y和1 = 0f, xy和1 = 0f, x平方和1 = 0f;
float x平均1 = 0f, y平均1 = 0f, Lxx1 = 0f, Lxy1 = 0f;
for (int i = 0; i < 记录条数; i++) {
x和1 = x和1 + 横向数据[i] / 横向系数;
y和1 = y和1 + 纵向数据[i] / 纵向系数;
xy和1 = xy和1 + 横向数据[i] * 纵向数据[i] / 纵向系数 / 横向系数;
x平方和1 = x平方和1 + 横向数据[i] * 横向数据[i] / 横向系数 / 横向系数;
float yyy = (纵向数据[i] - 纵向最小值) * 纵向单位数据长度;
yyy = 可用高度 + Y线到顶距 - yyy;
float xxx = (横向数据[i] - 横向最小值) * 横向单位数据长度 + Y线左边距;
g.fillOval((int) xxx, (int) yyy, w0, h0);
}
x平均1 = x和1 / 记录条数;
y平均1 = y和1 / 记录条数;
Lxx1 = x平方和1 - x和1 * x和1 / 记录条数;
Lxy1 = xy和1 - x和1 * y和1 / 记录条数;
String 回归方程1 = "回归方程1=" + "Y=" + (y平均1 - Lxy1 * x平均1 / Lxx1) + "+"
+ (Lxy1 / Lxx1) + "x";
g.drawString(回归方程1, 100, 窗口高度);
float x2, y2, z1; // x1,y1,
x2 = (横向最大值 - 横向最小值) * 横向单位数据长度 + Y线左边距;
y2 = ((y平均1 - Lxy1 * x平均1 / Lxx1) + (Lxy1 / Lxx1) * 横向最大值) - 纵向最小值;
y2 = 可用高度 + Y线到顶距 - y2 * 纵向单位数据长度;
g.setColor(Color.RED);
float xx1 = 横向最小值 / 横向系数;// 乘系数后值
float xx2 = 横向最大值 / 横向系数;// 乘系数后值
float yy1 = (y平均1 - Lxy1 * x平均1 / Lxx1) + (Lxy1 / Lxx1 * xx1); // 乘系数前值
float yy2 = (y平均1 - Lxy1 * x平均1 / Lxx1) + (Lxy1 / Lxx1 * xx2); // 乘系数前值
// 以下计算点的显示坐标值
xx1 = (xx1 * 横向系数 - 横向最小值) * 横向单位数据长度 + Y线左边距;
xx2 = (xx2 * 横向系数 - 横向最小值) * 横向单位数据长度 + Y线左边距;
yy1 = (yy1 * 纵向系数 - 纵向最小值) * 纵向单位数据长度;
yy2 = (yy2 * 纵向系数 - 纵向最小值) * 纵向单位数据长度;
yy1 = 可用高度 + Y线到顶距 - yy1;
yy2 = 可用高度 + Y线到顶距 - yy2;
g.drawLine((int) (xx1), (int) (yy1), (int) (xx2), (int) (yy2)); // 回归直线
String z0;
int y0 = 0;
for (int i = 0; i < 纵向分段数; i++) {
z1 = ((i + 1) * 纵向坐标单位数据 + 纵向最小值) / 纵向系数; // (int)
z0 = z1 + " ";
z0 = z0.substring(0, 6);
x = Y线左边距 - 40;
y = Y线到顶距 * 2 + 可用高度
- (int) (Y线左边距 + (i + 1) * 纵向单位数据长度 * 纵向坐标单位数据);
g.setColor(Color.RED);
g.drawString(z0, x, y); // 纵坐标标签
g.setColor(Color.BLACK);
g.drawLine(x + 35, y, x + 45, y); // 纵向单位点短线
}
// 以下画横向坐标线包括箭头、名称
g.drawLine(x, Y线到顶距 + 可用高度, x + 窗口宽度 - 80, Y线到顶距 + 可用高度); // 横向坐标延长线
g.drawLine(x + 窗口宽度 - 100, Y线到顶距 + 可用高度 - 3, x + 窗口宽度 - 80, Y线到顶距
+ 可用高度); // 横向箭头短线
g.drawLine(x + 窗口宽度 - 100, Y线到顶距 + 可用高度 + 3, x + 窗口宽度 - 80, Y线到顶距
+ 可用高度); // 横向箭头短线
g.setColor(Color.RED);
g.drawString(dataStatistic12.fa2.getText().toString(), x + 窗口宽度 - 120,
Y线到顶距 + 可用高度 + 20);
// 以下画横向坐标线标志
for (int i = 0; i < 横向分段数; i++) {
g.setColor(Color.RED);
z1 = ((i + 1) * 横向坐标单位数据 + 横向最小值) / 横向系数; // （int)
z0 = z1 + " ";
z0 = z0.substring(0, 6);
x = (int) (Y线左边距 + (i + 1) * 横向单位数据长度 * 横向坐标单位数据);
y = Y线到顶距 + 可用高度 + 6;
g.drawString(z0, x, y + 10);
g.setColor(Color.BLACK);
g.drawLine(x, y - 10, x, y - 5); // 横向单位点短线
}
}
}
70.源码70，部件程序，关系代数运算程序，可用于数据表间关系运算变换。
/*
* 程序文件名：dataStatistic13.java
* 作者：程学先
* 本程序用于关系代数实验，也可用于数据表间关系运算变换。
* 要求参数包括：表1名称，表2名称。
* 允许对数据表的结构及内容进行修改，关系运算将针对界面中显现的数据进行。
* 在第一页和第二页表现源表数据，用右键点击表格任意行列处将出现一个弹出式菜单。
* 在弹出菜单中选项可以进行添加一行、删除已行、添加一列、删除一列的操作
* 之后可以选择按钮操作，关系运算结果在第三页显示。
* 关系运算包括：求笛卡尔积、求并、交、差、选择、投影、连接、左连接、全连接、关系除。
* 为实验方便，在界面顶部准备了一个组合框和一个文本框，用于输入新的数据表名或文件名，
* 用新数据表或文件中的数据更新当前表，因此不退出程序便可进行多个项目的实验。
* 文件格式：每条记录一行，数据间用逗号分隔，数据不要加引号，前后不要加空格。
* 文件的第一行存放各列数据项名称，其数量和以下每条记录的数据数量要相同。
* 通过文件接入的数据将均被认为是char数据类型。
*/
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 dataStatistic13 extends JFrame implements ItemListener {
private static final ItemListener ItemListener = null;
private static dataStatistic13 frame1 = new dataStatistic13(); // 定义窗口
private static dataStatistic13 frame2 = new dataStatistic13();
private static dataStatistic13 frame3 = new dataStatistic13();
private static JPanel panel1 = new JPanel(); // 定义面板
private static JPanel panel2 = 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 JPopupMenu 弹出菜单 = new JPopupMenu();
private static JPopupMenu 弹出菜单2 = new JPopupMenu();
private static JLabel fl0, fl10, fl20, fl30;
private static JTextField fa10, fa30;
private static String[][] 表格数据1;
private static String[][] 表格数据2;
private static String[][] 表格数据3;
private static String 表名1;
private static String 表名2;
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;
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 String DBMS系统 = "sql server";
static String ODBC数据源 = "sql1";
private static Statement sta3;
private static ResultSet rs;
static String s1 = "", s2 = "", s3 = "", s4 = "", 当前值 = "";
static char x1 = 10, x2 = 13;
private static ResultSetMetaData rsmd;
static String[] 按钮集 = null;
static String 要求按钮号表;
static int 窗口宽 = 0, 窗口高 = 0, 按钮数 = 0, 按钮宽 = 0;
public static void means(String[] parameter) {
frame1 = new dataStatistic13();
frame2 = new dataStatistic13();
frame3 = new dataStatistic13();
panel1 = new JPanel(); // 定义面板
panel2 = new JPanel();
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
弹出菜单 = new JPopupMenu();
弹出菜单2 = new JPopupMenu();
记录条数1 = 0;
记录条数2 = 0;
记录条数3 = 0;
当前列号1 = 0;
当前列号2 = 0;
表1宽度 = 0;
表2宽度 = 0;
表3宽度 = 0;
list1 = new ArrayList();
fa0 = new Choice();
set1 = new HashSet();
set2 = new HashSet();
DBMS系统 = "sql server";
ODBC数据源 = "sql1";
s1 = "";
s2 = "";
s3 = "";
s4 = "";
当前值 = "";
x1 = 10;
x2 = 13;
String[] 按钮集01 = { "求笛卡尔积", "求并集", "求交集", "表1减表2", "求连接", "左连接", "全连接",
"表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) {
}
表名1 = parameter[4];
表名2 = parameter[2];
main1.driver1();
parameter[0] = "";
try {
String[] tableType = { "TABLE" };
Connection con;
con = main1.getConn();
DatabaseMetaData databaseMetaData = con.getMetaData();
ResultSet resultSet = databaseMetaData.getTables(null, null, "%",
tableType);
while (resultSet.next()) {
parameter[0] = parameter[0] + resultSet.getString("TABLE_NAME")
+ ",";
}
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "获取表名失败！");
}
frame1.setTitle("表1 作者：程学先");
frame2.setTitle("表2");
frame3.setTitle("运算结果 作者：程学先");
frame1.setBounds(10, 10, 1000, 660);
frame2.setBounds(100, 10, 1000, 660);
frame3.setBounds(200, 10, 1000, 660);
frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel1.setBounds(10, 10, 1000, 660);
panel2.setBounds(100, 10, 1000, 660);
panel3.setBounds(200, 10, 1000, 660);
panel1.setLayout(null);
panel2.setLayout(null);
panel3.setLayout(null);
if ((表名1 != null) && (表名1.length() > 0)) {
int c = 0;
int 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 String[列数1];
列数据宽度1 = new int[列数1];
for (int i = 0; i < 列数1; i++) {
列名1[i] = rsmd.getColumnName(i + 1);
一条记录1[i] = " ";
列数据类型1[i] = rsmd.getColumnTypeName(i + 1);
列数据宽度1[i] = rsmd.getColumnDisplaySize(i + 1);
表1宽度 = 表1宽度 + 列数据宽度1[i] * 4;
}
rs.last();
记录条数1 = rs.getRow();
表格数据1 = new String[记录条数1][列数1];
rs.absolute(1);
while (c < 记录条数1) {
rs.absolute(c + 1);
while (b < 列数1) {
表格数据1[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表1失败！" + s1);
return;
}
表格模型1 = new DefaultTableModel(表格数据1, 列名1);
表格1 = new JTable(表格模型1);
表格1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
表格1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
for (int i = 0; i < 列数1; i++) {
TableColumn tc = 表格1.getColumn(列名1[i]);
tc.setPreferredWidth(列数据宽度1[i] * 4);
}
scrollPane1.getViewport().add(表格1, null);
scrollPane1.setBounds(20, 60, 表1宽度, 450);
panel1.add(scrollPane1);
JMenuItem 子菜单1 = new JMenuItem("添加一行");
弹出菜单.add(子菜单1);
JMenuItem 子菜单2 = new JMenuItem("删除一行");
弹出菜单.add(子菜单2);
JMenuItem 子菜单3 = new JMenuItem("添加一列");
弹出菜单.add(子菜单3);
JMenuItem 子菜单4 = new JMenuItem("删除一列");
弹出菜单.add(子菜单4);
子菜单1.addActionListener(new ActionListener() { // 添加一行
public void actionPerformed(final ActionEvent arg0) {
表格模型1.addRow(一条记录1);
记录条数1++;
}
});
子菜单2.addActionListener(new ActionListener() { // 删除一行
public void actionPerformed(final ActionEvent arg0) {
表格模型1.removeRow(选中行号1);
记录条数1--;
}
});
子菜单3.addActionListener(new ActionListener() { // 添加一列
public void actionPerformed(final ActionEvent arg0) {
String 新列名 = JOptionPane.showInputDialog("请输入新列的名称：");
String[] s6 = new String[列数1 + 1];
int[] s7 = new int[列数1 + 1];
String[] s9 = new String[列数1 + 1];
String[][] s8 = new String[表格模型1.getRowCount()][列数1 + 1];
for (int j = 0; j < 列数1; j++) {
s6[j] = 列名1[j];
s7[j] = 列数据宽度1[j];
s9[j] = 列数据类型1[j];
for (int i = 0; i < 表格模型1.getRowCount(); i++) {
if (表格模型1.getValueAt(i, j) == null)
s8[i][j] = "";
else
s8[i][j] = 表格模型1.getValueAt(i, j).toString();
}
}
for (int i = 0; i < 表格模型1.getRowCount(); i++) {
s8[i][列数1] = "";
}
列数1++;
s6[列数1 - 1] = 新列名;
s7[列数1 - 1] = 30;
s9[列数1 - 1] = "char";
表1宽度 = 表1宽度 + 30;
表格数据1 = new String[表格模型1.getRowCount()][列数1];
列名1 = new String[列数1];
列数据宽度1 = new int[列数1];
列数据类型1 = new String[列数1];
for (int j = 0; j < 列数1; j++) {
列名1[j] = s6[j];
列数据宽度1[j] = s7[j];
列数据类型1[j] = s9[j];
for (int i = 0; i < 表格模型1.getRowCount(); i++) {
表格数据1[i][j] = s8[i][j];
}
}
scrollPane1.setBounds(20, 60, 表1宽度 * 4, 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] * 4);
}
panel1.add(scrollPane1);
表格1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
弹出菜单.show(表格1, e.getX() + 100, e.getY());
选中行号1 = 表格1.rowAtPoint(e.getPoint());
当前列号1 = 表格1.columnAtPoint(e.getPoint());
}
}
});
}
});
子菜单4.addActionListener(new ActionListener() { // 删除一列
public void actionPerformed(final ActionEvent arg0) {
表1宽度 = 表1宽度 - 列数据宽度1[当前列号1];
列数1 = 列数1 - 1;
String[] s6 = new String[列数1];
int[] s7 = new int[列数1];
String[] s8 = new String[列数1];
表1宽度 = 0;
for (int i = 0; i < 列数1; i++) {
if (i < 当前列号1) {
s6[i] = 列名1[i];
s7[i] = 列数据宽度1[i];
s8[i] = 列数据类型1[i];
} else {
s6[i] = 列名1[i + 1];
s7[i] = 列数据宽度1[i + 1];
s8[i] = 列数据类型1[i + 1];
}
表1宽度 = 表1宽度 + s7[i];
}
列名1 = new String[列数1];
列数据宽度1 = new int[列数1];
列数据类型1 = new String[列数1];
for (int i = 0; i < 列数1; i++) {
列名1[i] = s6[i];
列数据宽度1[i] = s7[i];
列数据类型1[i] = s8[i];
}
表格数据1 = new String[表格模型1.getRowCount()][列数1];
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) { // 读取当前表格数据
for (int j = 0; j < 列数1; j++) {
if (j < 当前列号1) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据1[i1][j] = "";
else
表格数据1[i1][j] = 表格模型1.getValueAt(i1, j)
.toString();
} else {
if (表格模型1.getValueAt(i1, j + 1) == null)
表格数据1[i1][j] = "";
else
表格数据1[i1][j] = 表格模型1.getValueAt(i1, j + 1)
.toString();
}
}
}
scrollPane1.setBounds(20, 60, 表1宽度 * 4, 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] * 4);
}
panel1.add(scrollPane1);
表格1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
弹出菜单.show(表格1, e.getX() + 100, e.getY());
选中行号1 = 表格1.rowAtPoint(e.getPoint());
当前列号1 = 表格1.columnAtPoint(e.getPoint());
}
}
});
}
});
表格1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
弹出菜单.show(表格1, e.getX() + 100, e.getY());
选中行号1 = 表格1.rowAtPoint(e.getPoint());
当前列号1 = 表格1.columnAtPoint(e.getPoint());
}
}
});
}
if ((表名2 != null) && (表名2.length() > 0)) {
int c = 0;
int b = 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];
一条记录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] = " ";
列数据类型2[i] = rsmd.getColumnTypeName(i + 1);
列数据宽度2[i] = rsmd.getColumnDisplaySize(i + 1);
表2宽度 = 表2宽度 + 列数据宽度2[i] * 4;
}
rs.last();
记录条数2 = rs.getRow();
表格数据2 = new String[记录条数2][列数2];
rs.absolute(1);
while (c < 记录条数2) {
rs.absolute(c + 1);
while (b < 列数2) {
表格数据2[c][b] = rs.getString(b + 1);
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(20, 60, 表2宽度, 450);
panel2.add(scrollPane2);
for (int i = 0; i < 列数2; i++) {
TableColumn tc = 表格2.getColumn(列名2[i]);
tc.setPreferredWidth(列数据宽度2[i] * 4);
}
panel2.add(scrollPane2);
表格2.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
弹出菜单2.show(表格2, e.getX() + 100, e.getY());
选中行号2 = 表格2.rowAtPoint(e.getPoint());
当前列号2 = 表格2.columnAtPoint(e.getPoint());
}
}
});
JMenuItem 子菜单12 = new JMenuItem("添加一行");
弹出菜单2.add(子菜单12);
JMenuItem 子菜单22 = new JMenuItem("删除一行");
弹出菜单2.add(子菜单22);
JMenuItem 子菜单32 = new JMenuItem("添加一列");
弹出菜单2.add(子菜单32);
JMenuItem 子菜单42 = new JMenuItem("删除一列");
弹出菜单2.add(子菜单42);
子菜单12.addActionListener(new ActionListener() { // 添加一行
public void actionPerformed(final ActionEvent arg0) {
表格模型2.addRow(一条记录1);
记录条数2++;
}
});
子菜单22.addActionListener(new ActionListener() { // 删除一行
public void actionPerformed(final ActionEvent arg0) {
表格模型2.removeRow(选中行号2);
记录条数2--;
}
});
子菜单32.addActionListener(new ActionListener() { // 添加一列
public void actionPerformed(final ActionEvent arg0) {
String 新列名 = JOptionPane.showInputDialog("请输入新列的名称：");
String[] s16 = new String[列数2 + 1];
int[] s17 = new int[列数2 + 1];
String[] s19 = new String[列数2 + 1];
String[][] s18 = new String[表格模型2.getRowCount()][列数2 + 1];
for (int j = 0; j < 列数2; j++) {
s16[j] = 列名2[j];
s17[j] = 列数据宽度2[j];
s19[j] = 列数据类型2[j];
for (int i = 0; i < 表格模型2.getRowCount(); i++) {
if (表格模型2.getValueAt(i, j) == null)
s18[i][j] = "";
else
s18[i][j] = 表格模型2.getValueAt(i, j).toString();
}
}
for (int i = 0; i < 表格模型2.getRowCount(); i++) {
s18[i][列数2] = "";
}
列数2++;
s16[列数2 - 1] = 新列名;
s17[列数2 - 1] = 30;
s19[列数2 - 1] = "char";
表2宽度 = 表2宽度 + 30;
表格数据2 = new String[表格模型2.getRowCount()][列数2];
列名2 = new String[列数2];
列数据宽度2 = new int[列数2];
列数据类型2 = new String[列数2];
for (int j = 0; j < 列数2; j++) {
列名2[j] = s16[j];
列数据宽度2[j] = s17[j];
列数据类型2[j] = s19[j];
for (int i = 0; i < 表格模型2.getRowCount(); i++) {
表格数据2[i][j] = s18[i][j];
}
}
scrollPane2.setBounds(20, 60, 表2宽度 * 4, 450);
表格模型2 = new DefaultTableModel(表格数据2, 列名2);
表格2 = new JTable(表格模型2);
表格2.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(表格2, null);
for (int i = 0; i < 列数2; i++) {
TableColumn tc = 表格2.getColumn(列名2[i]);
tc.setPreferredWidth(列数据宽度2[i] * 4);
}
panel2.add(scrollPane2);
表格2.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
弹出菜单2.show(表格2, e.getX() + 100, e.getY());
选中行号2 = 表格2.rowAtPoint(e.getPoint());
当前列号2 = 表格2.columnAtPoint(e.getPoint());
}
}
});
}
});
子菜单42.addActionListener(new ActionListener() { // 删除一列
public void actionPerformed(final ActionEvent arg0) {
表2宽度 = 表2宽度 - 列数据宽度2[当前列号2];
列数2 = 列数2 - 1;
String[] s6 = new String[列数2];
int[] s7 = new int[列数2];
String[] s8 = new String[列数2];
表2宽度 = 0;
for (int i = 0; i < 列数2; i++) {
if (i < 当前列号2) {
s6[i] = 列名2[i];
s7[i] = 列数据宽度2[i];
s8[i] = 列数据类型2[i];
} else {
s6[i] = 列名2[i + 1];
s7[i] = 列数据宽度2[i + 1];
s8[i] = 列数据类型2[i + 1];
}
表2宽度 = 表2宽度 + s7[i];
}
列名2 = new String[列数2];
列数据宽度2 = new int[列数2];
列数据类型2 = new String[列数2];
for (int i = 0; i < 列数2; i++) {
列名2[i] = s6[i];
列数据宽度2[i] = s7[i];
列数据类型2[i] = s8[i];
}
表格数据2 = new String[表格模型2.getRowCount()][列数2];
for (int i1 = 0; i1 < 表格模型2.getRowCount(); i1++) { // 读取当前表格数据
for (int j = 0; j < 列数2; j++) {
if (j < 当前列号2) {
if (表格模型2.getValueAt(i1, j) == null)
表格数据2[i1][j] = "";
else
表格数据2[i1][j] = 表格模型2.getValueAt(i1, j)
.toString();
} else {
if (表格模型2.getValueAt(i1, j + 1) == null)
表格数据2[i1][j] = "";
else
表格数据2[i1][j] = 表格模型2.getValueAt(i1, j + 1)
.toString();
}
}
}
scrollPane2.setBounds(20, 60, 表2宽度 * 4, 450);
表格模型2 = new DefaultTableModel(表格数据2, 列名2);
表格2 = new JTable(表格模型2);
表格2.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(表格2, null);
for (int i = 0; i < 列数2; i++) {
TableColumn tc = 表格2.getColumn(列名2[i]);
tc.setPreferredWidth(列数据宽度2[i] * 4);
}
panel2.add(scrollPane2);
表格2.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
弹出菜单2.show(表格2, e.getX() + 100, e.getY());
选中行号2 = 表格2.rowAtPoint(e.getPoint());
当前列号2 = 表格2.columnAtPoint(e.getPoint());
}
}
});
}
});
}
fl0 = new JLabel("数据表1表名1");
fl0.setBounds(40, 10, 90, 20);
panel1.add(fl0);
String[] s9 = parameter[0].split(",");
fa0.setBounds(130, 10, 150, 20);
for (int i = 0; i < s9.length; i++)
fa0.add(s9[i]);
panel1.add(fa0);
fa0.addItemListener(frame1);
fl10 = new JLabel("数据表1文件名1");
fl10.setBounds(310, 10, 100, 20);
panel1.add(fl10);
fa10 = new JTextField("", 20);
fa10.setBounds(410, 10, 150, 20);
panel1.add(fa10);
fa10.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (fa10.getText().length() < 1) {
final JFileChooser fc = new JFileChooser(".\\");
fc.showOpenDialog(null);
if (fc.getSelectedFile() != null) {
fa10.setText(fc.getSelectedFile().toString());
File file1 = new File(fa10.getText());
try {
if (file1.exists()) {
FileReader fr = new FileReader(file1);
BufferedReader br = new BufferedReader(fr);
String tempStr = null;
记录条数1 = 0;
String[][] s29 = new String[10][10];
;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
if (i == 0) {
列名1 = tempStr.split(",");
列数1 = 列名1.length;
s29 = new String[100][列数1];
} else {
s29[记录条数1] = tempStr.split(",");
记录条数1++;
}
}
表格数据1 = new String[记录条数1][列数1];
列数据宽度1 = new int[列数1];
列数据类型1 = new String[列数1];
for (int j = 0; j < 列数1; j++) {
列数据类型1[j] = "char";
}
for (int i = 0; i < 记录条数1; i++) {
for (int j = 0; j < 列数1; j++) {
表格数据1[i][j] = s29[i][j];
if (表格数据1[i][j].length() > 列数据宽度1[j])
列数据宽度1[j] = 表格数据1[i][j].length();
}
}
表1宽度 = 0;
for (int j = 0; j < 列数1; j++) {
表1宽度 = 表1宽度 + 列数据宽度1[j] * 20;
}
}
} catch (IOException e2) {
JOptionPane.showMessageDialog(null, "打开文件错！");
}
scrollPane1.setBounds(20, 60, 表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] * 20);
}
panel1.add(scrollPane1);
表格1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
弹出菜单.show(表格1, e.getX() + 100, e.getY());
选中行号1 = 表格1.rowAtPoint(e.getPoint());
当前列号1 = 表格1.columnAtPoint(e.getPoint());
}
}
});
}
}
}
});
fl20 = new JLabel("数据表表名2");
fl20.setBounds(40, 10, 90, 20);
panel2.add(fl20);
String[] s09 = parameter[0].split(",");
final JComboBox fa20 = new JComboBox();
fa20.setBounds(130, 10, 150, 20);
for (int i = 0; i < s09.length; i++)
fa20.addItem(s09[i]);
panel2.add(fa20);
fa20.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent arg0) {
try {
con = main1.getConn();// 连接数据库
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + fa20.getSelectedItem();
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数2 = rsmd.getColumnCount();
列名2 = new String[列数2];
一条记录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] = " ";
列数据类型2[i] = rsmd.getColumnTypeName(i + 1);
列数据宽度2[i] = rsmd.getColumnDisplaySize(i + 1);
表2宽度 = 表2宽度 + 列数据宽度2[i] * 4;
}
rs.last();
记录条数2 = rs.getRow();
表格数据2 = new String[记录条数2][列数2];
rs.absolute(1);
int c = 0, b = 0;
while (c < 记录条数2) {
rs.absolute(c + 1);
while (b < 列数2) {
表格数据2[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表2失败！" + s1);
return;
}
scrollPane2.setBounds(20, 60, 表2宽度, 450);
表格模型2 = new DefaultTableModel(表格数据2, 列名2);
表格2 = new JTable(表格模型2);
表格2.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(表格2, null);
for (int i = 0; i < 列数2; i++) {
TableColumn tc = 表格2.getColumn(列名2[i]);
tc.setPreferredWidth(列数据宽度2[i] * 4);
}
panel2.add(scrollPane2);
表格2.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
弹出菜单2.show(表格2, e.getX() + 100, e.getY());
选中行号2 = 表格2.rowAtPoint(e.getPoint());
当前列号2 = 表格2.columnAtPoint(e.getPoint());
}
}
});
}
});
fl30 = new JLabel("数据表1文件名1");
fl30.setBounds(310, 10, 100, 20);
panel2.add(fl30);
fa30 = new JTextField("", 20);
fa30.setBounds(410, 10, 150, 20);
panel2.add(fa30);
fa30.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (fa30.getText().length() < 1) {
final JFileChooser fc1 = new JFileChooser(".\\");
fc1.showOpenDialog(null);
if (fc1.getSelectedFile() != null) {
fa30.setText(fc1.getSelectedFile().toString());
File file1 = new File(fa30.getText());
try {
if (file1.exists()) {
FileReader fr = new FileReader(file1);
BufferedReader br = new BufferedReader(fr);
String tempStr = null;
记录条数2 = 0;
String[][] s9 = new String[10][10];
;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
if (i == 0) {
列名2 = tempStr.split(",");
列数2 = 列名2.length;
s9 = new String[100][列数2];
} else {
s9[记录条数2] = tempStr.split(",");
记录条数2++;
}
}
表格数据2 = new String[记录条数2][列数2];
列数据宽度2 = new int[列数2];
列数据类型2 = new String[列数2];
for (int j = 0; j < 列数2; j++) {
列数据类型2[j] = "char";
}
for (int i = 0; i < 记录条数2; i++) {
for (int j = 0; j < 列数2; j++) {
表格数据2[i][j] = s9[i][j];
if (表格数据2[i][j].length() > 列数据宽度2[j])
列数据宽度2[j] = 表格数据2[i][j].length();
}
}
表2宽度 = 0;
for (int j = 0; j < 列数2; j++) {
表2宽度 = 表2宽度 + 列数据宽度2[j] * 20;
}
}
} catch (IOException e2) {
JOptionPane.showMessageDialog(null, "打开文件错！");
}
scrollPane2.setBounds(20, 60, 表2宽度, 450);
表格模型2 = new DefaultTableModel(表格数据2, 列名2);
表格2 = new JTable(表格模型2);
表格2.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(表格2, null);
for (int i = 0; i < 列数2; i++) {
TableColumn tc = 表格2.getColumn(列名2[i]);
tc.setPreferredWidth(列数据宽度2[i] * 20);
}
panel2.add(scrollPane2);
表格2.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
弹出菜单2.show(表格2, e.getX() + 100, e.getY());
选中行号2 = 表格2.rowAtPoint(e.getPoint());
当前列号2 = 表格2.columnAtPoint(e.getPoint());
}
}
});
}
}
}
});
按钮宽 = (窗口宽 - 60) / 按钮数;
int 左边距 = 30;
final JButton 笛卡尔积 = new JButton(按钮集[0]);
笛卡尔积.setBounds(左边距, 540, 按钮宽, 20);
笛卡尔积.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
表3宽度 = 表1宽度 + 表2宽度;
列数3 = 列数1 + 列数2;
列名3 = new String[列数3];
列数据宽度3 = new int[列数3];
表格数据3 = new String[表格模型1.getRowCount() * 表格模型2.getRowCount()][列数3];
列数据类型3 = new String[列数3];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
列数据宽度3[j] = 列数据宽度1[j];
}
for (int j = 0; j < 列数2; j++) {
列数据类型3[j + 列数1] = 列数据类型2[j];
列名3[j + 列数1] = 列名2[j];
列数据宽度3[j + 列数1] = 列数据宽度2[j];
}
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
for (int i2 = 0; i2 < 表格模型2.getRowCount(); i2++) {
int n2 = 表格模型2.getRowCount();
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[i1 * n2 + i2][j] = "";
else
表格数据3[i1 * n2 + i2][j] = 表格模型1
.getValueAt(i1, j).toString();
}
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null)
表格数据3[i1 * n2 + i2][j + 列数1] = "";
else
表格数据3[i1 * n2 + i2][j + 列数1] = 表格模型2
.getValueAt(i2, j).toString();
}
}
}
scrollPane3.setBounds(20, 60, 表3宽度 * 4, 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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",0,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel1.add(笛卡尔积);
}
final JButton 求并集 = new JButton(按钮集[1]);
求并集.setBounds(左边距, 540, 按钮宽, 20);
求并集.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
表3宽度 = 表1宽度;
if (列数1 != 列数2) {
JOptionPane.showMessageDialog(null, "二表列数不相等，不能求并集！" + s1);
return;
}
表格模型3 = new DefaultTableModel(表格数据1, 列名1);
列数3 = 列数1;
列名3 = new String[列数3];
列数据宽度3 = new int[列数3];
表格数据3 = new String[表格模型1.getRowCount()][列数3];
for (int j = 0; j < 列数1; j++) {
列名3[j] = 列名1[j];
列数据宽度3[j] = 列数据宽度1[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
s6 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[i1][j] = "";
else {
表格数据3[i1][j] = 表格模型1.getValueAt(i1, j).toString();
s6 = s6 + 表格数据3[i1][j].trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = 表格模型2.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null) {
s6 = s6 + "";
表格模型2.setValueAt("", i2, j);
一条记录1[j] = "";
} else {
s6 = s6 + 表格模型2.getValueAt(i2, j).toString().trim();
一条记录1[j] = 表格模型2.getValueAt(i2, j).toString();
}
}
set1.add(s6);
if (set1.size() != size1) {
size1 = set1.size();
表格模型3.addRow(一条记录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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",1,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel1.add(求并集);
}
final JButton 求交集 = new JButton(按钮集[2]);
求交集.setBounds(左边距, 540, 按钮宽, 20);
求交集.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];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
列数据宽度3[j] = 列数据宽度1[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
s6 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) != null) {
s6 = s6 + 表格模型1.getValueAt(i1, j).toString().trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = 表格模型2.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null) {
s6 = s6 + "";
一条记录1[j] = "";
} else {
s6 = s6 + 表格模型2.getValueAt(i2, j).toString().trim();
一条记录1[j] = 表格模型2.getValueAt(i2, j).toString();
}
}
set1.add(s6);
if (set1.size() == size1) {
if (表3记录数 == 0) {
表3记录数 = 1;
表格数据3 = new String[1][列数1];
for (int j = 0; j < 列数1; j++) {
表格数据3[0][j] = 一条记录1[j];
}
表格模型3 = new DefaultTableModel(表格数据3, 列名1);
} else
表格模型3.addRow(一条记录1);
} else
size1 = set1.size();
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",2,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel1.add(求交集);
}
final JButton 表1减表2 = new JButton(按钮集[3]);
表1减表2.setBounds(左边距, 540, 按钮宽, 20);
表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];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
列数据宽度3[j] = 列数据宽度1[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < 表格模型2.getRowCount(); i1++) {
int n1 = 表格模型2.getRowCount();
s6 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型2.getValueAt(i1, j) != null) {
s6 = s6 + 表格模型2.getValueAt(i1, j).toString().trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = 表格模型1.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < 列数2; j++) {
if (表格模型1.getValueAt(i2, j) == null) {
s6 = s6 + "";
一条记录1[j] = "";
} else {
s6 = s6 + 表格模型1.getValueAt(i2, j).toString().trim();
一条记录1[j] = 表格模型1.getValueAt(i2, j).toString();
}
}
set1.add(s6);
if (set1.size() != size1) {
if (表3记录数 == 0) {
表3记录数 = 1;
表格数据3 = new String[1][列数1];
for (int j = 0; j < 列数1; j++) {
表格数据3[0][j] = 一条记录1[j];
}
表格模型3 = new DefaultTableModel(表格数据3, 列名1);
} else
表格模型3.addRow(一条记录1);
} else
size1 = set1.size();
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",3,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel1.add(表1减表2);
}
final JButton 求连接 = new JButton(按钮集[4]);
求连接.setBounds(左边距, 540, 按钮宽, 20);
求连接.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<列名1><关系符><列名2>" + x1 + x2
+ "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int 序号1 = 0, 序号2 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < 列数1; i++)
if (s8[0].trim().equals(列名1[i].trim()))
序号1 = i;
String 类型 = "";
if (main1.数字数据类型.lastIndexOf("," + 列数据类型1[序号1] + ",") >= 0)
类型 = "数字";
else
类型 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < 列数2; i++)
if (s8[1].trim().equals(列名2[i].trim()))
序号2 = i;
for (int i = 0; i < 列数1; i++)
for (int j = 0; j < 列数2; j++)
if (列名1[i].trim().equals(列名2[j].trim()))
list1.add(列名1[i]);
表3宽度 = 表1宽度 + 表2宽度;
列数3 = 列数1 + 列数2;
列名3 = new String[列数3];
列数据宽度3 = new int[列数3];
表格数据3 = new String[1][列数3];
列数据类型3 = new String[列数3];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
表格数据3[0][j] = "";
列数据宽度3[j] = 列数据宽度1[j];
}
for (int j = 0; j < 列数2; j++) {
列数据类型3[j + 列数1] = 列数据类型2[j];
列名3[j + 列数1] = 列名2[j];
表格数据3[0][j + 列数1] = "";
列数据宽度3[j + 列数1] = 列数据宽度2[j];
}
int 标志 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
for (int i2 = 0; i2 < 表格模型2.getRowCount(); i2++) {
int n2 = 表格模型2.getRowCount();
if (表格模型1.getValueAt(i1, 序号1) == null)
s1 = "";
else
s1 = 表格模型1.getValueAt(i1, 序号1).toString();
if (表格模型2.getValueAt(i2, 序号2) == null)
s2 = "";
else
s2 = 表格模型2.getValueAt(i2, 序号2).toString();
if (condition1(s1, s7, s2, 类型)) {
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[0][j] = "";
else
表格数据3[0][j] = 表格模型1.getValueAt(i1, j)
.toString().trim();
}
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null)
表格数据3[0][j + 列数1] = "";
else
表格数据3[0][j + 列数1] = 表格模型2.getValueAt(i2, j)
.toString().trim();
}
if (标志 == 0) {
标志 = 1;
表格模型3 = new DefaultTableModel(表格数据3, 列名3);
} else
表格模型3.addRow(表格数据3[0]);
}
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",4,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel1.add(求连接);
}
final JButton 左连接 = new JButton(按钮集[5]);
左连接.setBounds(左边距, 540, 按钮宽, 20);
左连接.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<列名1><关系符><列名2>" + x1 + x2
+ "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int 序号1 = 0, 序号2 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < 列数1; i++)
if (s8[0].trim().equals(列名1[i].trim()))
序号1 = i;
String 类型 = "";
if (main1.数字数据类型.lastIndexOf("," + 列数据类型1[序号1] + ",") >= 0)
类型 = "数字";
else
类型 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < 列数2; i++)
if (s8[1].trim().equals(列名2[i].trim()))
序号2 = i;
for (int i = 0; i < 列数1; i++)
for (int j = 0; j < 列数2; j++)
if (列名1[i].trim().equals(列名2[j].trim()))
list1.add(列名1[i]);
表3宽度 = 表1宽度 + 表2宽度;
列数3 = 列数1 + 列数2;
列名3 = new String[列数3];
列数据宽度3 = new int[列数3];
表格数据3 = new String[1][列数3];
列数据类型3 = new String[列数3];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
表格数据3[0][j] = "";
列数据宽度3[j] = 列数据宽度1[j];
}
for (int j = 0; j < 列数2; j++) {
列数据类型3[j + 列数1] = 列数据类型2[j];
列名3[j + 列数1] = 列名2[j];
表格数据3[0][j + 列数1] = "";
列数据宽度3[j + 列数1] = 列数据宽度2[j];
}
int 标志 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
for (int i2 = 0; i2 < 表格模型2.getRowCount(); i2++) {
int n2 = 表格模型2.getRowCount();
if (表格模型1.getValueAt(i1, 序号1) == null)
s1 = "";
else
s1 = 表格模型1.getValueAt(i1, 序号1).toString();
if (表格模型2.getValueAt(i2, 序号2) == null)
s2 = "";
else
s2 = 表格模型2.getValueAt(i2, 序号2).toString();
if (condition1(s1, s7, s2, 类型)) {
s3 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[0][j] = "";
else
表格数据3[0][j] = 表格模型1.getValueAt(i1, j)
.toString().trim();
s3 = s3 + 表格数据3[0][j];
}
set1.add(s3);
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null)
表格数据3[0][j + 列数1] = "";
else
表格数据3[0][j + 列数1] = 表格模型2.getValueAt(i2, j)
.toString().trim();
}
if (标志 == 0) {
标志 = 1;
表格模型3 = new DefaultTableModel(表格数据3, 列名3);
} else
表格模型3.addRow(表格数据3[0]);
}
}
}
for (int j = 0; j < 列数2; j++) {
表格数据3[0][j + 列数1] = "";
}
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n = set1.size();
s3 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[0][j] = "";
else
表格数据3[0][j] = 表格模型1.getValueAt(i1, j).toString()
.trim();
s3 = s3 + 表格数据3[0][j];
}
set1.add(s3);
if (set1.size() != n) {
n = set1.size();
表格模型3.addRow(表格数据3[0]);
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",5,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel1.add(左连接);
}
final JButton 全连接 = new JButton(按钮集[6]);
全连接.setBounds(左边距, 540, 按钮宽, 20);
全连接.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
set2.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<列名1><关系符><列名2>" + x1 + x2
+ "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int 序号1 = 0, 序号2 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < 列数1; i++)
if (s8[0].trim().equals(列名1[i].trim()))
序号1 = i;
String 类型 = "";
if (main1.数字数据类型.lastIndexOf("," + 列数据类型1[序号1] + ",") >= 0)
类型 = "数字";
else
类型 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < 列数2; i++)
if (s8[1].trim().equals(列名2[i].trim()))
序号2 = i;
for (int i = 0; i < 列数1; i++)
for (int j = 0; j < 列数2; j++)
if (列名1[i].trim().equals(列名2[j].trim()))
list1.add(列名1[i]);
表3宽度 = 表1宽度 + 表2宽度;
列数3 = 列数1 + 列数2;
列名3 = new String[列数3];
列数据宽度3 = new int[列数3];
表格数据3 = new String[1][列数3];
列数据类型3 = new String[列数3];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
表格数据3[0][j] = "";
列数据宽度3[j] = 列数据宽度1[j];
}
for (int j = 0; j < 列数2; j++) {
列数据类型3[j + 列数1] = 列数据类型2[j];
列名3[j + 列数1] = 列名2[j];
表格数据3[0][j + 列数1] = "";
列数据宽度3[j + 列数1] = 列数据宽度2[j];
}
int 标志 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
for (int i2 = 0; i2 < 表格模型2.getRowCount(); i2++) {
int n2 = 表格模型2.getRowCount();
if (表格模型1.getValueAt(i1, 序号1) == null)
s1 = "";
else
s1 = 表格模型1.getValueAt(i1, 序号1).toString();
if (表格模型2.getValueAt(i2, 序号2) == null)
s2 = "";
else
s2 = 表格模型2.getValueAt(i2, 序号2).toString();
if (condition1(s1, s7, s2, 类型)) {
s3 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[0][j] = "";
else
表格数据3[0][j] = 表格模型1.getValueAt(i1, j)
.toString().trim();
s3 = s3 + 表格数据3[0][j];
}
set1.add(s3);
s4 = "";
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null)
表格数据3[0][j + 列数1] = "";
else
表格数据3[0][j + 列数1] = 表格模型2.getValueAt(i2, j)
.toString().trim();
s4 = s4 + 表格数据3[0][j + 列数1];
}
set2.add(s4);
if (标志 == 0) {
标志 = 1;
表格模型3 = new DefaultTableModel(表格数据3, 列名3);
} else
表格模型3.addRow(表格数据3[0]);
}
}
}
for (int j = 0; j < 列数2; j++) {
表格数据3[0][j + 列数1] = "";
}
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n = set1.size();
s3 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[0][j] = "";
else
表格数据3[0][j] = 表格模型1.getValueAt(i1, j).toString()
.trim();
s3 = s3 + 表格数据3[0][j];
}
set1.add(s3);
if (set1.size() != n) {
n = set1.size();
表格模型3.addRow(表格数据3[0]);
}
}
for (int j = 0; j < 列数1; j++) {
表格数据3[0][j] = "";
}
for (int i2 = 0; i2 < 表格模型2.getRowCount(); i2++) {
int n = set2.size();
s4 = "";
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null)
表格数据3[0][j + 列数1] = "";
else
表格数据3[0][j + 列数1] = 表格模型2.getValueAt(i2, j)
.toString().trim();
s4 = s4 + 表格数据3[0][j + 列数1];
}
set2.add(s4);
if (set2.size() != n) {
n = set2.size();
表格模型3.addRow(表格数据3[0]);
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",6,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel1.add(全连接);
}
final JButton 表1除以表2 = new JButton(按钮集[7]);
表1除以表2.setBounds(左边距, 540, 按钮宽, 20);
表1除以表2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String s6 = JOptionPane.showInputDialog("请输入分组字段与要求包含的字段名："
+ x1 + x2 + "格式：<分组字段名集><。><包含字段名集>" + x1 + x2
+ "其中，分组字段名集是表1中某些列的名字，是商集的字段名，用逗号分隔" + x1 + x2
+ "要求包含的字段名是表1与表2中都有的某些列的名字。" + x1 + x2
+ "例如：学号,姓名。课程名");
String[] s8 = s6.split("。");
列名3 = s8[0].split(",");
String[] 包含字段名 = s8[1].split(",");
列数3 = 列名3.length;
int[] 分组字段号 = new int[列数3];
int[] 包含字段号 = new int[包含字段名.length];
int[] 包含字段号2 = new int[包含字段名.length];
String[][] 临时商 = new String[1000][列数3];
int[] 组包含数量 = new int[1000];
列数据宽度3 = new int[列数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];
}
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宽度 * 8, 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] * 8);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",7,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel1.add(表1除以表2);
}
final JButton 选择 = new JButton(按钮集[8]);
选择.setBounds(左边距, 540, 按钮宽, 20);
选择.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String g6 = JOptionPane.showInputDialog("请输入选择条件：" + x1 + x2
+ "条件式由若干个分条件式经逻辑关系符连接构成。" + x1 + x2
+ "格式：<分条件1>[<逻辑关系><分条件2>][<逻辑关系><分条件3>]" + x1 + x2
+ "其中，逻辑关系包括and、or。前后需有空格。" + x1 + x2 + "本程序不能识别括号。"
+ x1 + x2 + "分条件式由字段名、关系符、数据值（或字段名）构成。必须以字段名开始。" + x1
+ x2 + "格式1：<字段名>[<关系符><数据值>" + x1 + x2
+ "格式2：<字段名>[<关系符><字段名>" + x1 + x2
+ "例如：学号>201102 and 性别=男" + x1 + x2 + "又例如：津贴>基本工资");
g6 = g6.toUpperCase();
String g7 = g6;
g7 = g7.replaceAll("OR", "AND");
String[] g8 = g7.split(" AND ");
int[] g9 = new int[g8.length];
if (g8.length > 1) {
g9[g8.length - 1] = g7.length();
int k = 0;
for (int i = 0; i < g7.length(); i++) {
if (k < g8.length - 1)
g9[k] = g7.indexOf(" AND ", i);
i = g9[k];
k++;
}
}
int 序号1 = 0, 序号2 = 0;
String 类型 = "";
String s6 = "";
String s7 = "";
String[] s8 = new String[1];
boolean[] l1 = new boolean[表格模型1.getRowCount()];
int 标志 = 0;
for (int i = 0; i < g8.length; i++) {
s6 = g8[i];
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
序号1 = 0;
序号2 = 0;
for (int i1 = 0; i1 < 列数1; i1++)
if (s8[0].trim().equals(列名1[i1].toUpperCase().trim()))
序号1 = i1;
类型 = "";
if (main1.数字数据类型.lastIndexOf("," + 列数据类型1[序号1] + ",") >= 0)
类型 = "数字";
else
类型 = "字符串";
序号2 = -1;
for (int i2 = 0; i2 < 列数1; i2++)
if (s8[1].trim().equals(列名1[i2].toUpperCase().trim()))
序号2 = i2;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
if (表格模型1.getValueAt(i1, 序号1) == null)
s1 = "";
else
s1 = 表格模型1.getValueAt(i1, 序号1).toString().trim();
if (序号2 > 0)
if (表格模型1.getValueAt(i1, 序号2) == null)
s2 = "";
else
s2 = 表格模型1.getValueAt(i1, 序号2).toString()
.trim();
else
s2 = s8[1];
if (i == 0)
l1[i1] = condition1(s1, s7, s2, 类型);
else {
if (标志 == 0)
l1[i1] = l1[i1] && condition1(s1, s7, s2, 类型);
else
l1[i1] = l1[i1] || condition1(s1, s7, s2, 类型);
}
if (i < g8.length - 1) {
if (g6.substring(g9[i], g9[i] + 4).lastIndexOf(
"AND") > 0)
标志 = 0;
else
标志 = 1;
}
}
}
记录条数3 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++)
if (l1[i1])
记录条数3++;
表格数据3 = new String[记录条数3][列数1];
记录条数3 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
if (l1[i1]) {
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[记录条数3][j] = "";
else
表格数据3[记录条数3][j] = 表格模型1.getValueAt(i1, j)
.toString().trim();
}
记录条数3++;
}
}
列数据类型3 = new String[列数1];
列数据宽度3 = new int[列数1];
for (int i1 = 0; i1 < 列数1; i1++) {
列数据类型3[i1] = 列数据类型1[i1];
列数据宽度3[i1] = 列数据宽度1[i1];
}
scrollPane3.setBounds(20, 60, 表1宽度 * 8, 450);
表格模型3 = new DefaultTableModel(表格数据3, 列名1);
表格3 = new JTable(表格模型3);
表格3.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(表格3, null);
for (int i = 0; i < 列数1; i++) {
TableColumn tc = 表格3.getColumn(列名1[i]);
tc.setPreferredWidth(列数据宽度1[i] * 8);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",8,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel1.add(选择);
}
final JButton 投影 = new JButton(按钮集[9]);
投影.setBounds(左边距, 540, 按钮宽, 20);
投影.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String g6 = JOptionPane.showInputDialog("请输入字段名称集：" + x1 + x2
+ "可以是字段名称，之间用逗号分隔。" + x1 + x2
+ "也可以是字段号，用中括号括起，之间用逗号分隔。" + x1 + x2 + "字段号从1起计数。"
+ x1 + x2 + "例如：学号,姓名,性别,班级,出生日期。" + x1 + x2
+ "又例如：[1],[2],[4],[6]");
String[] s6;
int[] 字段序号;
表3宽度 = 0;
if (g6.lastIndexOf("]") >= 0) {
g6 = g6.substring(g6.indexOf("[") + 1, g6.lastIndexOf("]"));
s6 = g6.split("\\],\\[");
字段序号 = new int[s6.length];
列名3 = new String[s6.length];
列数3 = s6.length;
列数据宽度3 = new int[s6.length];
列数据类型3 = new String[s6.length];
for (int j = 0; j < s6.length; j++) {
字段序号[j] = Integer.parseInt(s6[j]) - 1;
列名3[j] = 列名1[字段序号[j]];
列数据宽度3[j] = 列数据宽度1[字段序号[j]];
列数据类型3[j] = 列数据类型1[字段序号[j]];
表3宽度 = 表3宽度 + 列数据宽度3[j];
}
} else {
列名3 = g6.split(",");
字段序号 = new int[列名3.length];
列数3 = 列名3.length;
列数据宽度3 = new int[列名3.length];
列数据类型3 = new String[列名3.length];
for (int i = 0; i < 列数1; i++)
for (int j = 0; j < 列名3.length; j++)
if (列名1[i].trim().equals(列名3[j].trim())) {
字段序号[j] = i;
列数据宽度3[j] = 列数据宽度1[字段序号[j]];
列数据类型3[j] = 列数据类型1[字段序号[j]];
表3宽度 = 表3宽度 + 列数据宽度3[j];
}
}
set1.clear();
int n1 = 0;
表格数据3 = new String[表格模型1.getRowCount()][列数3];
记录条数3 = 表格模型1.getRowCount();
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
s1 = "";
for (int j = 0; j < 列数3; j++) {
if (表格模型1.getValueAt(i1, 字段序号[j]) == null)
s1 = s1 + "";
else
s1 = s1
+ 表格模型1.getValueAt(i1, 字段序号[j]).toString()
.trim();
}
if (s1.length() > 0)
set1.add(s1);
if (set1.size() != n1) {
for (int j = 0; j < 列数3; j++) {
if (表格模型1.getValueAt(i1, 字段序号[j]) == null)
表格数据3[n1][j] = "";
else
表格数据3[n1][j] = 表格模型1.getValueAt(i1, 字段序号[j])
.toString().trim();
}
n1 = set1.size();
}
}
scrollPane3.setBounds(20, 60, 表3宽度 * 8, 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] * 8);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",9,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel1.add(投影);
}
final JButton 退出1 = new JButton(按钮集[10]);
退出1.setBounds(左边距, 540, 按钮宽, 20);
退出1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame2.setVisible(false);
frame2.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (要求按钮号表.indexOf(",10,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel1.add(退出1);
}
左边距 = 30;
final JButton 笛卡尔积2 = new JButton(按钮集[0]);
笛卡尔积2.setBounds(左边距, 540, 按钮宽, 20);
笛卡尔积2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
表3宽度 = 表1宽度 + 表2宽度;
列数3 = 列数1 + 列数2;
列名3 = new String[列数3];
列数据宽度3 = new int[列数3];
表格数据3 = new String[表格模型1.getRowCount() * 表格模型2.getRowCount()][列数3];
列数据类型3 = new String[列数3];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
列数据宽度3[j] = 列数据宽度1[j];
}
for (int j = 0; j < 列数2; j++) {
列数据类型3[j + 列数1] = 列数据类型2[j];
列名3[j + 列数1] = 列名2[j];
列数据宽度3[j + 列数1] = 列数据宽度2[j];
}
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
for (int i2 = 0; i2 < 表格模型2.getRowCount(); i2++) {
int n2 = 表格模型2.getRowCount();
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[i1 * n2 + i2][j] = "";
else
表格数据3[i1 * n2 + i2][j] = 表格模型1
.getValueAt(i1, j).toString();
}
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null)
表格数据3[i1 * n2 + i2][j + 列数1] = "";
else
表格数据3[i1 * n2 + i2][j + 列数1] = 表格模型2
.getValueAt(i2, j).toString();
}
}
}
scrollPane3.setBounds(20, 60, 表3宽度 * 4, 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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",0,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel2.add(笛卡尔积2);
}
final JButton 求并集2 = new JButton(按钮集[1]);
求并集2.setBounds(左边距, 540, 按钮宽, 20);
求并集2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
表3宽度 = 表1宽度;
if (列数1 != 列数2) {
JOptionPane.showMessageDialog(null, "二表列数不相等，不能求并集！" + s1);
return;
}
表格模型3 = new DefaultTableModel(表格数据1, 列名1);
列数3 = 列数1;
列名3 = new String[列数3];
列数据宽度3 = new int[列数3];
表格数据3 = new String[表格模型1.getRowCount()][列数3];
列数据类型3 = new String[列数3];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
列数据宽度3[j] = 列数据宽度1[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
s6 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[i1][j] = "";
else {
表格数据3[i1][j] = 表格模型1.getValueAt(i1, j).toString();
s6 = s6 + 表格数据3[i1][j].trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = 表格模型2.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null) {
s6 = s6 + "";
表格模型2.setValueAt("", i2, j);
一条记录1[j] = "";
} else {
s6 = s6 + 表格模型2.getValueAt(i2, j).toString().trim();
一条记录1[j] = 表格模型2.getValueAt(i2, j).toString();
}
}
set1.add(s6);
if (set1.size() != size1) {
size1 = set1.size();
表格模型3.addRow(一条记录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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",1,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel2.add(求并集2);
}
final JButton 求交集2 = new JButton(按钮集[2]);
求交集2.setBounds(左边距, 540, 按钮宽, 20);
求交集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];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
列数据宽度3[j] = 列数据宽度1[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
s6 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) != null) {
s6 = s6 + 表格模型1.getValueAt(i1, j).toString().trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = 表格模型2.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null) {
s6 = s6 + "";
一条记录1[j] = "";
} else {
s6 = s6 + 表格模型2.getValueAt(i2, j).toString().trim();
一条记录1[j] = 表格模型2.getValueAt(i2, j).toString();
}
}
set1.add(s6);
if (set1.size() == size1) {
if (表3记录数 == 0) {
表3记录数 = 1;
表格数据3 = new String[1][列数1];
for (int j = 0; j < 列数1; j++) {
表格数据3[0][j] = 一条记录1[j];
}
表格模型3 = new DefaultTableModel(表格数据3, 列名1);
} else
表格模型3.addRow(一条记录1);
} else
size1 = set1.size();
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",2,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel2.add(求交集2);
}
final JButton 表1减表22 = new JButton(按钮集[3]);
表1减表22.setBounds(左边距, 540, 按钮宽, 20);
表1减表22.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];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
列数据宽度3[j] = 列数据宽度1[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < 表格模型2.getRowCount(); i1++) {
int n1 = 表格模型2.getRowCount();
s6 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型2.getValueAt(i1, j) != null) {
s6 = s6 + 表格模型2.getValueAt(i1, j).toString().trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = 表格模型1.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < 列数2; j++) {
if (表格模型1.getValueAt(i2, j) == null) {
s6 = s6 + "";
一条记录1[j] = "";
} else {
s6 = s6 + 表格模型1.getValueAt(i2, j).toString().trim();
一条记录1[j] = 表格模型1.getValueAt(i2, j).toString();
}
}
set1.add(s6);
if (set1.size() != size1) {
if (表3记录数 == 0) {
表3记录数 = 1;
表格数据3 = new String[1][列数1];
for (int j = 0; j < 列数1; j++) {
表格数据3[0][j] = 一条记录1[j];
}
表格模型3 = new DefaultTableModel(表格数据3, 列名1);
} else
表格模型3.addRow(一条记录1);
} else
size1 = set1.size();
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",3,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel2.add(表1减表22);
}
final JButton 求连接2 = new JButton(按钮集[4]);
求连接2.setBounds(左边距, 540, 按钮宽, 20);
求连接2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<列名1><关系符><列名2>" + x1 + x2
+ "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int 序号1 = 0, 序号2 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < 列数1; i++)
if (s8[0].trim().equals(列名1[i].trim()))
序号1 = i;
String 类型 = "";
if (main1.数字数据类型.lastIndexOf("," + 列数据类型1[序号1] + ",") >= 0)
类型 = "数字";
else
类型 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < 列数2; i++)
if (s8[1].trim().equals(列名2[i].trim()))
序号2 = i;
for (int i = 0; i < 列数1; i++)
for (int j = 0; j < 列数2; j++)
if (列名1[i].trim().equals(列名2[j].trim()))
list1.add(列名1[i]);
表3宽度 = 表1宽度 + 表2宽度;
列数3 = 列数1 + 列数2;
列名3 = new String[列数3];
列数据宽度3 = new int[列数3];
表格数据3 = new String[1][列数3];
列数据类型3 = new String[列数3];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
表格数据3[0][j] = "";
列数据宽度3[j] = 列数据宽度1[j];
}
for (int j = 0; j < 列数2; j++) {
列数据类型3[j + 列数1] = 列数据类型2[j];
列名3[j + 列数1] = 列名2[j];
表格数据3[0][j + 列数1] = "";
列数据宽度3[j + 列数1] = 列数据宽度2[j];
}
int 标志 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
for (int i2 = 0; i2 < 表格模型2.getRowCount(); i2++) {
int n2 = 表格模型2.getRowCount();
if (表格模型1.getValueAt(i1, 序号1) == null)
s1 = "";
else
s1 = 表格模型1.getValueAt(i1, 序号1).toString();
if (表格模型2.getValueAt(i2, 序号2) == null)
s2 = "";
else
s2 = 表格模型2.getValueAt(i2, 序号2).toString();
if (condition1(s1, s7, s2, 类型)) {
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[0][j] = "";
else
表格数据3[0][j] = 表格模型1.getValueAt(i1, j)
.toString().trim();
}
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null)
表格数据3[0][j + 列数1] = "";
else
表格数据3[0][j + 列数1] = 表格模型2.getValueAt(i2, j)
.toString().trim();
}
if (标志 == 0) {
标志 = 1;
表格模型3 = new DefaultTableModel(表格数据3, 列名3);
} else
表格模型3.addRow(表格数据3[0]);
}
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",4,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel2.add(求连接2);
}
final JButton 左连接2 = new JButton(按钮集[5]);
左连接2.setBounds(左边距, 540, 按钮宽, 20);
左连接2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<列名1><关系符><列名2>" + x1 + x2
+ "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int 序号1 = 0, 序号2 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < 列数1; i++)
if (s8[0].trim().equals(列名1[i].trim()))
序号1 = i;
String 类型 = "";
if (main1.数字数据类型.lastIndexOf("," + 列数据类型1[序号1] + ",") >= 0)
类型 = "数字";
else
类型 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < 列数2; i++)
if (s8[1].trim().equals(列名2[i].trim()))
序号2 = i;
for (int i = 0; i < 列数1; i++)
for (int j = 0; j < 列数2; j++)
if (列名1[i].trim().equals(列名2[j].trim()))
list1.add(列名1[i]);
表3宽度 = 表1宽度 + 表2宽度;
列数3 = 列数1 + 列数2;
列名3 = new String[列数3];
列数据宽度3 = new int[列数3];
表格数据3 = new String[1][列数3];
列数据类型3 = new String[列数3];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
表格数据3[0][j] = "";
列数据宽度3[j] = 列数据宽度1[j];
}
for (int j = 0; j < 列数2; j++) {
列数据类型3[j + 列数1] = 列数据类型2[j];
列名3[j + 列数1] = 列名2[j];
表格数据3[0][j + 列数1] = "";
列数据宽度3[j + 列数1] = 列数据宽度2[j];
}
int 标志 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
for (int i2 = 0; i2 < 表格模型2.getRowCount(); i2++) {
int n2 = 表格模型2.getRowCount();
if (表格模型1.getValueAt(i1, 序号1) == null)
s1 = "";
else
s1 = 表格模型1.getValueAt(i1, 序号1).toString();
if (表格模型2.getValueAt(i2, 序号2) == null)
s2 = "";
else
s2 = 表格模型2.getValueAt(i2, 序号2).toString();
if (condition1(s1, s7, s2, 类型)) {
s3 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[0][j] = "";
else
表格数据3[0][j] = 表格模型1.getValueAt(i1, j)
.toString().trim();
s3 = s3 + 表格数据3[0][j];
}
set1.add(s3);
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null)
表格数据3[0][j + 列数1] = "";
else
表格数据3[0][j + 列数1] = 表格模型2.getValueAt(i2, j)
.toString().trim();
}
if (标志 == 0) {
标志 = 1;
表格模型3 = new DefaultTableModel(表格数据3, 列名3);
} else
表格模型3.addRow(表格数据3[0]);
}
}
}
for (int j = 0; j < 列数2; j++) {
表格数据3[0][j + 列数1] = "";
}
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n = set1.size();
s3 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[0][j] = "";
else
表格数据3[0][j] = 表格模型1.getValueAt(i1, j).toString()
.trim();
s3 = s3 + 表格数据3[0][j];
}
set1.add(s3);
if (set1.size() != n) {
n = set1.size();
表格模型3.addRow(表格数据3[0]);
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",5,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel2.add(左连接2);
}
final JButton 全连接2 = new JButton(按钮集[6]);
全连接2.setBounds(左边距, 540, 按钮宽, 20);
全连接2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
set2.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<列名1><关系符><列名2>" + x1 + x2
+ "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int 序号1 = 0, 序号2 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < 列数1; i++)
if (s8[0].trim().equals(列名1[i].trim()))
序号1 = i;
String 类型 = "";
if (main1.数字数据类型.lastIndexOf("," + 列数据类型1[序号1] + ",") >= 0)
类型 = "数字";
else
类型 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < 列数2; i++)
if (s8[1].trim().equals(列名2[i].trim()))
序号2 = i;
for (int i = 0; i < 列数1; i++)
for (int j = 0; j < 列数2; j++)
if (列名1[i].trim().equals(列名2[j].trim()))
list1.add(列名1[i]);
表3宽度 = 表1宽度 + 表2宽度;
列数3 = 列数1 + 列数2;
列名3 = new String[列数3];
列数据宽度3 = new int[列数3];
表格数据3 = new String[1][列数3];
列数据类型3 = new String[列数3];
for (int j = 0; j < 列数1; j++) {
列数据类型3[j] = 列数据类型1[j];
列名3[j] = 列名1[j];
表格数据3[0][j] = "";
列数据宽度3[j] = 列数据宽度1[j];
}
for (int j = 0; j < 列数2; j++) {
列数据类型3[j + 列数1] = 列数据类型2[j];
列名3[j + 列数1] = 列名2[j];
表格数据3[0][j + 列数1] = "";
列数据宽度3[j + 列数1] = 列数据宽度2[j];
}
int 标志 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n1 = 表格模型1.getRowCount();
for (int i2 = 0; i2 < 表格模型2.getRowCount(); i2++) {
int n2 = 表格模型2.getRowCount();
if (表格模型1.getValueAt(i1, 序号1) == null)
s1 = "";
else
s1 = 表格模型1.getValueAt(i1, 序号1).toString();
if (表格模型2.getValueAt(i2, 序号2) == null)
s2 = "";
else
s2 = 表格模型2.getValueAt(i2, 序号2).toString();
if (condition1(s1, s7, s2, 类型)) {
s3 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[0][j] = "";
else
表格数据3[0][j] = 表格模型1.getValueAt(i1, j)
.toString().trim();
s3 = s3 + 表格数据3[0][j];
}
set1.add(s3);
s4 = "";
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null)
表格数据3[0][j + 列数1] = "";
else
表格数据3[0][j + 列数1] = 表格模型2.getValueAt(i2, j)
.toString().trim();
s4 = s4 + 表格数据3[0][j + 列数1];
}
set2.add(s4);
if (标志 == 0) {
标志 = 1;
表格模型3 = new DefaultTableModel(表格数据3, 列名3);
} else
表格模型3.addRow(表格数据3[0]);
}
}
}
for (int j = 0; j < 列数2; j++) {
表格数据3[0][j + 列数1] = "";
}
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
int n = set1.size();
s3 = "";
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[0][j] = "";
else
表格数据3[0][j] = 表格模型1.getValueAt(i1, j).toString()
.trim();
s3 = s3 + 表格数据3[0][j];
}
set1.add(s3);
if (set1.size() != n) {
n = set1.size();
表格模型3.addRow(表格数据3[0]);
}
}
for (int j = 0; j < 列数1; j++) {
表格数据3[0][j] = "";
}
for (int i2 = 0; i2 < 表格模型2.getRowCount(); i2++) {
int n = set2.size();
s4 = "";
for (int j = 0; j < 列数2; j++) {
if (表格模型2.getValueAt(i2, j) == null)
表格数据3[0][j + 列数1] = "";
else
表格数据3[0][j + 列数1] = 表格模型2.getValueAt(i2, j)
.toString().trim();
s4 = s4 + 表格数据3[0][j + 列数1];
}
set2.add(s4);
if (set2.size() != n) {
n = set2.size();
表格模型3.addRow(表格数据3[0]);
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",6,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel2.add(全连接2);
}
final JButton 表1除以表22 = new JButton(按钮集[7]);
表1除以表22.setBounds(左边距, 540, 按钮宽, 20);
表1除以表22.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String s6 = JOptionPane.showInputDialog("请输入分组字段与要求包含的字段名："
+ x1 + x2 + "格式：<分组字段名集><。><包含字段名集>" + x1 + x2
+ "其中，分组字段名集是表1中某些列的名字，是商集的字段名，用逗号分隔" + x1 + x2
+ "要求包含的字段名是表1与表2中都有的某些列的名字。" + x1 + x2
+ "例如：学号,姓名。课程名");
String[] s8 = s6.split("。");
列名3 = s8[0].split(",");
String[] 包含字段名 = s8[1].split(",");
列数3 = 列名3.length;
int[] 分组字段号 = new int[列数3];
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[j] = 列数据类型1[i];
表3宽度 = 表3宽度 + 列数据宽度3[j];
}
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宽度 * 8, 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] * 8);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",7,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel2.add(表1除以表22);
}
final JButton 选择2 = new JButton(按钮集[8]);
选择2.setBounds(左边距, 540, 按钮宽, 20);
选择2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String g6 = JOptionPane.showInputDialog("请输入选择条件：" + x1 + x2
+ "条件式由若干个分条件式经逻辑关系符连接构成。" + x1 + x2
+ "格式：<分条件1>[<逻辑关系><分条件2>][<逻辑关系><分条件3>]" + x1 + x2
+ "其中，逻辑关系包括and、or。前后需有空格。" + x1 + x2 + "本程序不能识别括号。"
+ x1 + x2 + "分条件式由字段名、关系符、数据值（或字段名）构成。必须以字段名开始。" + x1
+ x2 + "格式1：<字段名>[<关系符><数据值>" + x1 + x2
+ "格式2：<字段名>[<关系符><字段名>" + x1 + x2
+ "例如：学号>201102 and 性别=男" + x1 + x2 + "又例如：津贴>基本工资");
g6 = g6.toUpperCase();
String g7 = g6;
g7 = g7.replaceAll("OR", "AND");
String[] g8 = g7.split(" AND ");
int[] g9 = new int[g8.length];
if (g8.length > 1) {
g9[g8.length - 1] = g7.length();
int k = 0;
for (int i = 0; i < g7.length(); i++) {
if (k < g8.length - 1)
g9[k] = g7.indexOf(" AND ", i);
i = g9[k];
k++;
}
}
int 序号1 = 0, 序号2 = 0;
String 类型 = "";
String s6 = "";
String s7 = "";
String[] s8 = new String[1];
boolean[] l1 = new boolean[表格模型1.getRowCount()];
int 标志 = 0;
for (int i = 0; i < g8.length; i++) {
s6 = g8[i];
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
列数据类型3 = new String[列数1];
列数据宽度3 = new int[列数1];
for (int i1 = 0; i1 < 列数1; i1++) {
列数据类型3[i1] = 列数据类型1[i1];
列数据宽度3[i1] = 列数据宽度1[i1];
}
序号1 = 0;
序号2 = 0;
for (int i1 = 0; i1 < 列数1; i1++)
if (s8[0].trim().equals(列名1[i1].toUpperCase().trim()))
序号1 = i1;
类型 = "";
if (main1.数字数据类型.lastIndexOf("," + 列数据类型1[序号1] + ",") >= 0)
类型 = "数字";
else
类型 = "字符串";
序号2 = -1;
for (int i2 = 0; i2 < 列数1; i2++)
if (s8[1].trim().equals(列名1[i2].toUpperCase().trim()))
序号2 = i2;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
if (表格模型1.getValueAt(i1, 序号1) == null)
s1 = "";
else
s1 = 表格模型1.getValueAt(i1, 序号1).toString().trim();
if (序号2 > 0)
if (表格模型1.getValueAt(i1, 序号2) == null)
s2 = "";
else
s2 = 表格模型1.getValueAt(i1, 序号2).toString()
.trim();
else
s2 = s8[1];
if (i == 0)
l1[i1] = condition1(s1, s7, s2, 类型);
else {
if (标志 == 0)
l1[i1] = l1[i1] && condition1(s1, s7, s2, 类型);
else
l1[i1] = l1[i1] || condition1(s1, s7, s2, 类型);
}
if (i < g8.length - 1) {
if (g6.substring(g9[i], g9[i] + 4).lastIndexOf(
"AND") > 0)
标志 = 0;
else
标志 = 1;
}
}
}
记录条数3 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++)
if (l1[i1])
记录条数3++;
表格数据3 = new String[记录条数3][列数1];
记录条数3 = 0;
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
if (l1[i1]) {
for (int j = 0; j < 列数1; j++) {
if (表格模型1.getValueAt(i1, j) == null)
表格数据3[记录条数3][j] = "";
else
表格数据3[记录条数3][j] = 表格模型1.getValueAt(i1, j)
.toString().trim();
}
记录条数3++;
}
}
scrollPane3.setBounds(20, 60, 表1宽度 * 8, 450);
表格模型3 = new DefaultTableModel(表格数据3, 列名1);
表格3 = new JTable(表格模型3);
表格3.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(表格3, null);
for (int i = 0; i < 列数1; i++) {
TableColumn tc = 表格3.getColumn(列名1[i]);
tc.setPreferredWidth(列数据宽度1[i] * 8);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",8,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel2.add(选择2);
}
final JButton 投影2 = new JButton(按钮集[9]);
投影2.setBounds(左边距, 540, 按钮宽, 20);
投影2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String g6 = JOptionPane.showInputDialog("请输入字段名称集：" + x1 + x2
+ "可以是字段名称，之间用逗号分隔。" + x1 + x2
+ "也可以是字段号，用中括号括起，之间用逗号分隔。" + x1 + x2 + "字段号从1起计数。"
+ x1 + x2 + "例如：学号,姓名,性别,班级,出生日期。" + x1 + x2
+ "又例如：[1],[2],[4],[6]");
String[] s6;
int[] 字段序号;
表3宽度 = 0;
if (g6.lastIndexOf("]") >= 0) {
g6 = g6.substring(g6.indexOf("[") + 1, g6.lastIndexOf("]"));
s6 = g6.split("\\],\\[");
字段序号 = new int[s6.length];
列名3 = new String[s6.length];
列数3 = s6.length;
列数据宽度3 = new int[s6.length];
列数据类型3 = new String[s6.length];
for (int j = 0; j < s6.length; j++) {
字段序号[j] = Integer.parseInt(s6[j]) - 1;
列名3[j] = 列名1[字段序号[j]];
列数据宽度3[j] = 列数据宽度1[字段序号[j]];
列数据类型3[j] = 列数据类型1[字段序号[j]];
表3宽度 = 表3宽度 + 列数据宽度3[j];
}
} else {
列名3 = g6.split(",");
字段序号 = new int[列名3.length];
列数3 = 列名3.length;
列数据宽度3 = new int[列名3.length];
for (int i = 0; i < 列数1; i++)
for (int j = 0; j < 列名3.length; j++)
if (列名1[i].trim().equals(列名3[j].trim())) {
字段序号[j] = i;
列数据宽度3[j] = 列数据宽度1[字段序号[j]];
表3宽度 = 表3宽度 + 列数据宽度3[j];
}
}
set1.clear();
int n1 = 0;
表格数据3 = new String[表格模型1.getRowCount()][列数3];
记录条数3 = 表格模型1.getRowCount();
for (int i1 = 0; i1 < 表格模型1.getRowCount(); i1++) {
s1 = "";
for (int j = 0; j < 列数3; j++) {
if (表格模型1.getValueAt(i1, 字段序号[j]) == null)
s1 = s1 + "";
else
s1 = s1
+ 表格模型1.getValueAt(i1, 字段序号[j]).toString()
.trim();
}
if (s1.length() > 0)
set1.add(s1);
if (set1.size() != n1) {
for (int j = 0; j < 列数3; j++) {
if (表格模型1.getValueAt(i1, 字段序号[j]) == null)
表格数据3[n1][j] = "";
else
表格数据3[n1][j] = 表格模型1.getValueAt(i1, 字段序号[j])
.toString().trim();
}
n1 = set1.size();
}
}
scrollPane3.setBounds(20, 60, 表3宽度 * 8, 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] * 8);
}
panel3.add(scrollPane3);
}
});
if (要求按钮号表.indexOf(",9,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel2.add(投影2);
}
final JButton 退出2 = new JButton(按钮集[10]);
退出2.setBounds(左边距, 540, 按钮宽, 20);
退出2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame2.setVisible(false);
frame2.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (要求按钮号表.indexOf(",10,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel2.add(退出2);
}
左边距 = 50;
按钮宽 = 170;
final JButton 导出 = new JButton(按钮集[11]);
导出.setBounds(左边距, 540, 按钮宽, 20);
导出.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataTransfer0.Trans(列名3, 列数据类型3, 列数据宽度3, "", 表格数据3, "运算结果");
}
});
if (要求按钮号表.indexOf(",11,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel3.add(导出);
}
final JButton 打印预览 = new JButton(按钮集[12]);
打印预览.setBounds(左边距, 540, 按钮宽, 20);
打印预览.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPreview0.printView1(列名3, 表格数据3, 列数据宽度3, "运算结果");
}
});
if (要求按钮号表.indexOf(",12,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel3.add(打印预览);
}
final JButton 打印 = new JButton(按钮集[13]);
打印.setBounds(左边距, 540, 按钮宽, 20);
打印.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPrint0.printView1(列名3, 表格数据3, 列数据宽度3, "运算结果");
}
});
if (要求按钮号表.indexOf(",13,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel3.add(打印);
}
final JButton 存入数据库 = new JButton(按钮集[14]);
存入数据库.setBounds(左边距, 540, 按钮宽, 20);
存入数据库.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String 表名 = JOptionPane.showInputDialog("请输入导入表名，注意原数据均被删除：");
dataTransfer19.Trans(列名3, 列数据类型3, 列数据宽度3, 表格数据3, 表名);
}
});
if (要求按钮号表.indexOf(",14,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel3.add(存入数据库);
}
final JButton 退出3 = new JButton(按钮集[10]);
退出3.setBounds(左边距, 540, 按钮宽, 20);
退出3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame2.setVisible(false);
frame2.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (要求按钮号表.indexOf(",10,") >= 0) {
左边距 = 左边距 + 按钮宽;
panel3.add(退出3);
}
frame3.add(panel3);
frame2.add(panel2);
frame1.add(panel1);
frame3.setVisible(true);
frame2.setVisible(true);
frame1.setVisible(true);
}
public static boolean condition1(String f1, String c1, String f2, String t1) {
int j = 0;
if (t1.trim().equals("数字")) {
double n1 = Double.parseDouble(f1);
double n2 = Double.parseDouble(f2);
if ((c1.trim().equals(">=")) && (n1 >= n2)) {
j = 1;
} else if ((c1.trim().equals("<=")) && (n1 <= n2)) {
j = 1;
} else if ((c1.trim().equals("=")) && (n1 == n2)) {
j = 1;
} else if ((c1.trim().equals("<>")) && (n1 != n2)) {
j = 1;
} else if ((c1.trim().equals(">")) && (n1 > n2)) {
j = 1;
} else if ((c1.trim().equals("<")) && (n1 < n2)) {
j = 1;
}
} else {
if ((c1.trim().equals(">=")) && (f1.compareTo(f2) >= 0)) {
j = 1;
} else if ((c1.trim().equals("<=")) && (f1.compareTo(f2) <= 0)) {
j = 1;
} else if ((c1.trim().equals("=")) && (f1.compareTo(f2) == 0)) {
j = 1;
} else if ((c1.trim().equals("<>")) && (f1.compareTo(f2) != 0)) {
j = 1;
} else if ((c1.trim().equals(">")) && (f1.compareTo(f2) > 0)) {
j = 1;
} else if ((c1.trim().equals("<")) && (f1.compareTo(f2) < 0)) {
j = 1;
}
}
if (j == 1)
return true;
else
return false;
}
public void itemStateChanged(ItemEvent e) {
try {
con = main1.getConn();// 连接数据库
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + fa0.getSelectedItem();
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
列数1 = rsmd.getColumnCount();
列名1 = new String[列数1];
一条记录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] = " ";
列数据类型1[i] = rsmd.getColumnTypeName(i + 1);
列数据宽度1[i] = rsmd.getColumnDisplaySize(i + 1);
表1宽度 = 表1宽度 + 列数据宽度1[i] * 4;
}
rs.last();
记录条数1 = rs.getRow();
表格数据1 = new String[记录条数1][列数1];
rs.absolute(1);
int c = 0, b = 0;
while (c < 记录条数1) {
rs.absolute(c + 1);
while (b < 列数1) {
表格数据1[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表1失败！" + s1);
return;
} scrollPane1.setBounds(20, 60, 表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] * 4);
}
panel1.add(scrollPane1);
表格1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
弹出菜单.show(表格1, e.getX() + 100, e.getY());
选中行号1 = 表格1.rowAtPoint(e.getPoint());
当前列号1 = 表格1.columnAtPoint(e.getPoint());
}
}
});
}
}
版本2
67.源码67，部件程序，生成单数据交叉表或转置表, 之后可转存数据表、转存文件、打印图表。
/*
* 程序文件名：dataStatistic10.java
* 作者：程学先
* 程序功能：生成单数据交叉表或转置表，之后可打印、转存数据表、转存文件、打印图表。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
public class dataStatistic10 extends JFrame {
static dataStatistic10 frame1 = new dataStatistic10();
static dataStatistic10 frame2 = new dataStatistic10();
static dataStatistic10 frame3 = new dataStatistic10();
static String variabl2603 = "";
static DefaultTableModel variabl19651;
static DefaultTableModel variabl19652;
static DefaultTableModel variabl19653;
static JTable variabl26551;
static JTable variabl26552;
static JTable variabl26553;
static JScrollPane scrollPane1 = new JScrollPane();
static JScrollPane scrollPane2 = new JScrollPane();
static JScrollPane scrollPane3 = new JScrollPane();
static String s1 = "", s2 = "";
static ResultSet rs;
static int variabl1739 = 0, c = 0;
static int variabl2651;
static int variabl21131;
static String[] variabl2517;
static String variabl1735;
static String[] variabl19131;
static String[] variabl19132;
static String[] variabl2411;
static String[] variabl1501;
static String[] variabl1169;
static String[] variabl11692;
static int[] variabl1489;
static int[] variabl1119;
static int[] variabl11192;
static int variabl1853, variabl18531, variabl2305;
static String[][] variabl21971;
static String[][] variabl21972;
static String variabl1685;
static String variabl2429;
static String[] variabl2253;
static String variabl1325;
static String variabl2049;
static String[] variabl240501;
static Connection con;
static ResultSetMetaData rsmd3;
static Statement sta3;
static int variabl2483 = 800, variabl2503 = 600;
private static JScrollPane scrollPaneL1 = new JScrollPane();
private static List list1 = new List();
private static JLabel fl0, fl1, fl2, fl3, fl4, fl5, fl6, fl7, fl8, fl9,
fl10, fl11, fl12;
private static JTextField fa0, fa1, fa2, fa3, fa4, fa5, fa6, fa7, fa8, fa9,
fa10, fa11, fa12;
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
frame1 = new dataStatistic10();
frame2 = new dataStatistic10();
frame3 = new dataStatistic10();
variabl2603 = "";
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
s1 = "";
s2 = "";
variabl1739 = 0;
c = 0;
variabl2483 = 800;
variabl2503 = 600;
scrollPaneL1 = new JScrollPane();
list1 = new List();
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) {
}
frame1 = new dataStatistic10();
frame2 = new dataStatistic10();
frame3 = new dataStatistic10();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
s1 = "";
s2 = "";
variabl1739 = 0;
c = 0;
variabl2483 = 800;
variabl2503 = 600;
scrollPaneL1 = new JScrollPane();
list1 = new List();
variabl2603 = parameter[4];
variabl2429 = parameter[0];
variabl1685 = variabl2603;
variabl1735 = parameter[8];
variabl1325 = parameter[19];
variabl2517 = parameter[19].split(",");
if (variabl1735.length() > 0) {
String[] s6 = variabl1735.split(",");
variabl1325 = "";
for (int i = 0; i < s6.length; i++)
if (variabl1325.length() > 0)
variabl1325 = variabl1325 + ","
+ variabl2517[Integer.parseInt(s6[i])];
else
variabl1325 = variabl2517[Integer.parseInt(s6[i])];
}
variabl2049 = parameter[20];
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (variabl1325.lastIndexOf(",") == variabl1325.length() - 1)
variabl1325 = variabl1325
.substring(0, variabl1325.length() - 1);
if (variabl2049.trim().length() > 0)
s1 = "select " + variabl1325 + " from " + variabl2603
+ " where " + variabl2049;
else
s1 = "select " + variabl1325 + " from " + variabl2603;
ResultSet rs = sta3.executeQuery(s1);
rsmd3 = rs.getMetaData();
variabl2651 = rsmd3.getColumnCount();
variabl2517 = new String[variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[i] = rsmd3.getColumnName(i + 1);
variabl1501[i] = rsmd3.getColumnTypeName(i + 1);
variabl1489[i] = rsmd3.getPrecision(i + 1);
}
rs.last();
variabl1853 = rs.getRow();
variabl21131 = variabl2651;
variabl19131 = new String[variabl21131];
variabl1169 = new String[variabl21131];
variabl1119 = new int[variabl21131];
for (int i = 0; i < variabl21131; i++) {
variabl19131[i] = variabl2517[i];
variabl1169[i] = variabl1501[i];
variabl1119[i] = variabl1489[i];
}
variabl21971 = new String[variabl1853][variabl2651];
rs.absolute(1);
for (int i = 0; i < variabl1853; i++) {
rs.absolute(i + 1);
for (int j = 0; j < variabl21131; j++) {
variabl21971[i][j] = rs.getString(j + 1);
}
}
rs.close();
sta3.close();
} catch (Exception e) {
e.printStackTrace();
}
frame1.setTitle("单交叉表程序 作者：程学先");
frame1.setBounds(10, 10, variabl2483 - 10, variabl2503 - 10);
frame1.getContentPane().setLayout(null);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
final JPanel panel = new JPanel(false);
panel.setLayout(null);
panel.setBounds(20, 20, variabl2483 - 50, variabl2503 - 20);
variabl19651 = new DefaultTableModel(variabl21971, variabl19131);
variabl26551 = new JTable(variabl19651);
variabl26551.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl26551.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(variabl26551, null);
scrollPane1.setBounds(20, 20, variabl2483 - 180, variabl2503 - 200);
panel.add(scrollPane1);
list1.setBounds(variabl2483 - 140, 20, 80, variabl2503 - 200);
panel.add(list1);
list1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (list1.getSelectedIndex() >= 0) {
int w1, w2, h1, h2;
switch (variabl1739) {
case 1:
fa1.setText(list1.getSelectedItem());
break;
case 2:
fa2.setText(list1.getSelectedItem());
break;
case 3:
fa3.setText(list1.getSelectedItem());
break;
case 4:
fa4.setText(list1.getSelectedItem());
break;
}
}
}
});
fl1 = new JLabel("行");
fl1.setBounds(30, variabl2503 - 170, 40, 20);
panel.add(fl1);
fa1 = new JTextField("", 20);
fa1.setBounds(70, variabl2503 - 170, 100, 20);
panel.add(fa1);
fa1.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 1;
list1.removeAll();
for (int j = 0; j < variabl21131; j++) {
list1.add(variabl19131[j]);
}
}
});
fl2 = new JLabel("列");
fl2.setBounds(170, variabl2503 - 170, 40, 20);
panel.add(fl2);
fa2 = new JTextField("", 20);
fa2.setBounds(210, variabl2503 - 170, 100, 20);
panel.add(fa2);
fa2.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 2;
list1.removeAll();
for (int j = 0; j < variabl21131; j++) {
list1.add(variabl19131[j]);
}
}
});
fl3 = new JLabel("交叉数据");
fl3.setBounds(310, variabl2503 - 170, 60, 20);
panel.add(fl3);
fa3 = new JTextField("", 20);
fa3.setBounds(370, variabl2503 - 170, 100, 20);
panel.add(fa3);
fa3.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 3;
list1.removeAll();
for (int j = 0; j < variabl21131; j++) {
list1.add(variabl19131[j]);
}
}
});
fl4 = new JLabel("聚集函数");
fl4.setBounds(470, variabl2503 - 170, 60, 20);
panel.add(fl4);
fa4 = new JTextField("", 20);
fa4.setBounds(530, variabl2503 - 170, 100, 20);
panel.add(fa4);
fa4.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 4;
list1.removeAll();
list1.add(" ");
list1.add("和");
list1.add("条数");
}
});
variabl2339 = (variabl2483 - 60) / variabl2851;
int variabl2337 = 30;
final JButton transformButton1 = new JButton(variabl2405[0]);
transformButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
try {
int variabl2341 = 0;
for (int i = 0; i < variabl21131; i++)
if (variabl19131[i].trim().equalsIgnoreCase(
fa1.getText().trim())) {
variabl2341 = i;
break;
}
int variabl2345 = 0;
for (int i = 0; i < variabl21131; i++)
if (variabl19131[i].trim().equalsIgnoreCase(
fa2.getText().trim())) {
variabl2345 = i;
break;
}
int variabl2033 = 0;
int mark = 0;
String[] variabl2289 = new String[variabl1853 + 1];
int[] variabl22891 = new int[variabl1853];
for (int i = 0; i < variabl1853; i++) {
mark = 0;
for (int j = i - 1; j >= 0; j--)
if (variabl21971[i][variabl2341]
.trim()
.equalsIgnoreCase(
variabl21971[j][variabl2341].trim())) {
mark = 1;
variabl22891[i] = variabl22891[j];
break;
}
if (mark == 0) {
variabl2033++;
variabl2289[variabl2033] = variabl21971[i][variabl2341];
variabl22891[i] = variabl2033;
}
}
int variabl1929 = 0;
String[] variabl2439 = new String[variabl1853 + 1];
int[] variabl24391 = new int[variabl1853];
for (int i = 0; i < variabl1853; i++) {
mark = 0;
for (int j = i - 1; j >= 0; j--)
if (variabl21971[i][variabl2345]
.trim()
.equalsIgnoreCase(
variabl21971[j][variabl2345].trim())) {
mark = 1;
variabl24391[i] = variabl24391[j];
break;
}
if (mark == 0) {
variabl1929++;
variabl2439[variabl1929] = variabl21971[i][variabl2345];
variabl24391[i] = variabl1929;
}
}
int variabl1211 = 0;
for (int i = 0; i < variabl21131; i++)
if (variabl19131[i].trim().equalsIgnoreCase(
fa3.getText().trim())) {
variabl1211 = i;
break;
}
variabl21972 = new String[variabl2033][variabl1929 + 1];
for (int k = 0; k < variabl1853; k++)
o: for (int i = 1; i <= variabl2033; i++)
for (int j = 1; j <= variabl1929; j++)
if ((i == variabl22891[k])
&& (j == variabl24391[k])) {
if (fa4.getText().trim().equals("和")) {
if ((variabl21972[i - 1][j] != null)
&& (variabl21972[i - 1][j]
.length() > 0))
variabl21972[i - 1][j] = ""
+ (Integer
.valueOf(variabl21972[i - 1][j]) + Integer
.valueOf(variabl21971[k][variabl1211]));
else
variabl21972[i - 1][j] = variabl21971[k][variabl1211];
break o;
} else if (fa4.getText().trim()
.equals("条数")) {
if ((variabl21972[i - 1][j] != null)
&& (variabl21972[i - 1][j]
.length() > 0))
variabl21972[i - 1][j] = ""
+ (Integer
.valueOf(variabl21972[i - 1][j]) + 1);
else
variabl21972[i - 1][j] = "1";
break o;
} else
variabl21972[i - 1][j] = variabl21971[k][variabl1211];
}
for (int i = 1; i <= variabl2033; i++)
variabl21972[i - 1][0] = variabl2289[i];
variabl19132 = new String[variabl1929 + 1];
variabl2651 = variabl1929 + 1;
variabl11692 = new String[variabl1929 + 1];
variabl11192 = new int[variabl1929 + 1];
variabl19132[0] = fa1.getText().trim();
for (int i = 0; i < variabl1929; i++) {
variabl19132[i + 1] = variabl2439[i + 1];
variabl11692[i + 1] = variabl1169[variabl1211];
variabl11192[i + 1] = variabl1119[variabl1211];
}
int variabl1181 = 0;
for (int i = 0; i < variabl19132.length; i++) {
if (variabl19132[i].length() > variabl1181)
variabl1181 = variabl19132[i].length();
}
variabl11692[0] = "nchar";
variabl11192[0] = variabl1181;
for (int i = 0; i < variabl21972.length; i++)
for (int j = 1; j < variabl2651; j++) {
if ((variabl21972[i][j] == null)
|| (variabl21972[i][j].length() < 0))
variabl21972[i][j] = "0";
}
} catch (Exception e1) {
e1.printStackTrace();
}
page2();
}
});
transformButton1.setBounds(30, variabl2503 - 120, 150, 20);
if (variabl1187.indexOf(",0,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel.add(transformButton1);
}
final JButton transformButton2 = new JButton(variabl2405[1]);
transformButton2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int variabl16931 = 0, variabl16932 = 0;
for (int i = 0; i < variabl21131; i++)
if (variabl19131[i].length() > variabl16931)
variabl16931 = variabl19131[i].length();
variabl16932 = variabl16931;
for (int i = 0; i < variabl21131; i++)
if (variabl1119[i] > variabl16932)
variabl16932 = variabl1119[i];
try {
variabl21972 = new String[variabl21131 - 1][variabl1853 + 1];
variabl19132 = new String[variabl1853 + 1];
variabl2651 = variabl1853 + 1;
variabl11692 = new String[variabl1853 + 1];
variabl11192 = new int[variabl1853 + 1];
variabl19132[0] = variabl19131[0];
variabl11692[0] = "nchar";
variabl11192[0] = variabl16931 + 1;
for (int i = 0; i < variabl1853; i++) {
for (int j = 1; j < variabl21131; j++) {
variabl21972[j - 1][i + 1] = variabl21971[i][j];
}
variabl19132[i + 1] = variabl21971[i][0];
variabl11192[i + 1] = variabl16932;
}
for (int j = 1; j < variabl21131; j++)
variabl21972[j - 1][0] = variabl19131[j];
page2();
} catch (Exception e1) {
e1.printStackTrace();
}
}
});
transformButton2.setBounds(180, variabl2503 - 120, 150, 20);
if (variabl1187.indexOf(",1,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel.add(transformButton2);
}
final JButton exitButton = new JButton(variabl2405[5]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
}
});
exitButton.setBounds(330, variabl2503 - 120, 150, 20);
if (variabl1187.indexOf(",5,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel.add(exitButton);
}
frame1.getContentPane().add(panel, null);
frame1.setVisible(true);
frame1.getContentPane().add(panel, BorderLayout.SOUTH);
}
public static void page2() {
frame2.setTitle("交叉表或转置表");
frame2.setBounds(100, 10, variabl2483 - 10, variabl2503 - 10);
frame2.getContentPane().setLayout(null);
final JPanel panel2 = new JPanel(false);
panel2.setLayout(null);
panel2.setBounds(20, 20, variabl2483 - 20, variabl2503 - 20);
variabl19652 = new DefaultTableModel(variabl21972, variabl19132);
variabl26552 = new JTable(variabl19652);
variabl26552.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl26552.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(variabl26552, null);
scrollPane2.setBounds(20, 20, variabl2483 - 180, variabl2503 - 200);
panel2.add(scrollPane2);
variabl2305 = -1;
variabl26552.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
variabl2305 = variabl26552.getSelectedRow();
}
});
int variabl2337 = 270;
int variabl2339 = frame1.variabl2339;
final JButton printButton5 = new JButton(variabl2405[2]);
printButton5.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String variabl26031 = "";
variabl26031 = JOptionPane.showInputDialog("请输入新数据表名称：");
s1 = "CREATE TABLE " + variabl26031 + " (";
for (int i = 0; i < variabl19132.length; i++) {
s1 = s1 + variabl19132[i] + " " + variabl11692[i];
if (main1.variabl2511.lastIndexOf("," + variabl11692[i]
+ ",") >= 0)
s1 = s1 + "(" + variabl11192[0] + ")";
if (i != variabl19132.length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
try {
con = main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
String variabl25111 = main1.variabl1545;
for (int i = 0; i < variabl21972.length; i++) {
s1 = "insert into " + variabl26031 + " values (";
for (int j = 0; j < variabl19132.length; j++) {
if (variabl25111.lastIndexOf("," + variabl11692[j]
+ ",") >= 0) {
if (variabl21972[i][j] == null)
variabl21972[i][j] = "0";
s1 = s1 + variabl21972[i][j];
} else {
if (variabl21972[i][j] == null)
variabl21972[i][j] = " ";
s1 = s1 + "'" + variabl21972[i][j] + "'";
}
if (j != variabl19132.length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
sta3.executeUpdate(s1);
}
sta3.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
}
}
});
printButton5.setBounds(variabl2337, variabl2503 - 140, variabl2339, 20);
if (variabl1187.indexOf(",2,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(printButton5);
}
final JButton printButton6 = new JButton(variabl2405[3]);
printButton6.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataTransfer0.Trans(variabl19132, variabl11692, variabl11192,
"", variabl21972, variabl2603);
}
});
printButton6.setBounds(variabl2337, variabl2503 - 140, variabl2339, 20);
if (variabl1187.indexOf(",3,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(printButton6);
}
final JButton printButton7 = new JButton(variabl2405[4]);
printButton7.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
boolean b1 = true;
String x = "";
while (b1) {
x = JOptionPane.showInputDialog(null, "请输入选择序号："
+ "1、显示单柱面统计图；2、显示多柱面统计图" + "3、显示饼形统计图；4、显示折线图");
if ("1234".lastIndexOf(x) < 0)
JOptionPane.showMessageDialog(null,
"输入序号不是1到4中间的数，请重新输入！");
else
b1 = false;
}
if (("134".lastIndexOf(x) >= 0) && (variabl2305 < 0)) {
JOptionPane.showMessageDialog(null,
"您所选图形只对一条记录，请点击表格中某一行后重新操作！");
return;
}
int variabl2481 = Integer.valueOf(x);
int a = 0, variabl26510 = 0;
if (variabl11692[0].lastIndexOf("int") < 0) {
variabl26510 = variabl2651 - 1;
a = 1;
} else
variabl26510 = variabl2651;
String[] variabl25170 = new String[variabl26510];
int[][] variabl2023 = new int[variabl21972.length][variabl26510];
try {
for (int j = 0; j < variabl2651; j++) {
if (a == 0)
variabl25170[j] = variabl19132[j];
else if (j != 0)
variabl25170[j - 1] = variabl19132[j];
}
variabl2253 = new String[variabl19652.getRowCount() + 1];
variabl2253[0] = variabl19132[0];
for (int i = 0; i < variabl21972.length; i++) {
for (int j = 0; j < variabl2651; j++) {
variabl2023[i][variabl26510 - 1] = 0;
if (a == 0) {
variabl2023[i][j] = Integer
.valueOf(variabl21972[i][j]);
} else if (j != 0) {
variabl2023[i][j - 1] = Integer
.valueOf(variabl21972[i][j]);
}
}
variabl2253[i + 1] = variabl21972[i][0];
}
} catch (Exception e1) {
JOptionPane.showMessageDialog(null,
"表中交叉数据部分不能全部转为数字类型，不能绘制统计图！");
return;
}
statisticalChart.GDisplay(variabl2023, variabl2305,
variabl25170, variabl2481, variabl2253);
}
});
printButton7.setBounds(variabl2337, variabl2503 - 140, variabl2339, 20);
if (variabl1187.indexOf(",4,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(printButton7);
}
final JButton exitButton1 = new JButton(variabl2405[5]);
exitButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel2.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame2.setVisible(false);
frame2.dispose();
}
});
exitButton1.setBounds(variabl2337, variabl2503 - 140, variabl2339, 20);
if (variabl1187.indexOf(",5,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(exitButton1);
}
frame2.getContentPane().add(panel2, null);
frame2.setVisible(true);
frame2.getContentPane().add(panel2, BorderLayout.SOUTH);
}
}
68.源码68，部件程序，生成多数据交叉表，之后可打印、转存数据表、转存文件、打印图表。
/*
* 程序文件名：dataStatistic11.java
* 作者：程学先
* 程序功能：生成多数据交叉表，之后可打印、转存数据表、转存文件、打印图表。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
public class dataStatistic11 extends JFrame {
static dataStatistic11 frame1 = new dataStatistic11();
static dataStatistic11 frame2 = new dataStatistic11();
static dataStatistic11 frame3 = new dataStatistic11();
static String variabl2603 = "";
static DefaultTableModel variabl19651;
static DefaultTableModel variabl19652;
static DefaultTableModel variabl19653;
static JTable variabl26551;
static JTable variabl26552;
static JTable variabl26553;
static JScrollPane scrollPane1 = new JScrollPane();
static JScrollPane scrollPane2 = new JScrollPane();
static JScrollPane scrollPane3 = new JScrollPane();
static String s1 = "", s2 = "";
static ResultSet rs;
static int variabl1739 = 0, c = 0;
static int variabl2651, variabl26512;
static int variabl21131;
static String[] variabl2517;
static String[] variabl2439;
static String variabl1735;
static String[] variabl19131;
static String[] variabl19132;
static String[] x1001;
static int x1002;
static String[] variabl2411;
static String[] variabl1501;
static String[] variabl1169;
static String[] variabl11692;
static int[] variabl1489;
static int[] variabl1119;
static int[] variabl11192;
static int variabl1853, variabl18531, variabl2305, variabl18532;
static int variabl1929 = 0, variabl2033 = 0;
static String[][] variabl21971;
static String[][] variabl21972;
static String variabl1685;
static String[] variabl1949;
static String variabl2429;
static String[] variabl2253;
static String variabl1325;
static String variabl2049;
static String[] variabl240501;
static String variabl1079;
static Connection con;
static ResultSetMetaData rsmd3;
static Statement sta3;
static int variabl2483 = 800, variabl2503 = 600;
private static JScrollPane scrollPaneL1 = new JScrollPane();
private static List list1 = new List();
private static JLabel fl0, fl1, fl2, fl3, fl4, fl5, fl6, fl7, fl8, fl9,
fl10, fl11, fl12;
private static JTextField fa0, fa1, fa2, fa3, fa4, fa5, fa6, fa7, fa8, fa9,
fa10, fa11, fa12;
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
frame1 = new dataStatistic11();
frame2 = new dataStatistic11();
frame3 = new dataStatistic11();
variabl2603 = "";
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
s1 = "";
s2 = "";
variabl1739 = 0;
c = 0;
variabl1929 = 0;
variabl2033 = 0;
variabl2483 = 800;
variabl2503 = 600;
JScrollPane scrollPaneL1 = new JScrollPane();
list1 = new List();
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) {
}
frame1 = new dataStatistic11();
frame2 = new dataStatistic11();
frame3 = new dataStatistic11();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
s1 = "";
s2 = "";
variabl1739 = 0;
c = 0;
variabl2483 = 800;
variabl2503 = 600;
scrollPaneL1 = new JScrollPane();
list1 = new List();
variabl2603 = parameter[4];
variabl2429 = parameter[0];
variabl1685 = variabl2603;
variabl1735 = parameter[8];
variabl1079 = parameter[15];
variabl1325 = parameter[19];
variabl2517 = parameter[19].split(",");
if (variabl1735.length() > 0) {
String[] s6 = variabl1735.split(",");
variabl1325 = "";
for (int i = 0; i < s6.length; i++)
if (variabl1325.length() > 0)
variabl1325 = variabl1325 + ","
+ variabl2517[Integer.parseInt(s6[i])];
else
variabl1325 = variabl2517[Integer.parseInt(s6[i])];
}
variabl2049 = parameter[20];
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
if (variabl1325.lastIndexOf(",") == variabl1325.length() - 1)
variabl1325 = variabl1325
.substring(0, variabl1325.length() - 1);
if (variabl2049.trim().length() > 0)
s1 = "select " + variabl1325 + " from " + variabl2603
+ " where " + variabl2049;
else
s1 = "select " + variabl1325 + " from " + variabl2603;
ResultSet rs = sta3.executeQuery(s1);
rsmd3 = rs.getMetaData();
variabl2651 = rsmd3.getColumnCount();
variabl2517 = new String[variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[i] = rsmd3.getColumnName(i + 1);
variabl1501[i] = rsmd3.getColumnTypeName(i + 1);
variabl1489[i] = rsmd3.getPrecision(i + 1);
}
rs.last();
variabl1853 = rs.getRow();
variabl21131 = variabl2651;
variabl19131 = new String[variabl21131];
variabl1169 = new String[variabl21131];
variabl1119 = new int[variabl21131];
for (int i = 0; i < variabl21131; i++) {
variabl19131[i] = variabl2517[i];
variabl1169[i] = variabl1501[i];
variabl1119[i] = variabl1489[i];
}
variabl21971 = new String[variabl1853][variabl2651];
variabl11692 = new String[variabl2651 + 1];
variabl11192 = new int[variabl2651 + 1];
rs.absolute(1);
for (int i = 0; i < variabl1853; i++) {
rs.absolute(i + 1);
for (int j = 0; j < variabl21131; j++) {
variabl21971[i][j] = rs.getString(j + 1);
}
}
rs.close();
sta3.close();
} catch (Exception e) {
e.printStackTrace();
}
frame1.setTitle("多表交叉表程序 作者：程学先");
frame1.setBounds(10, 10, variabl2483 - 10, variabl2503 - 10);
frame1.getContentPane().setLayout(null);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
final JPanel panel = new JPanel(false);
panel.setLayout(null);
panel.setBounds(20, 20, variabl2483 - 50, variabl2503 - 20);
variabl19651 = new DefaultTableModel(variabl21971, variabl19131);
variabl26551 = new JTable(variabl19651);
variabl26551.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl26551.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane1.getViewport().add(variabl26551, null);
scrollPane1.setBounds(20, 20, variabl2483 - 180, variabl2503 - 200);
panel.add(scrollPane1);
list1.setBounds(variabl2483 - 140, 20, 80, variabl2503 - 200);
panel.add(list1);
list1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (list1.getSelectedIndex() >= 0) {
int w1, w2, h1, h2;
switch (variabl1739) {
case 1:
if (fa1.getText().trim().length() > 0)
fa1.setText(fa1.getText().trim() + ","
+ list1.getSelectedItem());
else
fa1.setText(list1.getSelectedItem());
break;
case 2:
fa2.setText(list1.getSelectedItem());
break;
case 3:
fa3.setText(list1.getSelectedItem());
break;
case 4:
fa4.setText(list1.getSelectedItem());
break;
}
}
}
});
fl1 = new JLabel("行");
fl1.setBounds(30, variabl2503 - 170, 40, 20);
panel.add(fl1);
fa1 = new JTextField("", 20);
fa1.setBounds(70, variabl2503 - 170, 100, 20);
panel.add(fa1);
fa1.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 1;
list1.removeAll();
for (int j = 0; j < variabl21131; j++) {
list1.add(variabl19131[j]);
}
}
});
fl2 = new JLabel("列");
fl2.setBounds(170, variabl2503 - 170, 40, 20);
panel.add(fl2);
fa2 = new JTextField("", 20);
fa2.setBounds(210, variabl2503 - 170, 100, 20);
panel.add(fa2);
fa2.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 2;
list1.removeAll();
for (int j = 0; j < variabl21131; j++) {
list1.add(variabl19131[j]);
}
}
});
fl3 = new JLabel("交叉数据");
fl3.setBounds(310, variabl2503 - 170, 60, 20);
panel.add(fl3);
fa3 = new JTextField("", 20);
fa3.setBounds(370, variabl2503 - 170, 100, 20);
panel.add(fa3);
fa3.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 3;
list1.removeAll();
for (int j = 0; j < variabl21131; j++) {
list1.add(variabl19131[j]);
}
}
});
fl4 = new JLabel("聚集函数");
fl4.setBounds(470, variabl2503 - 170, 60, 20);
panel.add(fl4);
fa4 = new JTextField("", 20);
fa4.setBounds(530, variabl2503 - 170, 100, 20);
panel.add(fa4);
fa4.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 4;
list1.removeAll();
list1.add(" ");
list1.add("和");
list1.add("条数");
}
});
variabl2339 = (variabl2483 - 60) / variabl2851;
int variabl2337 = 30;
final JButton transformButton1 = new JButton(variabl2405[0]);
transformButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
try {
variabl1949 = fa1.getText().trim().split(",");
int variabl2341[] = new int[variabl1949.length];
int variabl2345 = 0;
int 交叉号 = 0;
String[] variabl1993 = new String[variabl1853];
variabl26512 = variabl1949.length;
for (int i = 0; i < variabl21131; i++) {
for (int j = 0; j < variabl26512; j++)
if (variabl19131[i].trim().equalsIgnoreCase(
variabl1949[j].trim())) {
variabl2341[j] = i;
}
if (variabl19131[i].trim().equalsIgnoreCase(
fa2.getText().trim())) {
variabl2345 = i;
}
if (variabl19131[i].trim().equalsIgnoreCase(
fa3.getText().trim())) {
交叉号 = i;
}
}
for (int i = 0; i < variabl1853; i++) {
variabl1993[i] = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl1993[i].length() == 0)
variabl1993[i] = variabl21971[i][variabl2341[j]];
else
variabl1993[i] = variabl1993[i] + ","
+ variabl21971[i][variabl2341[j]];
}
}
求分组(variabl1993);
variabl18532 = x1002;
String[][] lins = new String[variabl18532][variabl26512];
String[] lins1 = new String[variabl1853];
for (int i = 0; i < variabl18532; i++)
lins[i] = x1001[i].split(",");
for (int i = 0; i < variabl1853; i++)
lins1[i] = variabl21971[i][variabl2345];
求分组(lins1);
variabl26512 = variabl1949.length + x1002;
variabl19132 = new String[variabl26512];
for (int i = 0; i < variabl1949.length; i++) {
variabl19132[i] = variabl1949[i];
}
for (int i = variabl1949.length; i < variabl26512; i++) {
variabl19132[i] = x1001[i - variabl1949.length];
}
variabl21972 = new String[variabl18532][variabl26512];
String[] x1003 = new String[variabl18532];
for (int i = 0; i < variabl18532; i++) {
x1003[i] = "";
for (int j = 0; j < variabl1949.length; j++) {
variabl21972[i][j] = lins[i][j];
if (x1003[i].length() == 0)
x1003[i] = lins[i][j];
else
x1003[i] = x1003[i] + "," + lins[i][j];
}
}
for (int k = 0; k < variabl1853; k++)
for (int i = 0; i < variabl18532; i++)
if (variabl1993[k].equalsIgnoreCase(x1003[i])) {
for (int j = 0; j < variabl26512; j++) {
if (variabl19132[j]
.equalsIgnoreCase(variabl21971[k][variabl2345])) {
variabl21972[i][j] = variabl21971[k][交叉号];
}
}
}
} catch (Exception e1) {
e1.printStackTrace();
}
page2();
}
});
transformButton1.setBounds(variabl2337, variabl2503 - 120, variabl2339,
20);
if (variabl1187.indexOf(",0,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel.add(transformButton1);
}
final JButton exitButton = new JButton(variabl2405[6]);
exitButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
}
});
exitButton.setBounds(variabl2337, variabl2503 - 120, variabl2339, 20);
if (variabl1187.indexOf(",1,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel.add(exitButton);
}
frame1.getContentPane().add(panel, null);
frame1.setVisible(true);
frame1.getContentPane().add(panel, BorderLayout.SOUTH);
}
public static void 求分组(String[] a) {
x1001 = new String[500];
int b = 0;
int k = 0;
for (int i = 0; i < a.length; i++) {
k = 0;
for (int j = 0; j <= b; j++) {
if (x1001[j] == null) {
if (k == 0) {
x1001[b] = a[i];
b++;
break;
}
} else if (a[i].equalsIgnoreCase(x1001[j])) {
break;
}
}
}
x1002 = b;
String sk = "";
for (int i = 0; i < b; i++)
for (int j = 0; j <= i; j++)
if (x1001[i].compareTo(x1001[j]) < 0) {
sk = x1001[i];
x1001[i] = x1001[j];
x1001[j] = sk;
}
}
public static void page2() {
frame2.setTitle("多数据项交叉表");
frame2.setBounds(100, 10, variabl2483 - 10, variabl2503 - 10);
frame2.getContentPane().setLayout(null);
final JPanel panel2 = new JPanel(false);
panel2.setLayout(null);
panel2.setBounds(20, 20, variabl2483 - 20, variabl2503 - 20);
variabl19652 = new DefaultTableModel(variabl21972, variabl19132);
variabl26552 = new JTable(variabl19652);
variabl26552.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl26552.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(variabl26552, null);
scrollPane2.setBounds(20, 20, variabl2483 - 180, variabl2503 - 200);
panel2.add(scrollPane2);
variabl2305 = -1;
variabl26552.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
variabl2305 = variabl26552.getSelectedRow();
}
});
int variabl2337 = 30, variabl2339 = frame1.variabl2339;
final JButton printButton3 = new JButton(variabl2405[1]);
printButton3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPreview0.printView1(variabl19132, variabl21972,
variabl11192, variabl1685);
}
});
printButton3.setBounds(variabl2337, variabl2503 - 140, variabl2339, 20);
if (variabl1187.indexOf(",1,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(printButton3);
}
final JButton printButton4 = new JButton(variabl2405[2]);
printButton4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPrint0.printView1(variabl19132, variabl21972, variabl11192,
variabl1685);
}
});
printButton4.setBounds(variabl2337, variabl2503 - 140, variabl2339, 20);
if (variabl1187.indexOf(",2,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(printButton4);
}
final JButton printButton5 = new JButton(variabl2405[3]);
printButton5.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
boolean b0 = true;
String variabl26031 = "";
variabl26031 = JOptionPane.showInputDialog("请输入新数据表名称：");
s1 = "CREATE TABLE " + variabl26031 + " (";
for (int i = 0; i < variabl19132.length; i++) {
s1 = s1 + variabl19132[i] + " " + variabl11692[i];
if (main1.variabl2511.lastIndexOf("," + variabl11692[i]
+ ",") >= 0)
s1 = s1 + "(" + variabl11192[i] + ")";
if (i != variabl19132.length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
try {
con = main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sta3.executeUpdate(s1);
String variabl25111 = main1.variabl1545;
for (int i = 0; i < variabl21972.length; i++) {
s1 = "insert into " + variabl26031 + " values (";
for (int j = 0; j < variabl19132.length; j++) {
if (variabl25111.lastIndexOf("," + variabl11692[j]
+ ",") >= 0) {
if (variabl21972[i][j] == null)
variabl21972[i][j] = "0";
s1 = s1 + variabl21972[i][j];
} else {
if (variabl21972[i][j] == null)
variabl21972[i][j] = " ";
s1 = s1 + "'" + variabl21972[i][j] + "'";
}
if (j != variabl19132.length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
sta3.executeUpdate(s1);
}
sta3.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
}
}
});
printButton5.setBounds(variabl2337, variabl2503 - 140, variabl2339, 20);
if (variabl1187.indexOf(",3,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(printButton5);
}
final JButton printButton6 = new JButton(variabl2405[4]);
printButton6.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataTransfer0.Trans(variabl19132, variabl11692, variabl11192,
" ", variabl21972, variabl2603);
}
});
printButton6.setBounds(variabl2337, variabl2503 - 140, variabl2339, 20);
if (variabl1187.indexOf(",4,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(printButton6);
}
final JButton printButton7 = new JButton(variabl2405[5]);
printButton7.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
boolean b1 = true;
String x = "";
while (b1) {
x = JOptionPane.showInputDialog(null, "请输入选择序号："
+ "1、显示单柱面统计图；2、显示多柱面统计图" + "3、显示饼形统计图；4、显示折线图");
if ("1234".lastIndexOf(x) < 0)
JOptionPane.showMessageDialog(null,
"输入序号不是1到4中间的数，请重新输入！");
else
b1 = false;
}
if (("134".lastIndexOf(x) >= 0) && (variabl2305 < 0)) {
JOptionPane.showMessageDialog(null,
"您所选图形只对一条记录，请点击表格中某一行后重新操作！");
return;
}
int variabl2481 = Integer.valueOf(x);
int a = 0, variabl26510 = 0;
if (variabl1501[0].lastIndexOf("int") < 0) {
variabl26510 = variabl2651 - 1;
a = 1;
} else
variabl26510 = variabl2651;
String[] variabl25170 = new String[variabl26510];
int[][] variabl2023 = new int[variabl21972.length][variabl26510];
try {
for (int j = 0; j < variabl2651; j++) {
if (a == 0)
variabl25170[j] = variabl19132[j];
else if (j != 0)
variabl25170[j - 1] = variabl19132[j];
}
variabl2253 = new String[variabl19652.getRowCount() + 1];
variabl2253[0] = variabl19132[0];
for (int i = 0; i < variabl21972.length; i++) {
for (int j = 0; j < variabl2651; j++) {
variabl2023[i][variabl26510 - 1] = 0;
if (a == 0) {
variabl2023[i][j] = Integer
.valueOf(variabl21972[i][j]);
} else if (j != 0) {
variabl2023[i][j - 1] = Integer
.valueOf(variabl21972[i][j]);
}
}
variabl2253[i + 1] = variabl21972[i][0];
}
} catch (Exception e1) {
JOptionPane.showMessageDialog(null,
"表中交叉数据部分短缺，绘制统计图失败，请补充缺项，或改用程序10！");
return;
}
statisticalChart.GDisplay(variabl2023, variabl2305,
variabl25170, variabl2481, variabl2253);
}
});
printButton7.setBounds(variabl2337, variabl2503 - 140, variabl2339, 20);
if (variabl1187.indexOf(",6,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(printButton7);
}
frame2.getContentPane().add(panel2, null);
frame2.setVisible(true);
frame2.getContentPane().add(panel2, BorderLayout.SOUTH);
}
}
69.源码69，部件程序，一元线性回归分析程序，可显示拟合曲线。
/*
* 程序文件名：dataStatistic12.java
* 作者：程学先
* 程序功能：对数据库中某数据表中二个字段的数据进行一元线性回归分析并显示拟合曲线。
*/
import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Insets;
import java.awt.List;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumn;
import javax.swing.table.TableModel;
public class dataStatistic12 extends JFrame {
static String[] variabl2517;
static float[] variabl1841;
static float[] variabl1661;
static int variabl1555 = 0, variabl1519 = 0;
static int variabl1727 = 1200, variabl1783 = 700;
static int variabl1853, variabl2651, variabl1739;
static Graphics g;
static Graphics2D g2;
static Insets inset;
static int variabl2661 = 100, variabl2657 = variabl1783;
private static JTable table;
static Connection con;
private static ResultSetMetaData rsmd4;
static String variabl2603;
static String s1 = "", s2 = "", s3 = "";
static int variabl2483 = 900, variabl2503 = 600;
static int variabl2113;
static String[] variabl1913;
static int variabl19631, variabl19632;
static String[] variabl1501;
static Object[][] variabl2197;
static List list1 = new List();
static JTextField fa0, fa1, fa2, fa3;
static int variabl2177 = 1, variabl1827 = 1;
static String[] variabl2405 = null;
static String variabl1187;
static int variabl2851 = 0, variabl2339 = 0;
public static void means(String[] parameter) {
variabl1555 = 0;
variabl1519 = 0;
variabl1727 = 1200;
variabl1783 = 700;
variabl2661 = 100;
variabl2657 = variabl1783;
s1 = "";
s2 = "";
s3 = "";
list1 = new List();
variabl2177 = 1;
variabl1827 = 1;
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 = 1000;
variabl2503 = 700;
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];
main1.driver1();
con = main1.getConn();
try {
Statement sta = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
s1 = "select * from " + variabl2603;
ResultSet rs = sta.executeQuery(s1);
rs.last();
variabl1853 = rs.getRow();
rsmd4 = rs.getMetaData();
variabl2113 = rsmd4.getColumnCount();
variabl1913 = new String[variabl2113];
String[] variabl1501 = new String[variabl2113];
int[] variabl1489 = new int[variabl2113];
for (int i = 0; i < variabl2113; i++) {
variabl1913[i] = rsmd4.getColumnName(i + 1);
variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
}
variabl2197 = new String[variabl1853][variabl2113];
for (int i = 0; i < variabl1853; i++) {
rs.absolute(i + 1);
for (int j = 0; j < variabl2113; j++) {
s3 = rs.getString(j + 1);
variabl2197[i][j] = s3;
}
}
rs.close();
con.close();
sta.close();
} catch (Exception e1) {
e1.printStackTrace();
}
final dataStatistic12 frame1 = new dataStatistic12();
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame1.setTitle("统计程序 作者：程学先");
frame1.setBounds(10, 10, variabl1727, variabl1783 + 50);
frame1.setLayout(null);
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(10, 10, variabl2483 - 60, variabl2503 - 100);
final TableModel model = new DefaultTableModel(variabl2197, variabl1913);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2113; i++) {
TableColumn tc = table.getColumn(variabl1913[i]);
tc.setPreferredWidth(100);
tc.setMaxWidth(100);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table);
frame1.getContentPane().add(scrollPane, BorderLayout.CENTER);
inset = frame1.getInsets();
JLabel fl0 = new JLabel("纵向字段名");
frame1.add(fl0);
fa0 = new JTextField("", 20);
frame1.add(fa0);
fl0.setBounds(30, variabl2503 - 70, 70, 20);
fa0.setBounds(100, variabl2503 - 70, 80, 20);
fa0.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 0;
}
});
JLabel fl1 = new JLabel("纵向相乘系数");
frame1.add(fl1);
fa1 = new JTextField("", 20);
frame1.add(fa1);
fl1.setBounds(185, variabl2503 - 70, 90, 20);
fa1.setBounds(275, variabl2503 - 70, 80, 20);
fa1.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 1;
}
});
JLabel fl2 = new JLabel("横向字段名");
frame1.add(fl2);
fa2 = new JTextField("", 20);
frame1.add(fa2);
fl2.setBounds(360, variabl2503 - 70, 70, 20);
fa2.setBounds(430, variabl2503 - 70, 80, 20);
fa2.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 2;
}
});
JLabel fl3 = new JLabel("横向相乘系数");
frame1.add(fl3);
fa3 = new JTextField("", 20);
frame1.add(fa3);
fl3.setBounds(515, variabl2503 - 70, 80, 20);
fa3.setBounds(595, variabl2503 - 70, 80, 20);
fa3.addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
variabl1739 = 3;
}
});
list1.setBounds(variabl2483 - 50, 10, 120, variabl2503 - 100);
frame1.add(list1);
list1.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (list1.getSelectedIndex() >= 0) {
switch (variabl1739) {
case 0:
fa0.setText(list1.getSelectedItem());
variabl19631 = list1.getSelectedIndex();
break;
case 2:
fa2.setText(list1.getSelectedItem());
variabl19632 = list1.getSelectedIndex();
break;
}
}
}
});
for (int j = 0; j < variabl2113; j++) {
list1.add(variabl1913[j]);
}
variabl2339 = (variabl2483 - 750) / variabl2851;
int variabl2337 = 680;
final JButton Button1 = new JButton(variabl2405[0]);
Button1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1841 = new float[variabl1853];
variabl1661 = new float[variabl1853];
variabl2177 = Integer.valueOf(fa1.getText().toString());
variabl1827 = Integer.valueOf(fa3.getText().toString());
for (int i = 0; i < variabl1853; i++) {
variabl1841[i] = Float
.parseFloat(variabl2197[i][variabl19631].toString())
* variabl2177;
variabl1661[i] = Float
.parseFloat(variabl2197[i][variabl19632].toString())
* variabl1827;
}
calc.calc1();
}
});
Button1.setBounds(variabl2337, variabl2503 - 70, variabl2339, 20);
if (variabl1187.indexOf(",0,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
frame1.add(Button1);
}
final JButton Button2 = new JButton(variabl2405[1]);
Button2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame1.setVisible(false);
frame1.dispose();
calc.frame2.setVisible(false);
calc.frame2.dispose();
}
});
Button2.setBounds(variabl2337, variabl2503 - 70, variabl2339, 20);
if (variabl1187.indexOf(",1,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
frame1.add(Button2);
frame1.setVisible(true);
}
}
}
class calc extends JFrame {
static calc frame2 = new calc();
static Graphics g;
static float[] variabl1841, variabl1661;
static int variabl1853;
static int variabl1727 = 1000, variabl1783 = 700;
static int variabl1555 = 0, variabl1519, variabl1581 = 0, variabl1305;
static int variabl1415 = 20, variabl1395 = 20;
static int variabl2177 = 1, variabl1827 = 1;
static void calc1() {
calc frame2 = new calc();
frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame2.setBounds(10, 10, variabl1727, variabl1783 + 50);
frame2.setVisible(true);
}
public void paint(Graphics g1) {
variabl1853 = dataStatistic12.variabl1853;
variabl1841 = new float[variabl1853];
variabl1661 = new float[variabl1853];
variabl2177 = dataStatistic12.variabl2177;
variabl1827 = dataStatistic12.variabl1827;
variabl1519 = (int) (dataStatistic12.variabl1841[1]);
variabl1305 = (int) (dataStatistic12.variabl1661[1]);
for (int i = 0; i < variabl1853; i++) {
variabl1841[i] = dataStatistic12.variabl1841[i];
variabl1661[i] = dataStatistic12.variabl1661[i];
if (variabl1841[i] > variabl1555)
variabl1555 = (int) (variabl1841[i]);
if (variabl1841[i] < variabl1519)
variabl1519 = (int) (variabl1841[i]);
if (variabl1661[i] > variabl1581)
variabl1581 = (int) (variabl1661[i]);
if (variabl1661[i] < variabl1305)
variabl1305 = (int) (variabl1661[i]);
}
g1.setColor(Color.WHITE);
g1.fillRect(0, 0, getWidth(), getHeight());
g = g1;
brokenLine();
}
static void brokenLine() {
g.setColor(Color.BLACK);
int variabl1617 = variabl1783 - 100;
float variabl1029 = (float) ((variabl1555 - variabl1519))
/ (variabl1415);
float variabl1019 = (float) (variabl1617) / (variabl1555 - variabl1519);
int variabl1529 = 60;
int variabl1437 = 60;
float variabl1021 = (float) ((variabl1581 - variabl1305))
/ (variabl1395);
float variabl1027 = (float) ((variabl1727 - 200))
/ (variabl1581 - variabl1305);
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(new BasicStroke(2f));
g.drawLine(variabl1529, variabl1437 - 10, variabl1529, variabl1617
+ variabl1437 + 5);
g.drawLine(variabl1529, variabl1437 - 15, variabl1529 - 3, variabl1437);
g.drawLine(variabl1529, variabl1437 - 15, variabl1529 + 2, variabl1437);
g.setColor(Color.RED);
g.drawString(dataStatistic12.fa0.getText(), variabl1529 + 10,
variabl1437 - 5);
int x = 0, y = 0;
int w0 = 5, h0 = 5;
float variabl2283 = 0f, variabl2365 = 0f, variabl1869 = 0f, variabl1561 = 0f;
float variabl24531 = 0f, variabl24231 = 0f, Lxx1 = 0f, Lxy1 = 0f;
for (int i = 0; i < variabl1853; i++) {
variabl2283 = variabl2283 + variabl1661[i] / variabl1827;
variabl2365 = variabl2365 + variabl1841[i] / variabl2177;
variabl1869 = variabl1869 + variabl1661[i] * variabl1841[i]
/ variabl2177 / variabl1827;
variabl1561 = variabl1561 + variabl1661[i] * variabl1661[i]
/ variabl1827 / variabl1827;
float yyy = (variabl1841[i] - variabl1519) * variabl1019;
yyy = variabl1617 + variabl1437 - yyy;
float xxx = (variabl1661[i] - variabl1305) * variabl1027
+ variabl1529;
g.fillOval((int) xxx, (int) yyy, w0, h0);
}
variabl24531 = variabl2283 / variabl1853;
variabl24231 = variabl2365 / variabl1853;
Lxx1 = variabl1561 - variabl2283 * variabl2283 / variabl1853;
Lxy1 = variabl1869 - variabl2283 * variabl2365 / variabl1853;
String variabl16751 = "回归方程1=" + "Y="
+ (variabl24231 - Lxy1 * variabl24531 / Lxx1) + "+"
+ (Lxy1 / Lxx1) + "x";
g.drawString(variabl16751, 100, variabl1783);
float x2, y2, z1;
x2 = (variabl1581 - variabl1305) * variabl1027 + variabl1529;
y2 = ((variabl24231 - Lxy1 * variabl24531 / Lxx1) + (Lxy1 / Lxx1)
* variabl1581)
- variabl1519;
y2 = variabl1617 + variabl1437 - y2 * variabl1019;
g.setColor(Color.RED);
float xx1 = variabl1305 / variabl1827;
float xx2 = variabl1581 / variabl1827;
float yy1 = (variabl24231 - Lxy1 * variabl24531 / Lxx1)
+ (Lxy1 / Lxx1 * xx1);
float yy2 = (variabl24231 - Lxy1 * variabl24531 / Lxx1)
+ (Lxy1 / Lxx1 * xx2);
xx1 = (xx1 * variabl1827 - variabl1305) * variabl1027 + variabl1529;
xx2 = (xx2 * variabl1827 - variabl1305) * variabl1027 + variabl1529;
yy1 = (yy1 * variabl2177 - variabl1519) * variabl1019;
yy2 = (yy2 * variabl2177 - variabl1519) * variabl1019;
yy1 = variabl1617 + variabl1437 - yy1;
yy2 = variabl1617 + variabl1437 - yy2;
g.drawLine((int) (xx1), (int) (yy1), (int) (xx2), (int) (yy2));
String z0;
int y0 = 0;
for (int i = 0; i < variabl1415; i++) {
z1 = ((i + 1) * variabl1029 + variabl1519) / variabl2177;
z0 = z1 + " ";
z0 = z0.substring(0, 6);
x = variabl1529 - 40;
y = variabl1437 * 2 + variabl1617
- (int) (variabl1529 + (i + 1) * variabl1019 * variabl1029);
g.setColor(Color.RED);
g.drawString(z0, x, y);
g.setColor(Color.BLACK);
g.drawLine(x + 35, y, x + 45, y);
}
g.drawLine(x, variabl1437 + variabl1617, x + variabl1727 - 80,
variabl1437 + variabl1617);
g.drawLine(x + variabl1727 - 100, variabl1437 + variabl1617 - 3, x
+ variabl1727 - 80, variabl1437 + variabl1617);
g.drawLine(x + variabl1727 - 100, variabl1437 + variabl1617 + 3, x
+ variabl1727 - 80, variabl1437 + variabl1617);
g.setColor(Color.RED);
g.drawString(dataStatistic12.fa2.getText().toString(), x + variabl1727
- 120, variabl1437 + variabl1617 + 20);
for (int i = 0; i < variabl1395; i++) {
g.setColor(Color.RED);
z1 = ((i + 1) * variabl1021 + variabl1305) / variabl1827;
z0 = z1 + " ";
z0 = z0.substring(0, 6);
x = (int) (variabl1529 + (i + 1) * variabl1027 * variabl1021);
y = variabl1437 + variabl1617 + 6;
g.drawString(z0, x, y + 10);
g.setColor(Color.BLACK);
g.drawLine(x, y - 10, x, y - 5);
}
}
}
70.源码70，部件程序，关系代数运算程序，可用于数据表间关系运算变换。
/*
* 程序文件名：dataStatistic13.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 dataStatistic13 extends JFrame implements ItemListener {
private static final ItemListener ItemListener = null;
private static dataStatistic13 frame1 = new dataStatistic13();
private static dataStatistic13 frame2 = new dataStatistic13();
private static dataStatistic13 frame3 = new dataStatistic13();
private static JPanel panel1 = new JPanel();
private static JPanel panel2 = 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 JPopupMenu variabl2051 = new JPopupMenu();
private static JPopupMenu variabl20512 = new JPopupMenu();
private static JLabel fl0, fl10, fl20, fl30;
private static JTextField fa10, fa30;
private static String[][] variabl21971;
private static String[][] variabl21972;
private static String[][] variabl21973;
private static String variabl26031;
private static String variabl26032;
private static String[] variabl25171;
private static String[] variabl25172;
private static String[] variabl25173;
private static int variabl26511;
private static int variabl26512;
private static int variabl26513;
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 String variabl1275 = "sql server";
static String variabl1091 = "sql1";
private static Statement sta3;
private static ResultSet rs;
static String s1 = "", s2 = "", s3 = "", s4 = "", variabl2327 = "";
static char x1 = 10, x2 = 13;
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 dataStatistic13();
frame2 = new dataStatistic13();
frame3 = new dataStatistic13();
panel1 = new JPanel();
panel2 = new JPanel();
panel3 = new JPanel();
scrollPane1 = new JScrollPane();
scrollPane2 = new JScrollPane();
scrollPane3 = new JScrollPane();
variabl2051 = new JPopupMenu();
variabl20512 = new JPopupMenu();
variabl18531 = 0;
variabl18532 = 0;
variabl18533 = 0;
variabl17391 = 0;
variabl17392 = 0;
variabl2187 = 0;
variabl2017 = 0;
variabl1803 = 0;
list1 = new ArrayList();
fa0 = new Choice();
set1 = new HashSet();
set2 = new HashSet();
variabl1275 = "sql server";
variabl1091 = "sql1";
s1 = "";
s2 = "";
s3 = "";
s4 = "";
variabl2327 = "";
x1 = 10;
x2 = 13;
String[] variabl240501 = { "求笛卡尔积", "求并集", "求交集", "表1减表2", "求连接",
"左连接", "全连接", "表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) {
}
variabl26031 = parameter[4];
variabl26032 = parameter[2];
main1.driver1();
parameter[0] = "";
try {
String[] tableType = { "TABLE" };
Connection con;
con = main1.getConn();
DatabaseMetaData databaseMetaData = con.getMetaData();
ResultSet resultSet = databaseMetaData.getTables(null, null, "%",
tableType);
while (resultSet.next()) {
parameter[0] = parameter[0] + resultSet.getString("TABLE_NAME")
+ ",";
}
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "获取表名失败！");
}
frame1.setTitle("表1 作者：程学先");
frame2.setTitle("表2");
frame3.setTitle("运算结果 作者：程学先");
frame1.setBounds(10, 10, 1000, 660);
frame2.setBounds(100, 10, 1000, 660);
frame3.setBounds(200, 10, 1000, 660);
frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel1.setBounds(10, 10, 1000, 660);
panel2.setBounds(100, 10, 1000, 660);
panel3.setBounds(200, 10, 1000, 660);
panel1.setLayout(null);
panel2.setLayout(null);
panel3.setLayout(null);
if ((variabl26031 != null) && (variabl26031.length() > 0)) {
int c = 0;
int b = 0;
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl26031;
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26511 = rsmd.getColumnCount();
variabl25171 = new String[variabl26511];
variabl19191 = new String[variabl26511];
variabl15011 = new String[variabl26511];
variabl14891 = new int[variabl26511];
for (int i = 0; i < variabl26511; i++) {
variabl25171[i] = rsmd.getColumnName(i + 1);
variabl19191[i] = " ";
variabl15011[i] = rsmd.getColumnTypeName(i + 1);
variabl14891[i] = rsmd.getColumnDisplaySize(i + 1);
variabl2187 = variabl2187 + variabl14891[i] * 4;
}
rs.last();
variabl18531 = rs.getRow();
variabl21971 = new String[variabl18531][variabl26511];
rs.absolute(1);
while (c < variabl18531) {
rs.absolute(c + 1);
while (b < variabl26511) {
variabl21971[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表1失败！" + s1);
return;
}
variabl19651 = new DefaultTableModel(variabl21971, variabl25171);
variabl26551 = new JTable(variabl19651);
variabl26551.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
variabl26551.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
for (int i = 0; i < variabl26511; i++) {
TableColumn tc = variabl26551.getColumn(variabl25171[i]);
tc.setPreferredWidth(variabl14891[i] * 4);
}
scrollPane1.getViewport().add(variabl26551, null);
scrollPane1.setBounds(20, 60, variabl2187, 450);
panel1.add(scrollPane1);
JMenuItem variabl24011 = new JMenuItem("添加一行");
variabl2051.add(variabl24011);
JMenuItem variabl24012 = new JMenuItem("删除一行");
variabl2051.add(variabl24012);
JMenuItem variabl24013 = new JMenuItem("添加一列");
variabl2051.add(variabl24013);
JMenuItem variabl24014 = new JMenuItem("删除一列");
variabl2051.add(variabl24014);
variabl24011.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent arg0) {
variabl19651.addRow(variabl19191);
variabl18531++;
}
});
variabl24012.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent arg0) {
variabl19651.removeRow(variabl18231);
variabl18531--;
}
});
variabl24013.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent arg0) {
String variabl2443 = JOptionPane
.showInputDialog("请输入新列的名称：");
String[] s6 = new String[variabl26511 + 1];
int[] s7 = new int[variabl26511 + 1];
String[] s9 = new String[variabl26511 + 1];
String[][] s8 = new String[variabl19651.getRowCount()][variabl26511 + 1];
for (int j = 0; j < variabl26511; j++) {
s6[j] = variabl25171[j];
s7[j] = variabl14891[j];
s9[j] = variabl15011[j];
for (int i = 0; i < variabl19651.getRowCount(); i++) {
if (variabl19651.getValueAt(i, j) == null)
s8[i][j] = "";
else
s8[i][j] = variabl19651.getValueAt(i, j)
.toString();
}
}
for (int i = 0; i < variabl19651.getRowCount(); i++) {
s8[i][variabl26511] = "";
}
variabl26511++;
s6[variabl26511 - 1] = variabl2443;
s7[variabl26511 - 1] = 30;
s9[variabl26511 - 1] = "char";
variabl2187 = variabl2187 + 30;
variabl21971 = new String[variabl19651.getRowCount()][variabl26511];
variabl25171 = new String[variabl26511];
variabl14891 = new int[variabl26511];
variabl15011 = new String[variabl26511];
for (int j = 0; j < variabl26511; j++) {
variabl25171[j] = s6[j];
variabl14891[j] = s7[j];
variabl15011[j] = s9[j];
for (int i = 0; i < variabl19651.getRowCount(); i++) {
variabl21971[i][j] = s8[i][j];
}
}
scrollPane1.setBounds(20, 60, variabl2187 * 4, 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] * 4);
}
panel1.add(scrollPane1);
variabl26551.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl2051.show(variabl26551, e.getX() + 100,
e.getY());
variabl18231 = variabl26551.rowAtPoint(e
.getPoint());
variabl17391 = variabl26551.columnAtPoint(e
.getPoint());
}
}
});
}
});
variabl24014.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent arg0) {
variabl2187 = variabl2187 - variabl14891[variabl17391];
variabl26511 = variabl26511 - 1;
String[] s6 = new String[variabl26511];
int[] s7 = new int[variabl26511];
String[] s8 = new String[variabl26511];
variabl2187 = 0;
for (int i = 0; i < variabl26511; i++) {
if (i < variabl17391) {
s6[i] = variabl25171[i];
s7[i] = variabl14891[i];
s8[i] = variabl15011[i];
} else {
s6[i] = variabl25171[i + 1];
s7[i] = variabl14891[i + 1];
s8[i] = variabl15011[i + 1];
}
variabl2187 = variabl2187 + s7[i];
}
variabl25171 = new String[variabl26511];
variabl14891 = new int[variabl26511];
variabl15011 = new String[variabl26511];
for (int i = 0; i < variabl26511; i++) {
variabl25171[i] = s6[i];
variabl14891[i] = s7[i];
variabl15011[i] = s8[i];
}
variabl21971 = new String[variabl19651.getRowCount()][variabl26511];
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
for (int j = 0; j < variabl26511; j++) {
if (j < variabl17391) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21971[i1][j] = "";
else
variabl21971[i1][j] = variabl19651
.getValueAt(i1, j).toString();
} else {
if (variabl19651.getValueAt(i1, j + 1) == null)
variabl21971[i1][j] = "";
else
variabl21971[i1][j] = variabl19651
.getValueAt(i1, j + 1).toString();
}
}
}
scrollPane1.setBounds(20, 60, variabl2187 * 4, 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] * 4);
}
panel1.add(scrollPane1);
variabl26551.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl2051.show(variabl26551, e.getX() + 100,
e.getY());
variabl18231 = variabl26551.rowAtPoint(e
.getPoint());
variabl17391 = variabl26551.columnAtPoint(e
.getPoint());
}
}
});
}
});
variabl26551.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl2051.show(variabl26551, e.getX() + 100, e.getY());
variabl18231 = variabl26551.rowAtPoint(e.getPoint());
variabl17391 = variabl26551.columnAtPoint(e.getPoint());
}
}
});
}
if ((variabl26032 != null) && (variabl26032.length() > 0)) {
int c = 0;
int b = 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];
variabl19192 = new String[variabl26512];
variabl15012 = new String[variabl26512];
variabl14892 = new int[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmd.getColumnName(i + 1);
variabl19192[i] = " ";
variabl15012[i] = rsmd.getColumnTypeName(i + 1);
variabl14892[i] = rsmd.getColumnDisplaySize(i + 1);
variabl2017 = variabl2017 + variabl14892[i] * 4;
}
rs.last();
variabl18532 = rs.getRow();
variabl21972 = new String[variabl18532][variabl26512];
rs.absolute(1);
while (c < variabl18532) {
rs.absolute(c + 1);
while (b < variabl26512) {
variabl21972[c][b] = rs.getString(b + 1);
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(20, 60, variabl2017, 450);
panel2.add(scrollPane2);
for (int i = 0; i < variabl26512; i++) {
TableColumn tc = variabl26552.getColumn(variabl25172[i]);
tc.setPreferredWidth(variabl14892[i] * 4);
}
panel2.add(scrollPane2);
variabl26552.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl20512.show(variabl26552, e.getX() + 100,
e.getY());
variabl18232 = variabl26552.rowAtPoint(e.getPoint());
variabl17392 = variabl26552.columnAtPoint(e.getPoint());
}
}
});
JMenuItem variabl240112 = new JMenuItem("添加一行");
variabl20512.add(variabl240112);
JMenuItem variabl240122 = new JMenuItem("删除一行");
variabl20512.add(variabl240122);
JMenuItem variabl240132 = new JMenuItem("添加一列");
variabl20512.add(variabl240132);
JMenuItem variabl240142 = new JMenuItem("删除一列");
variabl20512.add(variabl240142);
variabl240112.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent arg0) {
variabl19652.addRow(variabl19191);
variabl18532++;
}
});
variabl240122.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent arg0) {
variabl19652.removeRow(variabl18232);
variabl18532--;
}
});
variabl240132.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent arg0) {
String variabl2443 = JOptionPane
.showInputDialog("请输入新列的名称：");
String[] s16 = new String[variabl26512 + 1];
int[] s17 = new int[variabl26512 + 1];
String[] s19 = new String[variabl26512 + 1];
String[][] s18 = new String[variabl19652.getRowCount()][variabl26512 + 1];
for (int j = 0; j < variabl26512; j++) {
s16[j] = variabl25172[j];
s17[j] = variabl14892[j];
s19[j] = variabl15012[j];
for (int i = 0; i < variabl19652.getRowCount(); i++) {
if (variabl19652.getValueAt(i, j) == null)
s18[i][j] = "";
else
s18[i][j] = variabl19652.getValueAt(i, j)
.toString();
}
}
for (int i = 0; i < variabl19652.getRowCount(); i++) {
s18[i][variabl26512] = "";
}
variabl26512++;
s16[variabl26512 - 1] = variabl2443;
s17[variabl26512 - 1] = 30;
s19[variabl26512 - 1] = "char";
variabl2017 = variabl2017 + 30;
variabl21972 = new String[variabl19652.getRowCount()][variabl26512];
variabl25172 = new String[variabl26512];
variabl14892 = new int[variabl26512];
variabl15012 = new String[variabl26512];
for (int j = 0; j < variabl26512; j++) {
variabl25172[j] = s16[j];
variabl14892[j] = s17[j];
variabl15012[j] = s19[j];
for (int i = 0; i < variabl19652.getRowCount(); i++) {
variabl21972[i][j] = s18[i][j];
}
}
scrollPane2.setBounds(20, 60, variabl2017 * 4, 450);
variabl19652 = new DefaultTableModel(variabl21972,
variabl25172);
variabl26552 = new JTable(variabl19652);
variabl26552.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(variabl26552, null);
for (int i = 0; i < variabl26512; i++) {
TableColumn tc = variabl26552
.getColumn(variabl25172[i]);
tc.setPreferredWidth(variabl14892[i] * 4);
}
panel2.add(scrollPane2);
variabl26552.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl20512.show(variabl26552, e.getX() + 100,
e.getY());
variabl18232 = variabl26552.rowAtPoint(e
.getPoint());
variabl17392 = variabl26552.columnAtPoint(e
.getPoint());
}
}
});
}
});
variabl240142.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent arg0) {
variabl2017 = variabl2017 - variabl14892[variabl17392];
variabl26512 = variabl26512 - 1;
String[] s6 = new String[variabl26512];
int[] s7 = new int[variabl26512];
String[] s8 = new String[variabl26512];
variabl2017 = 0;
for (int i = 0; i < variabl26512; i++) {
if (i < variabl17392) {
s6[i] = variabl25172[i];
s7[i] = variabl14892[i];
s8[i] = variabl15012[i];
} else {
s6[i] = variabl25172[i + 1];
s7[i] = variabl14892[i + 1];
s8[i] = variabl15012[i + 1];
}
variabl2017 = variabl2017 + s7[i];
}
variabl25172 = new String[variabl26512];
variabl14892 = new int[variabl26512];
variabl15012 = new String[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = s6[i];
variabl14892[i] = s7[i];
variabl15012[i] = s8[i];
}
variabl21972 = new String[variabl19652.getRowCount()][variabl26512];
for (int i1 = 0; i1 < variabl19652.getRowCount(); i1++) {
for (int j = 0; j < variabl26512; j++) {
if (j < variabl17392) {
if (variabl19652.getValueAt(i1, j) == null)
variabl21972[i1][j] = "";
else
variabl21972[i1][j] = variabl19652
.getValueAt(i1, j).toString();
} else {
if (variabl19652.getValueAt(i1, j + 1) == null)
variabl21972[i1][j] = "";
else
variabl21972[i1][j] = variabl19652
.getValueAt(i1, j + 1).toString();
}
}
}
scrollPane2.setBounds(20, 60, variabl2017 * 4, 450);
variabl19652 = new DefaultTableModel(variabl21972,
variabl25172);
variabl26552 = new JTable(variabl19652);
variabl26552.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(variabl26552, null);
for (int i = 0; i < variabl26512; i++) {
TableColumn tc = variabl26552
.getColumn(variabl25172[i]);
tc.setPreferredWidth(variabl14892[i] * 4);
}
panel2.add(scrollPane2);
variabl26552.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl20512.show(variabl26552, e.getX() + 100,
e.getY());
variabl18232 = variabl26552.rowAtPoint(e
.getPoint());
variabl17392 = variabl26552.columnAtPoint(e
.getPoint());
}
}
});
}
});
}
fl0 = new JLabel("数据表1表名1");
fl0.setBounds(40, 10, 90, 20);
panel1.add(fl0);
String[] s9 = parameter[0].split(",");
fa0.setBounds(130, 10, 150, 20);
for (int i = 0; i < s9.length; i++)
fa0.add(s9[i]);
panel1.add(fa0);
fa0.addItemListener(frame1);
fl10 = new JLabel("数据表1文件名1");
fl10.setBounds(310, 10, 100, 20);
panel1.add(fl10);
fa10 = new JTextField("", 20);
fa10.setBounds(410, 10, 150, 20);
panel1.add(fa10);
fa10.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (fa10.getText().length() < 1) {
final JFileChooser fc = new JFileChooser(".\\");
fc.showOpenDialog(null);
if (fc.getSelectedFile() != null) {
fa10.setText(fc.getSelectedFile().toString());
File file1 = new File(fa10.getText());
try {
if (file1.exists()) {
FileReader fr = new FileReader(file1);
BufferedReader br = new BufferedReader(fr);
String tempStr = null;
variabl18531 = 0;
String[][] s29 = new String[10][10];
;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
if (i == 0) {
variabl25171 = tempStr.split(",");
variabl26511 = variabl25171.length;
s29 = new String[100][variabl26511];
} else {
s29[variabl18531] = tempStr.split(",");
variabl18531++;
}
}
variabl21971 = new String[variabl18531][variabl26511];
variabl14891 = new int[variabl26511];
variabl15011 = new String[variabl26511];
for (int j = 0; j < variabl26511; j++) {
variabl15011[j] = "char";
}
for (int i = 0; i < variabl18531; i++) {
for (int j = 0; j < variabl26511; j++) {
variabl21971[i][j] = s29[i][j];
if (variabl21971[i][j].length() > variabl14891[j])
variabl14891[j] = variabl21971[i][j]
.length();
}
}
variabl2187 = 0;
for (int j = 0; j < variabl26511; j++) {
variabl2187 = variabl2187 + variabl14891[j]
* 20;
}
}
} catch (IOException e2) {
JOptionPane.showMessageDialog(null, "打开文件错！");
}
scrollPane1.setBounds(20, 60, 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] * 20);
}
panel1.add(scrollPane1);
variabl26551.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl2051.show(variabl26551,
e.getX() + 100, e.getY());
variabl18231 = variabl26551.rowAtPoint(e
.getPoint());
variabl17391 = variabl26551.columnAtPoint(e
.getPoint());
}
}
});
}
}
}
});
fl20 = new JLabel("数据表表名2");
fl20.setBounds(40, 10, 90, 20);
panel2.add(fl20);
String[] s09 = parameter[0].split(",");
final JComboBox fa20 = new JComboBox();
fa20.setBounds(130, 10, 150, 20);
for (int i = 0; i < s09.length; i++)
fa20.addItem(s09[i]);
panel2.add(fa20);
fa20.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent arg0) {
try {
con = main1.getConn();
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + fa20.getSelectedItem();
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26512 = rsmd.getColumnCount();
variabl25172 = new String[variabl26512];
variabl19192 = new String[variabl26512];
variabl15012 = new String[variabl26512];
variabl14892 = new int[variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmd.getColumnName(i + 1);
variabl19192[i] = " ";
variabl15012[i] = rsmd.getColumnTypeName(i + 1);
variabl14892[i] = rsmd.getColumnDisplaySize(i + 1);
variabl2017 = variabl2017 + variabl14892[i] * 4;
}
rs.last();
variabl18532 = rs.getRow();
variabl21972 = new String[variabl18532][variabl26512];
rs.absolute(1);
int c = 0, b = 0;
while (c < variabl18532) {
rs.absolute(c + 1);
while (b < variabl26512) {
variabl21972[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表2失败！" + s1);
return;
}
scrollPane2.setBounds(20, 60, variabl2017, 450);
variabl19652 = new DefaultTableModel(variabl21972, variabl25172);
variabl26552 = new JTable(variabl19652);
variabl26552.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(variabl26552, null);
for (int i = 0; i < variabl26512; i++) {
TableColumn tc = variabl26552.getColumn(variabl25172[i]);
tc.setPreferredWidth(variabl14892[i] * 4);
}
panel2.add(scrollPane2);
variabl26552.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl20512.show(variabl26552, e.getX() + 100,
e.getY());
variabl18232 = variabl26552.rowAtPoint(e.getPoint());
variabl17392 = variabl26552.columnAtPoint(e
.getPoint());
}
}
});
}
});
fl30 = new JLabel("数据表1文件名1");
fl30.setBounds(310, 10, 100, 20);
panel2.add(fl30);
fa30 = new JTextField("", 20);
fa30.setBounds(410, 10, 150, 20);
panel2.add(fa30);
fa30.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (fa30.getText().length() < 1) {
final JFileChooser fc1 = new JFileChooser(".\\");
fc1.showOpenDialog(null);
if (fc1.getSelectedFile() != null) {
fa30.setText(fc1.getSelectedFile().toString());
File file1 = new File(fa30.getText());
try {
if (file1.exists()) {
FileReader fr = new FileReader(file1);
BufferedReader br = new BufferedReader(fr);
String tempStr = null;
variabl18532 = 0;
String[][] s9 = new String[10][10];
;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
if (i == 0) {
variabl25172 = tempStr.split(",");
variabl26512 = variabl25172.length;
s9 = new String[100][variabl26512];
} else {
s9[variabl18532] = tempStr.split(",");
variabl18532++;
}
}
variabl21972 = new String[variabl18532][variabl26512];
variabl14892 = new int[variabl26512];
variabl15012 = new String[variabl26512];
for (int j = 0; j < variabl26512; j++) {
variabl15012[j] = "char";
}
for (int i = 0; i < variabl18532; i++) {
for (int j = 0; j < variabl26512; j++) {
variabl21972[i][j] = s9[i][j];
if (variabl21972[i][j].length() > variabl14892[j])
variabl14892[j] = variabl21972[i][j]
.length();
}
}
variabl2017 = 0;
for (int j = 0; j < variabl26512; j++) {
variabl2017 = variabl2017 + variabl14892[j]
* 20;
}
}
} catch (IOException e2) {
JOptionPane.showMessageDialog(null, "打开文件错！");
}
scrollPane2.setBounds(20, 60, variabl2017, 450);
variabl19652 = new DefaultTableModel(variabl21972,
variabl25172);
variabl26552 = new JTable(variabl19652);
variabl26552.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane2.getViewport().add(variabl26552, null);
for (int i = 0; i < variabl26512; i++) {
TableColumn tc = variabl26552
.getColumn(variabl25172[i]);
tc.setPreferredWidth(variabl14892[i] * 20);
}
panel2.add(scrollPane2);
variabl26552.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl20512.show(variabl26552,
e.getX() + 100, e.getY());
variabl18232 = variabl26552.rowAtPoint(e
.getPoint());
variabl17392 = variabl26552.columnAtPoint(e
.getPoint());
}
}
});
}
}
}
});
variabl2339 = (variabl2483 - 60) / variabl2851;
int variabl2337 = 30;
final JButton variabl1957 = new JButton(variabl2405[0]);
variabl1957.setBounds(variabl2337, 540, variabl2339, 20);
variabl1957.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1803 = variabl2187 + variabl2017;
variabl26513 = variabl26511 + variabl26512;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl21973 = new String[variabl19651.getRowCount()
* variabl19652.getRowCount()][variabl26513];
variabl15013 = new String[variabl26513];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl14893[j] = variabl14891[j];
}
for (int j = 0; j < variabl26512; j++) {
variabl15013[j + variabl26511] = variabl15012[j];
variabl25173[j + variabl26511] = variabl25172[j];
variabl14893[j + variabl26511] = variabl14892[j];
}
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
for (int i2 = 0; i2 < variabl19652.getRowCount(); i2++) {
int n2 = variabl19652.getRowCount();
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[i1 * n2 + i2][j] = "";
else
variabl21973[i1 * n2 + i2][j] = variabl19651
.getValueAt(i1, j).toString();
}
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null)
variabl21973[i1 * n2 + i2][j + variabl26511] = "";
else
variabl21973[i1 * n2 + i2][j + variabl26511] = variabl19652
.getValueAt(i2, j).toString();
}
}
}
scrollPane3.setBounds(20, 60, variabl1803 * 4, 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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",0,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel1.add(variabl1957);
}
final JButton variabl2285 = new JButton(variabl2405[1]);
variabl2285.setBounds(variabl2337, 540, variabl2339, 20);
variabl2285.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1803 = variabl2187;
if (variabl26511 != variabl26512) {
JOptionPane.showMessageDialog(null, "二表列数不相等，不能求并集！" + s1);
return;
}
variabl19653 = new DefaultTableModel(variabl21971, variabl25171);
variabl26513 = variabl26511;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl21973 = new String[variabl19651.getRowCount()][variabl26513];
for (int j = 0; j < variabl26511; j++) {
variabl25173[j] = variabl25171[j];
variabl14893[j] = variabl14891[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
s6 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[i1][j] = "";
else {
variabl21973[i1][j] = variabl19651
.getValueAt(i1, j).toString();
s6 = s6 + variabl21973[i1][j].trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = variabl19652.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null) {
s6 = s6 + "";
variabl19652.setValueAt("", i2, j);
variabl19191[j] = "";
} else {
s6 = s6
+ variabl19652.getValueAt(i2, j).toString()
.trim();
variabl19191[j] = variabl19652.getValueAt(i2, j)
.toString();
}
}
set1.add(s6);
if (set1.size() != size1) {
size1 = set1.size();
variabl19653.addRow(variabl19191);
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",1,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel1.add(variabl2285);
}
final JButton variabl2287 = new JButton(variabl2405[2]);
variabl2287.setBounds(variabl2337, 540, variabl2339, 20);
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];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl14893[j] = variabl14891[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
s6 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) != null) {
s6 = s6
+ variabl19651.getValueAt(i1, j).toString()
.trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = variabl19652.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null) {
s6 = s6 + "";
variabl19191[j] = "";
} else {
s6 = s6
+ variabl19652.getValueAt(i2, j).toString()
.trim();
variabl19191[j] = variabl19652.getValueAt(i2, j)
.toString();
}
}
set1.add(s6);
if (set1.size() == size1) {
if (variabl1391 == 0) {
variabl1391 = 1;
variabl21973 = new String[1][variabl26511];
for (int j = 0; j < variabl26511; j++) {
variabl21973[0][j] = variabl19191[j];
}
variabl19653 = new DefaultTableModel(variabl21973,
variabl25171);
} else
variabl19653.addRow(variabl19191);
} else
size1 = set1.size();
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",2,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel1.add(variabl2287);
}
final JButton variabl1449 = new JButton(variabl2405[3]);
variabl1449.setBounds(variabl2337, 540, variabl2339, 20);
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];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl14893[j] = variabl14891[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < variabl19652.getRowCount(); i1++) {
int n1 = variabl19652.getRowCount();
s6 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19652.getValueAt(i1, j) != null) {
s6 = s6
+ variabl19652.getValueAt(i1, j).toString()
.trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = variabl19651.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl19651.getValueAt(i2, j) == null) {
s6 = s6 + "";
variabl19191[j] = "";
} else {
s6 = s6
+ variabl19651.getValueAt(i2, j).toString()
.trim();
variabl19191[j] = variabl19651.getValueAt(i2, j)
.toString();
}
}
set1.add(s6);
if (set1.size() != size1) {
if (variabl1391 == 0) {
variabl1391 = 1;
variabl21973 = new String[1][variabl26511];
for (int j = 0; j < variabl26511; j++) {
variabl21973[0][j] = variabl19191[j];
}
variabl19653 = new DefaultTableModel(variabl21973,
variabl25171);
} else
variabl19653.addRow(variabl19191);
} else
size1 = set1.size();
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",3,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel1.add(variabl1449);
}
final JButton variabl2491 = new JButton(variabl2405[4]);
variabl2491.setBounds(variabl2337, 540, variabl2339, 20);
variabl2491.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<variabl25171><variabl2259><variabl25172>" + x1
+ x2 + "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int variabl26731 = 0, variabl26732 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < variabl26511; i++)
if (s8[0].trim().equals(variabl25171[i].trim()))
variabl26731 = i;
String variabl2511 = "";
if (main1.variabl1545.lastIndexOf(","
+ variabl15011[variabl26731] + ",") >= 0)
variabl2511 = "数字";
else
variabl2511 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < variabl26512; i++)
if (s8[1].trim().equals(variabl25172[i].trim()))
variabl26732 = i;
for (int i = 0; i < variabl26511; i++)
for (int j = 0; j < variabl26512; j++)
if (variabl25171[i].trim().equals(
variabl25172[j].trim()))
list1.add(variabl25171[i]);
variabl1803 = variabl2187 + variabl2017;
variabl26513 = variabl26511 + variabl26512;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl21973 = new String[1][variabl26513];
variabl15013 = new String[variabl26513];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl21973[0][j] = "";
variabl14893[j] = variabl14891[j];
}
for (int j = 0; j < variabl26512; j++) {
variabl15013[j + variabl26511] = variabl15012[j];
variabl25173[j + variabl26511] = variabl25172[j];
variabl21973[0][j + variabl26511] = "";
variabl14893[j + variabl26511] = variabl14892[j];
}
int variabl2559 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
for (int i2 = 0; i2 < variabl19652.getRowCount(); i2++) {
int n2 = variabl19652.getRowCount();
if (variabl19651.getValueAt(i1, variabl26731) == null)
s1 = "";
else
s1 = variabl19651.getValueAt(i1, variabl26731)
.toString();
if (variabl19652.getValueAt(i2, variabl26732) == null)
s2 = "";
else
s2 = variabl19652.getValueAt(i2, variabl26732)
.toString();
if (condition1(s1, s7, s2, variabl2511)) {
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[0][j] = "";
else
variabl21973[0][j] = variabl19651
.getValueAt(i1, j).toString()
.trim();
}
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null)
variabl21973[0][j + variabl26511] = "";
else
variabl21973[0][j + variabl26511] = variabl19652
.getValueAt(i2, j).toString()
.trim();
}
if (variabl2559 == 0) {
variabl2559 = 1;
variabl19653 = new DefaultTableModel(
variabl21973, variabl25173);
} else
variabl19653.addRow(variabl21973[0]);
}
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",4,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel1.add(variabl2491);
}
final JButton variabl2415 = new JButton(variabl2405[5]);
variabl2415.setBounds(variabl2337, 540, variabl2339, 20);
variabl2415.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<variabl25171><variabl2259><variabl25172>" + x1
+ x2 + "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int variabl26731 = 0, variabl26732 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < variabl26511; i++)
if (s8[0].trim().equals(variabl25171[i].trim()))
variabl26731 = i;
String variabl2511 = "";
if (main1.variabl1545.lastIndexOf(","
+ variabl15011[variabl26731] + ",") >= 0)
variabl2511 = "数字";
else
variabl2511 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < variabl26512; i++)
if (s8[1].trim().equals(variabl25172[i].trim()))
variabl26732 = i;
for (int i = 0; i < variabl26511; i++)
for (int j = 0; j < variabl26512; j++)
if (variabl25171[i].trim().equals(
variabl25172[j].trim()))
list1.add(variabl25171[i]);
variabl1803 = variabl2187 + variabl2017;
variabl26513 = variabl26511 + variabl26512;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl21973 = new String[1][variabl26513];
variabl15013 = new String[variabl26513];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl21973[0][j] = "";
variabl14893[j] = variabl14891[j];
}
for (int j = 0; j < variabl26512; j++) {
variabl15013[j + variabl26511] = variabl15012[j];
variabl25173[j + variabl26511] = variabl25172[j];
variabl21973[0][j + variabl26511] = "";
variabl14893[j + variabl26511] = variabl14892[j];
}
int variabl2559 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
for (int i2 = 0; i2 < variabl19652.getRowCount(); i2++) {
int n2 = variabl19652.getRowCount();
if (variabl19651.getValueAt(i1, variabl26731) == null)
s1 = "";
else
s1 = variabl19651.getValueAt(i1, variabl26731)
.toString();
if (variabl19652.getValueAt(i2, variabl26732) == null)
s2 = "";
else
s2 = variabl19652.getValueAt(i2, variabl26732)
.toString();
if (condition1(s1, s7, s2, variabl2511)) {
s3 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[0][j] = "";
else
variabl21973[0][j] = variabl19651
.getValueAt(i1, j).toString()
.trim();
s3 = s3 + variabl21973[0][j];
}
set1.add(s3);
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null)
variabl21973[0][j + variabl26511] = "";
else
variabl21973[0][j + variabl26511] = variabl19652
.getValueAt(i2, j).toString()
.trim();
}
if (variabl2559 == 0) {
variabl2559 = 1;
variabl19653 = new DefaultTableModel(
variabl21973, variabl25173);
} else
variabl19653.addRow(variabl21973[0]);
}
}
}
for (int j = 0; j < variabl26512; j++) {
variabl21973[0][j + variabl26511] = "";
}
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n = set1.size();
s3 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[0][j] = "";
else
variabl21973[0][j] = variabl19651.getValueAt(i1, j)
.toString().trim();
s3 = s3 + variabl21973[0][j];
}
set1.add(s3);
if (set1.size() != n) {
n = set1.size();
variabl19653.addRow(variabl21973[0]);
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",5,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel1.add(variabl2415);
}
final JButton variabl2425 = new JButton(variabl2405[6]);
variabl2425.setBounds(variabl2337, 540, variabl2339, 20);
variabl2425.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
set2.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<variabl25171><variabl2259><variabl25172>" + x1
+ x2 + "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int variabl26731 = 0, variabl26732 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < variabl26511; i++)
if (s8[0].trim().equals(variabl25171[i].trim()))
variabl26731 = i;
String variabl2511 = "";
if (main1.variabl1545.lastIndexOf(","
+ variabl15011[variabl26731] + ",") >= 0)
variabl2511 = "数字";
else
variabl2511 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < variabl26512; i++)
if (s8[1].trim().equals(variabl25172[i].trim()))
variabl26732 = i;
for (int i = 0; i < variabl26511; i++)
for (int j = 0; j < variabl26512; j++)
if (variabl25171[i].trim().equals(
variabl25172[j].trim()))
list1.add(variabl25171[i]);
variabl1803 = variabl2187 + variabl2017;
variabl26513 = variabl26511 + variabl26512;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl21973 = new String[1][variabl26513];
variabl15013 = new String[variabl26513];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl21973[0][j] = "";
variabl14893[j] = variabl14891[j];
}
for (int j = 0; j < variabl26512; j++) {
variabl15013[j + variabl26511] = variabl15012[j];
variabl25173[j + variabl26511] = variabl25172[j];
variabl21973[0][j + variabl26511] = "";
variabl14893[j + variabl26511] = variabl14892[j];
}
int variabl2559 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
for (int i2 = 0; i2 < variabl19652.getRowCount(); i2++) {
int n2 = variabl19652.getRowCount();
if (variabl19651.getValueAt(i1, variabl26731) == null)
s1 = "";
else
s1 = variabl19651.getValueAt(i1, variabl26731)
.toString();
if (variabl19652.getValueAt(i2, variabl26732) == null)
s2 = "";
else
s2 = variabl19652.getValueAt(i2, variabl26732)
.toString();
if (condition1(s1, s7, s2, variabl2511)) {
s3 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[0][j] = "";
else
variabl21973[0][j] = variabl19651
.getValueAt(i1, j).toString()
.trim();
s3 = s3 + variabl21973[0][j];
}
set1.add(s3);
s4 = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null)
variabl21973[0][j + variabl26511] = "";
else
variabl21973[0][j + variabl26511] = variabl19652
.getValueAt(i2, j).toString()
.trim();
s4 = s4 + variabl21973[0][j + variabl26511];
}
set2.add(s4);
if (variabl2559 == 0) {
variabl2559 = 1;
variabl19653 = new DefaultTableModel(
variabl21973, variabl25173);
} else
variabl19653.addRow(variabl21973[0]);
}
}
}
for (int j = 0; j < variabl26512; j++) {
variabl21973[0][j + variabl26511] = "";
}
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n = set1.size();
s3 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[0][j] = "";
else
variabl21973[0][j] = variabl19651.getValueAt(i1, j)
.toString().trim();
s3 = s3 + variabl21973[0][j];
}
set1.add(s3);
if (set1.size() != n) {
n = set1.size();
variabl19653.addRow(variabl21973[0]);
}
}
for (int j = 0; j < variabl26511; j++) {
variabl21973[0][j] = "";
}
for (int i2 = 0; i2 < variabl19652.getRowCount(); i2++) {
int n = set2.size();
s4 = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null)
variabl21973[0][j + variabl26511] = "";
else
variabl21973[0][j + variabl26511] = variabl19652
.getValueAt(i2, j).toString().trim();
s4 = s4 + variabl21973[0][j + variabl26511];
}
set2.add(s4);
if (set2.size() != n) {
n = set2.size();
variabl19653.addRow(variabl21973[0]);
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",6,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel1.add(variabl2425);
}
final JButton variabl1151 = new JButton(variabl2405[7]);
variabl1151.setBounds(variabl2337, 540, variabl2339, 20);
variabl1151.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String s6 = JOptionPane.showInputDialog("请输入分组字段与要求包含的字段名："
+ x1 + x2 + "格式：<分组字段名集><。><包含字段名集>" + x1 + x2
+ "其中，分组字段名集是表1中某些列的名字，是商集的字段名，用逗号分隔" + x1 + x2
+ "要求包含的字段名是表1与表2中都有的某些列的名字。" + x1 + x2
+ "例如：学号,姓名。课程名");
String[] s8 = s6.split("。");
variabl25173 = s8[0].split(",");
String[] variabl1311 = s8[1].split(",");
variabl26513 = variabl25173.length;
int[] variabl1495 = new int[variabl26513];
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];
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];
}
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 * 8, 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] * 8);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",7,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel1.add(variabl1151);
}
final JButton variabl2537 = new JButton(variabl2405[8]);
variabl2537.setBounds(variabl2337, 540, variabl2339, 20);
variabl2537.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String g6 = JOptionPane.showInputDialog("请输入选择条件：" + x1 + x2
+ "条件式由若干个分条件式经逻辑关系符连接构成。" + x1 + x2
+ "格式：<分条件1>[<逻辑关系><分条件2>][<逻辑关系><分条件3>]" + x1 + x2
+ "其中，逻辑关系包括and、or。前后需有空格。" + x1 + x2 + "本程序不能识别括号。"
+ x1 + x2 + "分条件式由字段名、关系符、数据值（或字段名）构成。必须以字段名开始。" + x1
+ x2 + "格式1：<variabl2385>[<variabl2259><variabl2293>"
+ x1 + x2
+ "格式2：<variabl2385>[<variabl2259><variabl2385>" + x1
+ x2 + "例如：学号>201102 and 性别=男" + x1 + x2
+ "又例如：津贴>基本工资");
g6 = g6.toUpperCase();
String g7 = g6;
g7 = g7.replaceAll("OR", "AND");
String[] g8 = g7.split(" AND ");
int[] g9 = new int[g8.length];
if (g8.length > 1) {
g9[g8.length - 1] = g7.length();
int k = 0;
for (int i = 0; i < g7.length(); i++) {
if (k < g8.length - 1)
g9[k] = g7.indexOf(" AND ", i);
i = g9[k];
k++;
}
}
int variabl26731 = 0, variabl26732 = 0;
String variabl2511 = "";
String s6 = "";
String s7 = "";
String[] s8 = new String[1];
boolean[] l1 = new boolean[variabl19651.getRowCount()];
int variabl2559 = 0;
for (int i = 0; i < g8.length; i++) {
s6 = g8[i];
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
variabl26731 = 0;
variabl26732 = 0;
for (int i1 = 0; i1 < variabl26511; i1++)
if (s8[0].trim().equals(
variabl25171[i1].toUpperCase().trim()))
variabl26731 = i1;
variabl2511 = "";
if (main1.variabl1545.lastIndexOf(","
+ variabl15011[variabl26731] + ",") >= 0)
variabl2511 = "数字";
else
variabl2511 = "字符串";
variabl26732 = -1;
for (int i2 = 0; i2 < variabl26511; i2++)
if (s8[1].trim().equals(
variabl25171[i2].toUpperCase().trim()))
variabl26732 = i2;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
if (variabl19651.getValueAt(i1, variabl26731) == null)
s1 = "";
else
s1 = variabl19651.getValueAt(i1, variabl26731)
.toString().trim();
if (variabl26732 > 0)
if (variabl19651.getValueAt(i1, variabl26732) == null)
s2 = "";
else
s2 = variabl19651.getValueAt(i1, variabl26732)
.toString().trim();
else
s2 = s8[1];
if (i == 0)
l1[i1] = condition1(s1, s7, s2, variabl2511);
else {
if (variabl2559 == 0)
l1[i1] = l1[i1]
&& condition1(s1, s7, s2, variabl2511);
else
l1[i1] = l1[i1]
|| condition1(s1, s7, s2, variabl2511);
}
if (i < g8.length - 1) {
if (g6.substring(g9[i], g9[i] + 4).lastIndexOf(
"AND") > 0)
variabl2559 = 0;
else
variabl2559 = 1;
}
}
}
variabl18533 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++)
if (l1[i1])
variabl18533++;
variabl21973 = new String[variabl18533][variabl26511];
variabl18533 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
if (l1[i1]) {
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[variabl18533][j] = "";
else
variabl21973[variabl18533][j] = variabl19651
.getValueAt(i1, j).toString().trim();
}
variabl18533++;
}
}
variabl15013 = new String[variabl26511];
variabl14893 = new int[variabl26511];
for (int i1 = 0; i1 < variabl26511; i1++) {
variabl15013[i1] = variabl15011[i1];
variabl14893[i1] = variabl14891[i1];
}
scrollPane3.setBounds(20, 60, variabl2187 * 8, 450);
variabl19653 = new DefaultTableModel(variabl21973, variabl25171);
variabl26553 = new JTable(variabl19653);
variabl26553.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(variabl26553, null);
for (int i = 0; i < variabl26511; i++) {
TableColumn tc = variabl26553.getColumn(variabl25171[i]);
tc.setPreferredWidth(variabl14891[i] * 8);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",8,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel1.add(variabl2537);
}
final JButton variabl2549 = new JButton(variabl2405[9]);
variabl2549.setBounds(variabl2337, 540, variabl2339, 20);
variabl2549.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String g6 = JOptionPane.showInputDialog("请输入字段名称集：" + x1 + x2
+ "可以是字段名称，之间用逗号分隔。" + x1 + x2
+ "也可以是字段号，用中括号括起，之间用逗号分隔。" + x1 + x2 + "字段号从1起计数。"
+ x1 + x2 + "例如：学号,姓名,性别,班级,出生日期。" + x1 + x2
+ "又例如：[1],[2],[4],[6]");
String[] s6;
int[] variabl2127;
variabl1803 = 0;
if (g6.lastIndexOf("]") >= 0) {
g6 = g6.substring(g6.indexOf("[") + 1, g6.lastIndexOf("]"));
s6 = g6.split("\\],\\[");
variabl2127 = new int[s6.length];
variabl25173 = new String[s6.length];
variabl26513 = s6.length;
variabl14893 = new int[s6.length];
variabl15013 = new String[s6.length];
for (int j = 0; j < s6.length; j++) {
variabl2127[j] = Integer.parseInt(s6[j]) - 1;
variabl25173[j] = variabl25171[variabl2127[j]];
variabl14893[j] = variabl14891[variabl2127[j]];
variabl15013[j] = variabl15011[variabl2127[j]];
variabl1803 = variabl1803 + variabl14893[j];
}
} else {
variabl25173 = g6.split(",");
variabl2127 = new int[variabl25173.length];
variabl26513 = variabl25173.length;
variabl14893 = new int[variabl25173.length];
variabl15013 = new String[variabl25173.length];
for (int i = 0; i < variabl26511; i++)
for (int j = 0; j < variabl25173.length; j++)
if (variabl25171[i].trim().equals(
variabl25173[j].trim())) {
variabl2127[j] = i;
variabl14893[j] = variabl14891[variabl2127[j]];
variabl15013[j] = variabl15011[variabl2127[j]];
variabl1803 = variabl1803 + variabl14893[j];
}
}
set1.clear();
int n1 = 0;
variabl21973 = new String[variabl19651.getRowCount()][variabl26513];
variabl18533 = variabl19651.getRowCount();
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
s1 = "";
for (int j = 0; j < variabl26513; j++) {
if (variabl19651.getValueAt(i1, variabl2127[j]) == null)
s1 = s1 + "";
else
s1 = s1
+ variabl19651
.getValueAt(i1, variabl2127[j])
.toString().trim();
}
if (s1.length() > 0)
set1.add(s1);
if (set1.size() != n1) {
for (int j = 0; j < variabl26513; j++) {
if (variabl19651.getValueAt(i1, variabl2127[j]) == null)
variabl21973[n1][j] = "";
else
variabl21973[n1][j] = variabl19651
.getValueAt(i1, variabl2127[j])
.toString().trim();
}
n1 = set1.size();
}
}
scrollPane3.setBounds(20, 60, variabl1803 * 8, 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] * 8);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",9,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel1.add(variabl2549);
}
final JButton variabl25991 = new JButton(variabl2405[10]);
variabl25991.setBounds(variabl2337, 540, variabl2339, 20);
variabl25991.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame2.setVisible(false);
frame2.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (variabl1187.indexOf(",10,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel1.add(variabl25991);
}
variabl2337 = 30;
final JButton variabl19572 = new JButton(variabl2405[0]);
variabl19572.setBounds(variabl2337, 540, variabl2339, 20);
variabl19572.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1803 = variabl2187 + variabl2017;
variabl26513 = variabl26511 + variabl26512;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl21973 = new String[variabl19651.getRowCount()
* variabl19652.getRowCount()][variabl26513];
variabl15013 = new String[variabl26513];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl14893[j] = variabl14891[j];
}
for (int j = 0; j < variabl26512; j++) {
variabl15013[j + variabl26511] = variabl15012[j];
variabl25173[j + variabl26511] = variabl25172[j];
variabl14893[j + variabl26511] = variabl14892[j];
}
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
for (int i2 = 0; i2 < variabl19652.getRowCount(); i2++) {
int n2 = variabl19652.getRowCount();
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[i1 * n2 + i2][j] = "";
else
variabl21973[i1 * n2 + i2][j] = variabl19651
.getValueAt(i1, j).toString();
}
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null)
variabl21973[i1 * n2 + i2][j + variabl26511] = "";
else
variabl21973[i1 * n2 + i2][j + variabl26511] = variabl19652
.getValueAt(i2, j).toString();
}
}
}
scrollPane3.setBounds(20, 60, variabl1803 * 4, 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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",0,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(variabl19572);
}
final JButton variabl22852 = new JButton(variabl2405[1]);
variabl22852.setBounds(variabl2337, 540, variabl2339, 20);
variabl22852.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl1803 = variabl2187;
if (variabl26511 != variabl26512) {
JOptionPane.showMessageDialog(null, "二表列数不相等，不能求并集！" + s1);
return;
}
variabl19653 = new DefaultTableModel(variabl21971, variabl25171);
variabl26513 = variabl26511;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl21973 = new String[variabl19651.getRowCount()][variabl26513];
variabl15013 = new String[variabl26513];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl14893[j] = variabl14891[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
s6 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[i1][j] = "";
else {
variabl21973[i1][j] = variabl19651
.getValueAt(i1, j).toString();
s6 = s6 + variabl21973[i1][j].trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = variabl19652.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null) {
s6 = s6 + "";
variabl19652.setValueAt("", i2, j);
variabl19191[j] = "";
} else {
s6 = s6
+ variabl19652.getValueAt(i2, j).toString()
.trim();
variabl19191[j] = variabl19652.getValueAt(i2, j)
.toString();
}
}
set1.add(s6);
if (set1.size() != size1) {
size1 = set1.size();
variabl19653.addRow(variabl19191);
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",1,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(variabl22852);
}
final JButton variabl22872 = new JButton(variabl2405[2]);
variabl22872.setBounds(variabl2337, 540, variabl2339, 20);
variabl22872.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];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl14893[j] = variabl14891[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
s6 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) != null) {
s6 = s6
+ variabl19651.getValueAt(i1, j).toString()
.trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = variabl19652.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null) {
s6 = s6 + "";
variabl19191[j] = "";
} else {
s6 = s6
+ variabl19652.getValueAt(i2, j).toString()
.trim();
variabl19191[j] = variabl19652.getValueAt(i2, j)
.toString();
}
}
set1.add(s6);
if (set1.size() == size1) {
if (variabl1391 == 0) {
variabl1391 = 1;
variabl21973 = new String[1][variabl26511];
for (int j = 0; j < variabl26511; j++) {
variabl21973[0][j] = variabl19191[j];
}
variabl19653 = new DefaultTableModel(variabl21973,
variabl25171);
} else
variabl19653.addRow(variabl19191);
} else
size1 = set1.size();
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",2,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(variabl22872);
}
final JButton variabl14492 = new JButton(variabl2405[3]);
variabl14492.setBounds(variabl2337, 540, variabl2339, 20);
variabl14492.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];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl14893[j] = variabl14891[j];
}
String s6 = "";
int size1 = 0;
for (int i1 = 0; i1 < variabl19652.getRowCount(); i1++) {
int n1 = variabl19652.getRowCount();
s6 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19652.getValueAt(i1, j) != null) {
s6 = s6
+ variabl19652.getValueAt(i1, j).toString()
.trim();
}
}
set1.add(s6);
}
size1 = set1.size();
int n2 = variabl19651.getRowCount();
for (int i2 = 0; i2 < n2; i2++) {
s6 = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl19651.getValueAt(i2, j) == null) {
s6 = s6 + "";
variabl19191[j] = "";
} else {
s6 = s6
+ variabl19651.getValueAt(i2, j).toString()
.trim();
variabl19191[j] = variabl19651.getValueAt(i2, j)
.toString();
}
}
set1.add(s6);
if (set1.size() != size1) {
if (variabl1391 == 0) {
variabl1391 = 1;
variabl21973 = new String[1][variabl26511];
for (int j = 0; j < variabl26511; j++) {
variabl21973[0][j] = variabl19191[j];
}
variabl19653 = new DefaultTableModel(variabl21973,
variabl25171);
} else
variabl19653.addRow(variabl19191);
} else
size1 = set1.size();
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",3,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(variabl14492);
}
final JButton variabl24912 = new JButton(variabl2405[4]);
variabl24912.setBounds(variabl2337, 540, variabl2339, 20);
variabl24912.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<variabl25171><variabl2259><variabl25172>" + x1
+ x2 + "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int variabl26731 = 0, variabl26732 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < variabl26511; i++)
if (s8[0].trim().equals(variabl25171[i].trim()))
variabl26731 = i;
String variabl2511 = "";
if (main1.variabl1545.lastIndexOf(","
+ variabl15011[variabl26731] + ",") >= 0)
variabl2511 = "数字";
else
variabl2511 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < variabl26512; i++)
if (s8[1].trim().equals(variabl25172[i].trim()))
variabl26732 = i;
for (int i = 0; i < variabl26511; i++)
for (int j = 0; j < variabl26512; j++)
if (variabl25171[i].trim().equals(
variabl25172[j].trim()))
list1.add(variabl25171[i]);
variabl1803 = variabl2187 + variabl2017;
variabl26513 = variabl26511 + variabl26512;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl21973 = new String[1][variabl26513];
variabl15013 = new String[variabl26513];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl21973[0][j] = "";
variabl14893[j] = variabl14891[j];
}
for (int j = 0; j < variabl26512; j++) {
variabl15013[j + variabl26511] = variabl15012[j];
variabl25173[j + variabl26511] = variabl25172[j];
variabl21973[0][j + variabl26511] = "";
variabl14893[j + variabl26511] = variabl14892[j];
}
int variabl2559 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
for (int i2 = 0; i2 < variabl19652.getRowCount(); i2++) {
int n2 = variabl19652.getRowCount();
if (variabl19651.getValueAt(i1, variabl26731) == null)
s1 = "";
else
s1 = variabl19651.getValueAt(i1, variabl26731)
.toString();
if (variabl19652.getValueAt(i2, variabl26732) == null)
s2 = "";
else
s2 = variabl19652.getValueAt(i2, variabl26732)
.toString();
if (condition1(s1, s7, s2, variabl2511)) {
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[0][j] = "";
else
variabl21973[0][j] = variabl19651
.getValueAt(i1, j).toString()
.trim();
}
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null)
variabl21973[0][j + variabl26511] = "";
else
variabl21973[0][j + variabl26511] = variabl19652
.getValueAt(i2, j).toString()
.trim();
}
if (variabl2559 == 0) {
variabl2559 = 1;
variabl19653 = new DefaultTableModel(
variabl21973, variabl25173);
} else
variabl19653.addRow(variabl21973[0]);
}
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",4,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(variabl24912);
}
final JButton variabl24152 = new JButton(variabl2405[5]);
variabl24152.setBounds(variabl2337, 540, variabl2339, 20);
variabl24152.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<variabl25171><variabl2259><variabl25172>" + x1
+ x2 + "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int variabl26731 = 0, variabl26732 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < variabl26511; i++)
if (s8[0].trim().equals(variabl25171[i].trim()))
variabl26731 = i;
String variabl2511 = "";
if (main1.variabl1545.lastIndexOf(","
+ variabl15011[variabl26731] + ",") >= 0)
variabl2511 = "数字";
else
variabl2511 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < variabl26512; i++)
if (s8[1].trim().equals(variabl25172[i].trim()))
variabl26732 = i;
for (int i = 0; i < variabl26511; i++)
for (int j = 0; j < variabl26512; j++)
if (variabl25171[i].trim().equals(
variabl25172[j].trim()))
list1.add(variabl25171[i]);
variabl1803 = variabl2187 + variabl2017;
variabl26513 = variabl26511 + variabl26512;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl21973 = new String[1][variabl26513];
variabl15013 = new String[variabl26513];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl21973[0][j] = "";
variabl14893[j] = variabl14891[j];
}
for (int j = 0; j < variabl26512; j++) {
variabl15013[j + variabl26511] = variabl15012[j];
variabl25173[j + variabl26511] = variabl25172[j];
variabl21973[0][j + variabl26511] = "";
variabl14893[j + variabl26511] = variabl14892[j];
}
int variabl2559 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
for (int i2 = 0; i2 < variabl19652.getRowCount(); i2++) {
int n2 = variabl19652.getRowCount();
if (variabl19651.getValueAt(i1, variabl26731) == null)
s1 = "";
else
s1 = variabl19651.getValueAt(i1, variabl26731)
.toString();
if (variabl19652.getValueAt(i2, variabl26732) == null)
s2 = "";
else
s2 = variabl19652.getValueAt(i2, variabl26732)
.toString();
if (condition1(s1, s7, s2, variabl2511)) {
s3 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[0][j] = "";
else
variabl21973[0][j] = variabl19651
.getValueAt(i1, j).toString()
.trim();
s3 = s3 + variabl21973[0][j];
}
set1.add(s3);
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null)
variabl21973[0][j + variabl26511] = "";
else
variabl21973[0][j + variabl26511] = variabl19652
.getValueAt(i2, j).toString()
.trim();
}
if (variabl2559 == 0) {
variabl2559 = 1;
variabl19653 = new DefaultTableModel(
variabl21973, variabl25173);
} else
variabl19653.addRow(variabl21973[0]);
}
}
}
for (int j = 0; j < variabl26512; j++) {
variabl21973[0][j + variabl26511] = "";
}
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n = set1.size();
s3 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[0][j] = "";
else
variabl21973[0][j] = variabl19651.getValueAt(i1, j)
.toString().trim();
s3 = s3 + variabl21973[0][j];
}
set1.add(s3);
if (set1.size() != n) {
n = set1.size();
variabl19653.addRow(variabl21973[0]);
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",5,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(variabl24152);
}
final JButton variabl24252 = new JButton(variabl2405[6]);
variabl24252.setBounds(variabl2337, 540, variabl2339, 20);
variabl24252.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
set1.clear();
set2.clear();
String s6 = JOptionPane.showInputDialog("请输入连接条件：" + x1 + x2
+ "格式：<variabl25171><variabl2259><variabl25172>" + x1
+ x2 + "其中，列名1是表1中某列的名字，列名2是表2中某列的名字，" + x1 + x2
+ "如果在二表中存在相同的列名，在书写时前面要加表名与点" + x1 + x2
+ "表名分别为表1和表2，不用原来数据表名。" + x1 + x2
+ "为方便输入，关系符改用：=，<>，>，>=，<，<=" + x1 + x2
+ "例如：表1.学号=表2.学号");
String s7 = "";
String[] s8;
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
if (s8[0].trim().equals(s8[1].trim())) {
JOptionPane.showMessageDialog(null, "同名字段前要加表名带点！");
return;
}
int variabl26731 = 0, variabl26732 = 0;
if (s8[0].lastIndexOf(".") > 0)
s8[0] = s8[0].substring(s8[0].lastIndexOf(".") + 1,
s8[0].length());
for (int i = 0; i < variabl26511; i++)
if (s8[0].trim().equals(variabl25171[i].trim()))
variabl26731 = i;
String variabl2511 = "";
if (main1.variabl1545.lastIndexOf(","
+ variabl15011[variabl26731] + ",") >= 0)
variabl2511 = "数字";
else
variabl2511 = "字符串";
if (s8[1].lastIndexOf(".") > 0)
s8[1] = s8[1].substring(s8[1].lastIndexOf(".") + 1,
s8[1].length());
for (int i = 0; i < variabl26512; i++)
if (s8[1].trim().equals(variabl25172[i].trim()))
variabl26732 = i;
for (int i = 0; i < variabl26511; i++)
for (int j = 0; j < variabl26512; j++)
if (variabl25171[i].trim().equals(
variabl25172[j].trim()))
list1.add(variabl25171[i]);
variabl1803 = variabl2187 + variabl2017;
variabl26513 = variabl26511 + variabl26512;
variabl25173 = new String[variabl26513];
variabl14893 = new int[variabl26513];
variabl21973 = new String[1][variabl26513];
variabl15013 = new String[variabl26513];
for (int j = 0; j < variabl26511; j++) {
variabl15013[j] = variabl15011[j];
variabl25173[j] = variabl25171[j];
variabl21973[0][j] = "";
variabl14893[j] = variabl14891[j];
}
for (int j = 0; j < variabl26512; j++) {
variabl15013[j + variabl26511] = variabl15012[j];
variabl25173[j + variabl26511] = variabl25172[j];
variabl21973[0][j + variabl26511] = "";
variabl14893[j + variabl26511] = variabl14892[j];
}
int variabl2559 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n1 = variabl19651.getRowCount();
for (int i2 = 0; i2 < variabl19652.getRowCount(); i2++) {
int n2 = variabl19652.getRowCount();
if (variabl19651.getValueAt(i1, variabl26731) == null)
s1 = "";
else
s1 = variabl19651.getValueAt(i1, variabl26731)
.toString();
if (variabl19652.getValueAt(i2, variabl26732) == null)
s2 = "";
else
s2 = variabl19652.getValueAt(i2, variabl26732)
.toString();
if (condition1(s1, s7, s2, variabl2511)) {
s3 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[0][j] = "";
else
variabl21973[0][j] = variabl19651
.getValueAt(i1, j).toString()
.trim();
s3 = s3 + variabl21973[0][j];
}
set1.add(s3);
s4 = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null)
variabl21973[0][j + variabl26511] = "";
else
variabl21973[0][j + variabl26511] = variabl19652
.getValueAt(i2, j).toString()
.trim();
s4 = s4 + variabl21973[0][j + variabl26511];
}
set2.add(s4);
if (variabl2559 == 0) {
variabl2559 = 1;
variabl19653 = new DefaultTableModel(
variabl21973, variabl25173);
} else
variabl19653.addRow(variabl21973[0]);
}
}
}
for (int j = 0; j < variabl26512; j++) {
variabl21973[0][j + variabl26511] = "";
}
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
int n = set1.size();
s3 = "";
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[0][j] = "";
else
variabl21973[0][j] = variabl19651.getValueAt(i1, j)
.toString().trim();
s3 = s3 + variabl21973[0][j];
}
set1.add(s3);
if (set1.size() != n) {
n = set1.size();
variabl19653.addRow(variabl21973[0]);
}
}
for (int j = 0; j < variabl26511; j++) {
variabl21973[0][j] = "";
}
for (int i2 = 0; i2 < variabl19652.getRowCount(); i2++) {
int n = set2.size();
s4 = "";
for (int j = 0; j < variabl26512; j++) {
if (variabl19652.getValueAt(i2, j) == null)
variabl21973[0][j + variabl26511] = "";
else
variabl21973[0][j + variabl26511] = variabl19652
.getValueAt(i2, j).toString().trim();
s4 = s4 + variabl21973[0][j + variabl26511];
}
set2.add(s4);
if (set2.size() != n) {
n = set2.size();
variabl19653.addRow(variabl21973[0]);
}
}
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] * 4);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",6,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(variabl24252);
}
final JButton variabl11512 = new JButton(variabl2405[7]);
variabl11512.setBounds(variabl2337, 540, variabl2339, 20);
variabl11512.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String s6 = JOptionPane.showInputDialog("请输入分组字段与要求包含的字段名："
+ x1 + x2 + "格式：<分组字段名集><。><包含字段名集>" + x1 + x2
+ "其中，分组字段名集是表1中某些列的名字，是商集的字段名，用逗号分隔" + x1 + x2
+ "要求包含的字段名是表1与表2中都有的某些列的名字。" + x1 + x2
+ "例如：学号,姓名。课程名");
String[] s8 = s6.split("。");
variabl25173 = s8[0].split(",");
String[] variabl1311 = s8[1].split(",");
variabl26513 = variabl25173.length;
int[] variabl1495 = new int[variabl26513];
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];
variabl15013[j] = variabl15011[i];
variabl1803 = variabl1803 + variabl14893[j];
}
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 * 8, 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] * 8);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",7,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(variabl11512);
}
final JButton variabl25372 = new JButton(variabl2405[8]);
variabl25372.setBounds(variabl2337, 540, variabl2339, 20);
variabl25372.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String g6 = JOptionPane.showInputDialog("请输入选择条件：" + x1 + x2
+ "条件式由若干个分条件式经逻辑关系符连接构成。" + x1 + x2
+ "格式：<分条件1>[<逻辑关系><分条件2>][<逻辑关系><分条件3>]" + x1 + x2
+ "其中，逻辑关系包括and、or。前后需有空格。" + x1 + x2 + "本程序不能识别括号。"
+ x1 + x2 + "分条件式由字段名、关系符、数据值（或字段名）构成。必须以字段名开始。" + x1
+ x2 + "格式1：<variabl2385>[<variabl2259><variabl2293>"
+ x1 + x2
+ "格式2：<variabl2385>[<variabl2259><variabl2385>" + x1
+ x2 + "例如：学号>201102 and 性别=男" + x1 + x2
+ "又例如：津贴>基本工资");
g6 = g6.toUpperCase();
String g7 = g6;
g7 = g7.replaceAll("OR", "AND");
String[] g8 = g7.split(" AND ");
int[] g9 = new int[g8.length];
if (g8.length > 1) {
g9[g8.length - 1] = g7.length();
int k = 0;
for (int i = 0; i < g7.length(); i++) {
if (k < g8.length - 1)
g9[k] = g7.indexOf(" AND ", i);
i = g9[k];
k++;
}
}
int variabl26731 = 0, variabl26732 = 0;
String variabl2511 = "";
String s6 = "";
String s7 = "";
String[] s8 = new String[1];
boolean[] l1 = new boolean[variabl19651.getRowCount()];
int variabl2559 = 0;
for (int i = 0; i < g8.length; i++) {
s6 = g8[i];
if (s6.lastIndexOf(">=") > 0) {
s7 = ">=";
s8 = s6.split(">=");
} else if (s6.lastIndexOf("<=") > 0) {
s7 = "<=";
s8 = s6.split("<=");
} else if (s6.lastIndexOf("=") > 0) {
s7 = "=";
s8 = s6.split("=");
} else if (s6.lastIndexOf("<>") > 0) {
s7 = "<>";
s8 = s6.split("<>");
} else if (s6.lastIndexOf(">") > 0) {
s7 = ">";
s8 = s6.split(">");
} else if (s6.lastIndexOf("<") > 0) {
s7 = "<";
s8 = s6.split("<");
} else {
JOptionPane.showMessageDialog(null, "缺关系符或关系符用错！");
return;
}
variabl15013 = new String[variabl26511];
variabl14893 = new int[variabl26511];
for (int i1 = 0; i1 < variabl26511; i1++) {
variabl15013[i1] = variabl15011[i1];
variabl14893[i1] = variabl14891[i1];
}
variabl26731 = 0;
variabl26732 = 0;
for (int i1 = 0; i1 < variabl26511; i1++)
if (s8[0].trim().equals(
variabl25171[i1].toUpperCase().trim()))
variabl26731 = i1;
variabl2511 = "";
if (main1.variabl1545.lastIndexOf(","
+ variabl15011[variabl26731] + ",") >= 0)
variabl2511 = "数字";
else
variabl2511 = "字符串";
variabl26732 = -1;
for (int i2 = 0; i2 < variabl26511; i2++)
if (s8[1].trim().equals(
variabl25171[i2].toUpperCase().trim()))
variabl26732 = i2;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
if (variabl19651.getValueAt(i1, variabl26731) == null)
s1 = "";
else
s1 = variabl19651.getValueAt(i1, variabl26731)
.toString().trim();
if (variabl26732 > 0)
if (variabl19651.getValueAt(i1, variabl26732) == null)
s2 = "";
else
s2 = variabl19651.getValueAt(i1, variabl26732)
.toString().trim();
else
s2 = s8[1];
if (i == 0)
l1[i1] = condition1(s1, s7, s2, variabl2511);
else {
if (variabl2559 == 0)
l1[i1] = l1[i1]
&& condition1(s1, s7, s2, variabl2511);
else
l1[i1] = l1[i1]
|| condition1(s1, s7, s2, variabl2511);
}
if (i < g8.length - 1) {
if (g6.substring(g9[i], g9[i] + 4).lastIndexOf(
"AND") > 0)
variabl2559 = 0;
else
variabl2559 = 1;
}
}
}
variabl18533 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++)
if (l1[i1])
variabl18533++;
variabl21973 = new String[variabl18533][variabl26511];
variabl18533 = 0;
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
if (l1[i1]) {
for (int j = 0; j < variabl26511; j++) {
if (variabl19651.getValueAt(i1, j) == null)
variabl21973[variabl18533][j] = "";
else
variabl21973[variabl18533][j] = variabl19651
.getValueAt(i1, j).toString().trim();
}
variabl18533++;
}
}
scrollPane3.setBounds(20, 60, variabl2187 * 8, 450);
variabl19653 = new DefaultTableModel(variabl21973, variabl25171);
variabl26553 = new JTable(variabl19653);
variabl26553.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane3.getViewport().add(variabl26553, null);
for (int i = 0; i < variabl26511; i++) {
TableColumn tc = variabl26553.getColumn(variabl25171[i]);
tc.setPreferredWidth(variabl14891[i] * 8);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",8,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(variabl25372);
}
final JButton variabl25492 = new JButton(variabl2405[9]);
variabl25492.setBounds(variabl2337, 540, variabl2339, 20);
variabl25492.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String g6 = JOptionPane.showInputDialog("请输入字段名称集：" + x1 + x2
+ "可以是字段名称，之间用逗号分隔。" + x1 + x2
+ "也可以是字段号，用中括号括起，之间用逗号分隔。" + x1 + x2 + "字段号从1起计数。"
+ x1 + x2 + "例如：学号,姓名,性别,班级,出生日期。" + x1 + x2
+ "又例如：[1],[2],[4],[6]");
String[] s6;
int[] variabl2127;
variabl1803 = 0;
if (g6.lastIndexOf("]") >= 0) {
g6 = g6.substring(g6.indexOf("[") + 1, g6.lastIndexOf("]"));
s6 = g6.split("\\],\\[");
variabl2127 = new int[s6.length];
variabl25173 = new String[s6.length];
variabl26513 = s6.length;
variabl14893 = new int[s6.length];
variabl15013 = new String[s6.length];
for (int j = 0; j < s6.length; j++) {
variabl2127[j] = Integer.parseInt(s6[j]) - 1;
variabl25173[j] = variabl25171[variabl2127[j]];
variabl14893[j] = variabl14891[variabl2127[j]];
variabl15013[j] = variabl15011[variabl2127[j]];
variabl1803 = variabl1803 + variabl14893[j];
}
} else {
variabl25173 = g6.split(",");
variabl2127 = new int[variabl25173.length];
variabl26513 = variabl25173.length;
variabl14893 = new int[variabl25173.length];
for (int i = 0; i < variabl26511; i++)
for (int j = 0; j < variabl25173.length; j++)
if (variabl25171[i].trim().equals(
variabl25173[j].trim())) {
variabl2127[j] = i;
variabl14893[j] = variabl14891[variabl2127[j]];
variabl1803 = variabl1803 + variabl14893[j];
}
}
set1.clear();
int n1 = 0;
variabl21973 = new String[variabl19651.getRowCount()][variabl26513];
variabl18533 = variabl19651.getRowCount();
for (int i1 = 0; i1 < variabl19651.getRowCount(); i1++) {
s1 = "";
for (int j = 0; j < variabl26513; j++) {
if (variabl19651.getValueAt(i1, variabl2127[j]) == null)
s1 = s1 + "";
else
s1 = s1
+ variabl19651
.getValueAt(i1, variabl2127[j])
.toString().trim();
}
if (s1.length() > 0)
set1.add(s1);
if (set1.size() != n1) {
for (int j = 0; j < variabl26513; j++) {
if (variabl19651.getValueAt(i1, variabl2127[j]) == null)
variabl21973[n1][j] = "";
else
variabl21973[n1][j] = variabl19651
.getValueAt(i1, variabl2127[j])
.toString().trim();
}
n1 = set1.size();
}
}
scrollPane3.setBounds(20, 60, variabl1803 * 8, 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] * 8);
}
panel3.add(scrollPane3);
}
});
if (variabl1187.indexOf(",9,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(variabl25492);
}
final JButton variabl25992 = new JButton(variabl2405[10]);
variabl25992.setBounds(variabl2337, 540, variabl2339, 20);
variabl25992.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame2.setVisible(false);
frame2.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (variabl1187.indexOf(",10,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel2.add(variabl25992);
}
variabl2337 = 50;
variabl2339 = 170;
final JButton variabl2639 = new JButton(variabl2405[11]);
variabl2639.setBounds(variabl2337, 540, variabl2339, 20);
variabl2639.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataTransfer0.Trans(variabl25173, variabl15013, variabl14893,
"", variabl21973, "运算结果");
}
});
if (variabl1187.indexOf(",11,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel3.add(variabl2639);
}
final JButton variabl2091 = new JButton(variabl2405[12]);
variabl2091.setBounds(variabl2337, 540, variabl2339, 20);
variabl2091.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPreview0.printView1(variabl25173, variabl21973,
variabl14893, "运算结果");
}
});
if (variabl1187.indexOf(",12,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel3.add(variabl2091);
}
final JButton variabl2617 = new JButton(variabl2405[13]);
variabl2617.setBounds(variabl2337, 540, variabl2339, 20);
variabl2617.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dataPrint0.printView1(variabl25173, variabl21973, variabl14893,
"运算结果");
}
});
if (variabl1187.indexOf(",13,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel3.add(variabl2617);
}
final JButton variabl1337 = new JButton(variabl2405[14]);
variabl1337.setBounds(variabl2337, 540, variabl2339, 20);
variabl1337.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String variabl2603 = JOptionPane
.showInputDialog("请输入导入表名，注意原数据均被删除：");
dataTransfer19.Trans(variabl25173, variabl15013, variabl14893,
variabl21973, variabl2603);
}
});
if (variabl1187.indexOf(",14,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel3.add(variabl1337);
}
final JButton variabl25993 = new JButton(variabl2405[10]);
variabl25993.setBounds(variabl2337, 540, variabl2339, 20);
variabl25993.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
frame2.setVisible(false);
frame2.dispose();
frame3.setVisible(false);
frame3.dispose();
}
});
if (variabl1187.indexOf(",10,") >= 0) {
variabl2337 = variabl2337 + variabl2339;
panel3.add(variabl25993);
}
frame3.add(panel3);
frame2.add(panel2);
frame1.add(panel1);
frame3.setVisible(true);
frame2.setVisible(true);
frame1.setVisible(true);
}
public static boolean condition1(String f1, String c1, String f2, String t1) {
int j = 0;
if (t1.trim().equals("数字")) {
double n1 = Double.parseDouble(f1);
double n2 = Double.parseDouble(f2);
if ((c1.trim().equals(">=")) && (n1 >= n2)) {
j = 1;
} else if ((c1.trim().equals("<=")) && (n1 <= n2)) {
j = 1;
} else if ((c1.trim().equals("=")) && (n1 == n2)) {
j = 1;
} else if ((c1.trim().equals("<>")) && (n1 != n2)) {
j = 1;
} else if ((c1.trim().equals(">")) && (n1 > n2)) {
j = 1;
} else if ((c1.trim().equals("<")) && (n1 < n2)) {
j = 1;
}
} else {
if ((c1.trim().equals(">=")) && (f1.compareTo(f2) >= 0)) {
j = 1;
} else if ((c1.trim().equals("<=")) && (f1.compareTo(f2) <= 0)) {
j = 1;
} else if ((c1.trim().equals("=")) && (f1.compareTo(f2) == 0)) {
j = 1;
} else if ((c1.trim().equals("<>")) && (f1.compareTo(f2) != 0)) {
j = 1;
} else if ((c1.trim().equals(">")) && (f1.compareTo(f2) > 0)) {
j = 1;
} else if ((c1.trim().equals("<")) && (f1.compareTo(f2) < 0)) {
j = 1;
}
}
if (j == 1)
return true;
else
return false;
}
public void itemStateChanged(ItemEvent e) {
try {
con = main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + fa0.getSelectedItem();
rs = sta3.executeQuery(s1);
rsmd = rs.getMetaData();
variabl26511 = rsmd.getColumnCount();
variabl25171 = new String[variabl26511];
variabl19191 = new String[variabl26511];
variabl15011 = new String[variabl26511];
variabl14891 = new int[variabl26511];
for (int i = 0; i < variabl26511; i++) {
variabl25171[i] = rsmd.getColumnName(i + 1);
variabl19191[i] = " ";
variabl15011[i] = rsmd.getColumnTypeName(i + 1);
variabl14891[i] = rsmd.getColumnDisplaySize(i + 1);
variabl2187 = variabl2187 + variabl14891[i] * 4;
}
rs.last();
variabl18531 = rs.getRow();
variabl21971 = new String[variabl18531][variabl26511];
rs.absolute(1);
int c = 0, b = 0;
while (c < variabl18531) {
rs.absolute(c + 1);
while (b < variabl26511) {
variabl21971[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "读取表1失败！" + s1);
return;
}
scrollPane1.setBounds(20, 60, 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] * 4);
}
panel1.add(scrollPane1);
variabl26551.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON3) {
variabl2051.show(variabl26551, e.getX() + 100, e.getY());
variabl18231 = variabl26551.rowAtPoint(e.getPoint());
variabl17391 = variabl26551.columnAtPoint(e.getPoint());
}
}
});
}
}
https://blog.sciencenet.cn/blog-2551-1120011.html
上一篇：管理信息系统软件生产线源码62-66
下一篇：管理信息系统软件生产线源码71-73
