博文
管理信息系统软件生产线源码37-40
|||
版本1
37.源码37，部件程序，用组合框表示代码数据的单记录、表格式混合部件。
/**
* 程序文件名：tableTenance11.java
* 作者： 齐赛
* 完成时间：2013年5月19日
* 功能： 用组合框表示代码数据的单记录、表格式混合部件。
* 界面由表格预览窗口，字段信息面板，功能按钮组成。
* 特点：1、用户可以通过点击预览表格来选择要删除的行，也可以通过功能按钮来选择，表格会及时更新，并自动定位到选择行。
* 2、对操作边界进行了严格控制，按钮会在不同的操作下置灰。包括表为空的情况。
* 3、对一些非法的操作也给予了控制，例如用户修改了字段信息，在进行删除时若找不到记录信息，会以消息框的方式来提示。
* 4、增加了状态行
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.BevelBorder;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.plaf.ButtonUI;
import javax.swing.table.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Vector;
import java.io.*;
public class tableTenance11 extends JFrame implements FocusListener
{
private static JLabel statusBar1=new JLabel("一共");
private static JLabel totalItems=new JLabel();
private static JLabel statusBar2=new JLabel("条记录");
private static JLabel statusBar3=new JLabel("当前记录是第");
private static JLabel currentItem=new JLabel();
private static JLabel statusBar4=new JLabel("条");
private static JButton firstItem=new JButton("第一条");
private static JButton nextItem=new JButton("下一条");
private static JButton previousItem=new JButton("上一条");
private static JButton endItem=new JButton("末一条");
private static JButton delete=new JButton("删除记录");
private static JTable table02; // 创建表格
private static JScrollPane scrollPane;
static Connection con; // 连接数据库
static Statement sta;
static ResultSet rs;
static ResultSetMetaData rsmd;
static tableTenance11 frame=new tableTenance11();
static String 表名; // 数据表名
static String 字典表名;
static String[] 关键字段名;
static int 窗口宽 = 900, 窗口高 = 700;//窗口高
static int 列数; // 数据表列数
static int 表格列数;
static String[] 列名; // 数据表列名
static String[] 表格列名;
static String[] 列标题; // 表格列标题名，如果有字典，是翻译后内容
static String[] 列数据类型;
static String[] 表列数据类型; // 存放表格各列数据类型的数组
static int[] 列数据宽度;
static int[] 表列数据宽度; // 存放表格各列数据宽度的数组
static int 表格记录条数=-1, 数据库记录条数=-1; // 记录条数
static String[][] 表格数据;// 存放表格数据的数组
static String [] 按钮集=null;
static String 要求按钮号表;
static String 要求字段号表; // 需要显示的字段的顺序号
static String[][] 关键字段值;
static String 字段名表="";
static int[] 关键字序号;
static String s1 = "";
static DefaultTableModel model;
static int b = 0, c = 0;
static int[] 列序号;
static int[] 关键字表格序号;
static String[] 文本数据;
static int count1;
static int count2;
static int count3;
static ArrayList<Fields>fields=new ArrayList<Fields>();
static String 接口参数表数据[][];
static String 代码表数据[][];
static String 接口参数表名;
static int currentRow=-1;
static int currentColumn=-1;
static int 按钮数=0,按钮宽=0;
public static void means(String[] parameter){
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){}
statusBar1=new JLabel("一共");
totalItems=new JLabel();
statusBar2=new JLabel("条记录");
statusBar3=new JLabel("当前记录是第");
currentItem=new JLabel();
statusBar4=new JLabel("条");
firstItem=new JButton(按钮集[0]);
nextItem=new JButton(按钮集[1]);
previousItem=new JButton(按钮集[2]);
endItem=new JButton(按钮集[3]);
delete=new JButton(按钮集[4]);
frame=new tableTenance11();
窗口宽 = 900; 窗口高 = 700;//窗口高
表格记录条数=-1; 数据库记录条数=-1; // 记录条数
字段名表=""; s1 = ""; b = 0; c = 0;
fields=new ArrayList<Fields>();
currentRow=-1;
currentColumn=-1;
表名=parameter[4] ; // 数据表名
要求字段号表=parameter[8] ;
关键字段名 = parameter[6].split(",");
接口参数表名=parameter[5];
String 表名表 = parameter[0];
if (关键字段名.length == 0)
{
JOptionPane.showMessageDialog(null, "缺少关键字的说明，请选择关键字后重新操作");
return;
}
frame.setTitle("单记录维护模型 " + 表名+" 作者：齐赛"); // 窗口标题
frame.setBounds(250, 50, 窗口宽, 窗口高); // 窗口位置大小
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
frame.setLayout(null);
scrollPane = new JScrollPane(); // 定义表格显示滚动条
frame.getContentPane().add(scrollPane); // 加入滚动条
关键字序号 = new int[关键字段名.length];
关键字表格序号 = new int[关键字段名.length];
con = main1.getConn(); // 调用前面方法连接数据库
try
{ // 以下是连接数据库
String [] s6,s7;
字段名表="";
if (要求字段号表.length()>0) {
s6=要求字段号表.split(",");
s7=parameter[19].split(",");
for (int i=0;i<s6.length;i++){
if (字段名表.length()>0)
字段名表=字段名表+","+s7[Integer.valueOf(s6[i])];
else 字段名表=s7[Integer.valueOf(s6[i])];
}
s1="select "+字段名表+" from "+表名;
}
else{
s7=parameter[19].split(",");
字段名表="";
for (int k1=0;k1<s7.length;k1++)
if (k1<s7.length-1) 字段名表=字段名表+s7[k1]+",";
else 字段名表=字段名表+s7[k1];
s1="select * from "+表名;
}
handleSQL(s1,1);
rs.last();
数据库记录条数 = rs.getRow();
表格记录条数 = 数据库记录条数;
if(表格记录条数==0)
{
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
delete.setEnabled(false);
}
Font f=new Font("仿宋",Font.BOLD,15);
statusBar1.setBounds(5,530,50,30);
statusBar1.setFont(f);
frame.add(statusBar1);
totalItems.setBounds(55, 530, 50, 30);
totalItems.setText(String.valueOf(表格记录条数));
totalItems.setForeground(Color.RED);
totalItems.setFont(f);
frame.add(totalItems);
statusBar2.setBounds(85, 530, 50, 30);
statusBar2.setFont(f);
frame.add(statusBar2);
statusBar3.setBounds(140, 530, 100, 30);
statusBar3.setFont(f);
frame.add(statusBar3);
currentItem.setBounds(245, 530, 50, 30);
currentItem.setText(String.valueOf(currentRow+1));//当前的记录
currentItem.setForeground(Color.RED);
currentItem.setFont(f);
frame.add(currentItem);
statusBar4.setBounds(295, 530, 50, 30);
statusBar4.setFont(f);
frame.add(statusBar4);
关键字段值 = new String[表格记录条数][关键字段名.length];
列数 = rsmd.getColumnCount(); // 获取列数
列名 = new String[列数]; // 定义列名数组
列数据类型 = new String[列数]; // 定义列字段类型数组
列数据宽度 = new int[列数]; // 定义列数据宽度
for (int i = 0; i < 列数; i++)
{
列名[i] = rsmd.getColumnName(i + 1); // 获取列名存到数组中
列数据类型[i] = rsmd.getColumnTypeName(i + 1); // 获取列数据类型名存到数组中
列数据宽度[i] = rsmd.getColumnDisplaySize(i + 1);
if (列数据宽度[i] < 列名[i].length())
列数据宽度[i] = 列名[i].length();
else if (列数据宽度[i] > 50)
列数据宽度[i] = 50;
for (int j = 0; j < 关键字段名.length; j++)
{
if (关键字段名[j].trim().equals(列名[i].trim()))
{
关键字序号[j] = i;
if (要求字段号表.length() <= 0)
要求字段号表 += (i + 1);
else
要求字段号表 = 要求字段号表 + "," + (i + 1);
break;
}
}
}
要求字段号表 = "," + 要求字段号表 + ",";
列序号 = new int[列数];
表格列数=列数;
文本数据 = new String[表格列数];
列标题 = new String[表格列数];
表格列名 = new String[表格列数]; // 定义列名数组
表列数据类型 = new String[表格列数]; // 定义列字段类型数组
表列数据宽度 = new int[表格列数]; // 定义列数据宽度
表格数据 = new String[数据库记录条数][表格列数]; // 表格数据数组
b = 0;
while (b < 表格列数)
{
表格列名[b] = 列名[b];
表列数据类型[b] = 列数据类型[b];
表列数据宽度[b] = 列数据宽度[b];
列标题[b] = 列名[b];
列序号[b] = b;
b++;
}
rs.absolute(1);
c = 0; // 行号
b = 0; // 列号
while (c < 数据库记录条数)
{
rs.absolute(c + 1);
while (b < 表格列数)
{
表格数据[c][b] = rs.getString(列序号[b] + 1); // 表格数据
for (int i = 0; i < 关键字序号.length; i++)
{
if (关键字序号[i] == 列序号[b])
{
关键字表格序号[i] = b;
关键字段值[c][i] = 表格数据[c][b];
break;
}
}
b++;
}
c++;
b = 0;
}
} catch (Exception e)
{
e.printStackTrace();
} finally
{
closeSQL();
}
字典表名="";
String []t1;
int b=0,c=0;
if (表名表.lastIndexOf(表名+"字典表")>=0){
t1=表名表.split(",");
for (int i=0;i<t1.length;i++)
if (t1[i].lastIndexOf(表名+"字典表")>=0) 字典表名=t1[i];
}
if (字典表名.length() > 0)
{
con = main1.getConn(); // 调用前面方法连接数据库
s1 = "select * from " + 字典表名;
handleSQL(s1,1);
try
{
while (rs.next())
{
String 字段名称 = rs.getString(1);
String 标签名称 = rs.getString(2);
b = 0;
while (b < 表格列数)
{
if (列标题[b].compareTo(字段名称.trim()) == 0)
{
列标题[b] = 标签名称.trim();
}
else 列标题[b] = 表格列名[b];
b++;
}
}
} catch (Exception e1)
{
e1.printStackTrace();
} finally
{
closeSQL();
}
}
model = new DefaultTableModel(表格数据, 列标题); // 创建表格模型
table02 = new JTable(model); // 创建指定表格模型的表格
table02.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table02.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
table02.addMouseListener(new MouseAdapter()
{
public void mouseClicked(final MouseEvent e)
{
currentRow = table02.getSelectedRow();
currentItem.setText(String.valueOf(currentRow+1));
if(currentRow==0)
{
if(currentRow==表格记录条数-1)
{
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
}else
{
firstItem.setEnabled(false);
previousItem.setEnabled(false);
nextItem.setEnabled(true);
endItem.setEnabled(true);
}
}else
{
if(currentRow==表格记录条数-1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}else
{
nextItem.setEnabled(true);
endItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
}
currentColumn=table02.getSelectedColumn();
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
}
});
for (int i = 0; i < 表格列数; i++)
{
TableColumn tc = table02.getColumn(列标题[i]);
for(int j=0;j<关键字表格序号.length;j++)
{
if(i==关键字表格序号[j])
{
DefaultTableCellRenderer cellRender=new DefaultTableCellRenderer();
cellRender.setBackground(Color.ORANGE);
tc.setCellRenderer(cellRender);
}
}
JTableHeader header = table02.getTableHeader();
tc.setPreferredWidth(表列数据宽度[i] * 8);
tc.setMaxWidth(表列数据宽度[i] * 8);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table02); // 滚动条加到表格中
按钮宽=(窗口宽-60)/按钮数;
int 左边距=30;
firstItem.setBounds(左边距,500,按钮宽,30);
if (要求按钮号表.indexOf(",0,")>=0) {
左边距=左边距+按钮宽;
frame.add(firstItem);
}
firstItem.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent arg0)
{
currentRow=0;
table02.setRowSelectionInterval(currentRow, currentRow);
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));
currentItem.setText(String.valueOf(currentRow+1));
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if(currentRow==表格记录条数-1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
}else
{
nextItem.setEnabled(true);
endItem.setEnabled(true);
}
}
});
nextItem.setBounds(左边距,500,按钮宽,30);
if (要求按钮号表.indexOf(",0,")>=0) {
左边距=左边距+按钮宽;
frame.add(nextItem);
}
nextItem.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if(currentRow==-1)
{
currentRow=0;
table02.setRowSelectionInterval(currentRow, currentRow);
currentItem.setText(String.valueOf(currentRow+1));
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if(currentRow==表格记录条数-1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
}
}else if(currentRow+1==表格记录条数-1)
{
currentRow++;
endItem.setEnabled(false);
nextItem.setEnabled(false);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}else
{
currentRow++;
endItem.setEnabled(true);
nextItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
table02.setRowSelectionInterval(currentRow, currentRow);
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));
currentItem.setText(String.valueOf(currentRow+1));
}
});
previousItem.setBounds(左边距,500,按钮宽,30);
if (要求按钮号表.indexOf(",0,")>=0) {
左边距=左边距+按钮宽;
frame.add(previousItem);
}
previousItem.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent arg0)
{
if(currentRow==-1)
{
currentRow=0;
table02.setRowSelectionInterval(currentRow, currentRow);
currentItem.setText(String.valueOf(currentRow+1));
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if(currentRow==表格记录条数-1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
}
}else if(currentRow-1==0)
{
currentRow--;
firstItem.setEnabled(false);
previousItem.setEnabled(false);
nextItem.setEnabled(true);
endItem.setEnabled(true);
}else
{
currentRow--;
endItem.setEnabled(true);
nextItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
table02.setRowSelectionInterval(currentRow, currentRow);//选中行
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));
currentItem.setText(String.valueOf(currentRow+1));
}
});
endItem.setBounds(左边距,500,按钮宽,30);
if (要求按钮号表.indexOf(",0,")>=0) {
左边距=左边距+按钮宽;
frame.add(endItem);
}
endItem.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
currentRow=表格记录条数-1;
table02.setRowSelectionInterval(currentRow, currentRow);
currentItem.setText(String.valueOf(currentRow+1));
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));
endItem.setEnabled(false);
nextItem.setEnabled(false);
if(currentRow==0)
{
firstItem.setEnabled(false);
previousItem.setEnabled(false);
}else
{
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
}
});
delete.setBounds(左边距,500,按钮宽,30);
if (要求按钮号表.indexOf(",0,")>=0) {
左边距=左边距+按钮宽;
frame.add(delete);
}
delete.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if(currentRow==-1)
{
JOptionPane.showMessageDialog(null,"请先选择一条记录！");
return;
}else
{
int response=JOptionPane.showConfirmDialog(null, "是否真的要删除此条记录？", "请选择", JOptionPane.CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE);
if(response==0)
{
s1="delete from "+表名+" where ";
int p=0;
for(int i=0;i<fields.size();i++)
{
Fields field=fields.get(i);
if(field.是否是主键)
{
s1+=field.实际字段名+"="+field.getFormatText();
p++;
if(p<关键字段名.length)
{
s1+=" AND ";
}
}
}
int status=handleSQL(s1,4);
closeSQL();
if(status==0)
{
JOptionPane.showMessageDialog(null, "此条记录不存在！");
return;
}else
{
JOptionPane.showMessageDialog(null, "删除成功！");
updateTable();
totalItems.setText(String.valueOf(表格记录条数));
if(表格记录条数==0)
{
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
delete.setEnabled(false);
currentRow=-1;
}else if(表格记录条数==1)
{
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
delete.setEnabled(true);
currentRow=0;
table02.setRowSelectionInterval(currentRow, currentRow);//选中行
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));//自动定位到当前选中行
currentItem.setText(String.valueOf(currentRow+1));//更新状态
}else
{
if(currentRow==表格记录条数)
{
currentRow--;
table02.setRowSelectionInterval(currentRow, currentRow);//选中行
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));//自动定位到当前选中行
currentItem.setText(String.valueOf(currentRow+1));//更新状态
firstItem.setEnabled(true);
nextItem.setEnabled(false);
previousItem.setEnabled(true);
endItem.setEnabled(false);
}else
{
table02.setRowSelectionInterval(currentRow, currentRow);//选中行
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));//自动定位到当前选中行
currentItem.setText(String.valueOf(currentRow+1));//更新状态
firstItem.setEnabled(true);
nextItem.setEnabled(true);
previousItem.setEnabled(true);
endItem.setEnabled(true);
}
}
}
}else
{
return;
}
}
}
});
JButton nextItem1=new JButton(按钮集[5]);
nextItem1.setBounds(左边距,500,按钮宽,30);
if (要求按钮号表.indexOf(",0,")>=0) {
左边距=左边距+按钮宽;
frame.add(nextItem1);
}
nextItem1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Vector<String> v=new Vector<String>(表格列数);
for(int i=0;i<fields.size();i++)
{
v.add(fields.get(i).getText()); //加到表格中
}
model.addRow(v);
table02.repaint();
s1="insert into "+表名+" ("+字段名表+") values (";
String s2="",s3="";
for(int j=0;j<fields.size();j++){
s3=fields.get(j).getText();
if(main1.数字数据类型.trim().indexOf(","+列数据类型[j]+",")>=0){
if ((s3.trim().length()<1)||(s3==null)) s3="0";//数字类型
s2=s2+s3.trim();
}
else {
s2=s2+"'"+fields.get(j).getText()+"'";
}
if(j<fields.size()-1)
s2=s2+",";
}
s1=s1+s2+")";
try {
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能录入，可能是数据出错，请检查！");
return;
}
int k5=Integer.parseInt(totalItems.getText());
表格记录条数=k5+1;
totalItems.setText((k5+1)+"");
currentItem.setText((k5+1)+"");
}
});
JButton nextItem2=new JButton(按钮集[6]);
nextItem2.setBounds(左边距,500,按钮宽,30);
if (要求按钮号表.indexOf(",0,")>=0) {
左边距=左边距+按钮宽;
frame.add(nextItem2);
}
nextItem2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Vector<String> v=new Vector<String>(表格列数);
int m0=table02.getSelectedRow();
for(int i=0;i<fields.size();i++)
{
v.add(fields.get(i).getText()); //加到表格中
}
model.removeRow(m0);
model.addRow(v);
table02.repaint();
currentItem.setText(String.valueOf(currentRow+1));
s1="update "+表名+" set ";
String s2="",s3="",s4="";
int k3=0;
for(int j=0;j<fields.size();j++){
s3=fields.get(j).getText();
k3=0;
for (int k2=0;k2<关键字表格序号.length;k2++)
if (关键字表格序号[k2]==j){
s4=s4+表格列名[j]+"=";
if(main1.数字数据类型.trim().indexOf(","+列数据类型[j]+",")>=0)
s4=s4+s3.trim();
else
s4=s4+"'"+s3.trim()+"'";
if (k2<关键字表格序号.length-1)
s4=s4+" and ";
k3=1;
}
if (k3==0){
if(main1.数字数据类型.trim().indexOf(","+列数据类型[j]+",")>=0){
if ((s3.trim().length()<1)||(s3==null)) s3="0";//数字类型
s2=s2+表格列名[j]+"="+s3.trim();
}
else {
s2=s2+表格列名[j]+"='"+fields.get(j).getText()+"'";
}
if(j<fields.size()-1)
s2=s2+",";
}
}
s1=s1+s2+" where "+s4;
try {
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能录入，可能是数据出错，请检查！");
return;
}
}
});
JButton nextItem3=new JButton(按钮集[7]);
nextItem3.setBounds(左边距,500,按钮宽,30);
if (要求按钮号表.indexOf(",0,")>=0) {
左边距=左边距+按钮宽;
frame.add(nextItem3);
}
nextItem3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if(接口参数表名.length()>0)
{
con = main1.getConn();
s1 = "select * from " + 接口参数表名;
handleSQL(s1,1);
try
{
rs.last();
int rows=rs.getRow();
rs.absolute(1);
int columns=rsmd.getColumnCount();
接口参数表数据=new String[rows][columns];
int i=0;
while (i<rows)
{
for(int j=0;j<columns;j++)
{
接口参数表数据[i][j]=rs.getString(j+1);
}
i++;
rs.next();
}
} catch (Exception e1)
{
e1.printStackTrace();
} finally
{
closeSQL();
}
}
for(int i=0;i<列标题.length;i++)
{
boolean 是否有参数表=false;
boolean key=false;
boolean code=false;
if(表名表.lastIndexOf(列标题[i]+"代码表")>=0)
{
code=true;
}
if(接口参数表名.length()>0)
for(int k=0;k<接口参数表数据.length;k++)
{
if(列标题[i].trim().equals(接口参数表数据[k][1].trim()))
{
是否有参数表=true;
break;
}
}
for(int k=0;k<关键字表格序号.length;k++)
{
if((i)==关键字表格序号[k])
{
key=true;
break;
}
}
Fields f=frame.new Fields(i, 表列数据类型[i], 列标题[i], 表格列名[i], 表列数据宽度[i], 是否有参数表, key,code);
fields.add(f);
}
JPanel fieldsJp=new JPanel();
FlowLayout fl=new FlowLayout();
fl.setAlignment(FlowLayout.LEFT);
fl.setHgap(10);
fl.setVgap(10);
fieldsJp.setLayout(fl);
fieldsJp.setPreferredSize(new Dimension(窗口宽-45,窗口高));
ArrayList<Integer> longField=new ArrayList<Integer>();
for(int i=0;i<fields.size();i++)
{
if(fields.get(i).jta !=null)
{
longField.add(i);
continue;
}
fieldsJp.add(fields.get(i));
}
for(int i=0;i<longField.size();i++)
{
fieldsJp.add(fields.get(longField.get(i)));
}
fieldsJp.setBackground(Color.GRAY);
JScrollPane fieldsJSPane=new JScrollPane(fieldsJp);
JSplitPane splitPane=new JSplitPane(JSplitPane.VERTICAL_SPLIT,scrollPane,fieldsJSPane);
splitPane.setBounds(0,0,窗口宽-15,500);
splitPane.setDividerLocation(150);
splitPane.setOneTouchExpandable(true);
fieldsJSPane.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(Color.BLACK),"字段信息"));
fieldsJSPane.getVerticalScrollBar().setUnitIncrement(15);
frame.getContentPane().add(splitPane);
frame.setVisible(true);
}
/**
* 1.遍历表格字段，及其在数据表中的序号，拿到它的标题，数据类型，数据宽度，是否有参数表，构造panel；
2.panel的属性：组合框，文本框，文本域，标签，标题，字段名，是否为主键；
主要方法有面板总长度、面板宽度、面板长度、是否是XX组件、
*/
class Fields extends JPanel implements Comparable<Fields>
{
JComboBox jco;
JTextField jtf;
JTextArea jta;
JLabel jlb;
String 字典名;//对应的字典名
String 实际字段名;//实际字段名
int 相对序号;
boolean 是否是主键;
boolean 是否有参数表;
boolean code;
String 数据类型;
public Fields(int 相对序号,String fieldType,String name,String actualName,int dataWidth,boolean referenceTable,boolean isKey,boolean codeTable)
{
this.是否是主键=isKey;
this.相对序号=相对序号;
this.字典名=name;
this.实际字段名=actualName;
this.数据类型=fieldType;
this.是否有参数表=referenceTable;
this.code=codeTable;
if(dataWidth<60 && !codeTable)
{
jtf=new JTextField();
jtf.addFocusListener(tableTenance11.this);
jlb=new JLabel(name);
jlb.setFont(new Font("仿宋",Font.BOLD,18));
if(isKey)
{
jlb.setForeground(Color.RED);
}
jtf.setPreferredSize(new Dimension(dataWidth*8,25));
this.add(jlb);
this.add(jtf);
}else if(!codeTable)
{
jta=new JTextArea();
jta.addFocusListener(tableTenance11.this);
jlb=new JLabel(name);
jlb.setFont(new Font("仿宋",Font.BOLD,18));
if(isKey)
{
jlb.setForeground(Color.RED);
}
jta.setLineWrap(true);
JScrollPane jsp=new JScrollPane(jta);
jsp.setPreferredSize(new Dimension(200,80));
this.add(jlb);
this.add(jsp);
}else
{
jco=new JComboBox();
jco.addFocusListener(tableTenance11.this);
jlb=new JLabel(name);
jlb.setFont(new Font("仿宋",Font.BOLD,18));
if(isKey)
{
jlb.setForeground(Color.RED);
}
jco.setPreferredSize(new Dimension(dataWidth*10+20,25));
jco.setBackground(Color.WHITE);
con = main1.getConn();
s1 = "select * from " + name+"代码表";
handleSQL(s1,1);
try
{
rs.last();
int rows=rs.getRow();
rs.absolute(1);
int columns=rsmd.getColumnCount();
代码表数据=new String[rows][columns];
int i=0;
while (i<rows)
{
jco.addItem(rs.getString(1));
i++;
rs.next();
}
} catch (Exception e1)
{
e1.printStackTrace();
} finally
{
closeSQL();
}
this.add(jlb);
this.add(jco);
this.setBorder(BorderFactory.createLineBorder(Color.GRAY));
}
}
public int compareTo(Fields f)
{
return this.相对序号-this.相对序号;
}
public String getFormatText()
{
String text="";
if(main1.数字数据类型.trim().indexOf(this.数据类型.trim())>=0)
{
text=this.getText();
if(text.isEmpty())
{
text="0";
}
}else
{
text="'"+this.getText()+"'";
}
return text;
}
public String getText()
{
if(this.jco!=null)
{
return (String)jco.getSelectedItem();
}else if(this.jta!=null)
{
return this.jta.getText();
}else
{
return this.jtf.getText();
}
}
public void setText(String text)
{
if(this.jco!=null)
{
if (text==null) return;
for(int i=0;i<jco.getItemCount();i++)
{
String str=(String)jco.getItemAt(i);
if (str.trim().equals(text.trim()))
{
jco.setSelectedIndex(i);
}
}
}else if(this.jta!=null)
{
this.jta.setText(text);
}else
{
this.jtf.setText(text);
}
}
public Component getComponent()
{
if(this.jco!=null)
{
return this.jco;
}else if(this.jta!=null)
{
return this.jta;
}else
{
return this.jtf;
}
}
}
public void focusGained(FocusEvent e)
{
Component c=(Component)e.getSource();
c.setBackground(Color.CYAN);
}
public void focusLost(FocusEvent e)
{
Component c=(Component)e.getSource();
c.setBackground(Color.WHITE);
}
/**
* @param dml DML语句
* @param type 1表示查询，2表示添加，3表示修改，4表示删除
*/
static public int handleSQL(String dml,int type)
{
int status=0;
try
{
con=main1.getConn();
sta=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
switch (type)
{
case 1:
{
rs=sta.executeQuery(dml);
rsmd=rs.getMetaData();
break;
}
case 2:
{
sta.executeUpdate(dml);
JOptionPane.showMessageDialog(null, "数据添加成功！");
break;
}
case 3:
{
sta.executeUpdate(dml);
JOptionPane.showMessageDialog(null, "数据修改成功！");
break;
}
case 4:
{
status=sta.executeUpdate(dml);
break;
}
}
} catch (SQLException e)
{
JOptionPane.showMessageDialog(null, "数据库出错！");
closeSQL();
e.printStackTrace();
}
return status;
}
/**
* 断开数据库的链接
*/
static void closeSQL()
{
try
{
if(rs!=null)
{
rs.close();
rs=null;
}
if(sta!=null)
{
sta.close();
sta=null;
}
if(con!=null)
{
con.close();
con=null;
}
}catch(SQLException sqle1)
{
sqle1.printStackTrace();
}
}
/**
* 当添加数据之后，之前保存的数据要重新更新，以便再次添加数据
*/
public static void updateTable()
{
con = main1.getConn(); // 调用前面方法连接数据库
s1 = "select * from " + 表名; // 查取全表数据
handleSQL(s1,1);
try
{
rs.last();
数据库记录条数 = rs.getRow();
表格记录条数 = 数据库记录条数;
表格数据 = new String[数据库记录条数][表格列数]; // 表格数据数组
rs.absolute(1);
c = 0; // 行号
b = 0; // 列号
while (c < 数据库记录条数)
{
rs.absolute(c + 1);
while (b < 表格列数)
{
表格数据[c][b] = rs.getString(列序号[b] + 1); // 表格数据
for (int i = 0; i < 关键字序号.length; i++)
{
if (关键字序号[i] == 列序号[b])
{
关键字表格序号[i] = b;// 记录在表格中的序号
关键字段值[c][i] = 表格数据[c][b];
break;
}
}
b++;
}
c++;
b = 0;
}
} catch (Exception e)
{
e.printStackTrace();
} finally
{
closeSQL();
}
model.setDataVector(表格数据, 列标题);
table02.setModel(model);
table02.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table02.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < 表格列数; i++)
{ // 设置表格每列宽度
TableColumn tc = table02.getColumn(列标题[i]);// 返回表格的列对象
for(int j=0;j<关键字表格序号.length;j++)
{
if(i==关键字表格序号[j])
{
DefaultTableCellRenderer cellRender=new DefaultTableCellRenderer();
cellRender.setBackground(Color.ORANGE);
tc.setCellRenderer(cellRender);
}
}
JTableHeader header = table02.getTableHeader();
tc.setPreferredWidth(表列数据宽度[i] * 8);
tc.setMaxWidth(表列数据宽度[i] * 8);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table02);
table02.repaint();
}
/**
* 此方法在前端检查记录的关键字是否在数据库中已经存在
* @param array要添加的数据
* @return 返回值若为真，表示有重复关键字，否则无
*/
public static boolean keyJudge(String[] array)
{
boolean flag = false;
for (int i = 0; i < 关键字段值.length; i++)
{
int j = 0;
for (; j < 关键字段名.length; j++)
{
if (!关键字段值[i][j].trim().equals(array[关键字表格序号[j]].trim()))
break;
}
if (j == 关键字段名.length)
{
flag = true;
break;
} else if (i == 关键字段值.length - 1)
{
String temp[][] = 关键字段值;
关键字段值 = new String[关键字段值.length + 1][关键字段名.length];
for (int i1 = 0; i1 < temp.length; i1++)
for (int j1 = 0; j1 < temp[0].length; j1++)
关键字段值[i1][j1] = temp[i1][j1];
for (int i2 = 0; i2 < 关键字段名.length; i2++)
关键字段值[关键字段值.length - 1][i2] = array[关键字表格序号[i2]];
return false;
}
}
return flag;
}
}
38.源码38，部件程序，可选表名的表格式数据维护程序。
/*
* 程序文件名：tableTenance12.java
* 作者：程学先
* 程序功能：可选表名的表格式数据维护程序。
* 界面中提供二个列表框，请首先选择数据表，之后显示数据表内容。再选择关键字，
* 关键字可以为多个字段。再作修改、删除等操作。
* 要求每录入一行或修改一行或删除一行都要按一次按钮。
* 调用： tableTenance12.means(parameter)
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.table.*;
import java.sql.*;
import java.util.*;
import java.util.List;
public class tableTenance12 extends JFrame
{
static tableTenance12 frame = new tableTenance12(); // 创建窗体
private static List<JLabel> list1 = new ArrayList<JLabel>();// 存放字段标签
private static List<JTextField> list2 = new ArrayList<JTextField>();// 存放字段内容
public static JTable table; // 创建表格
private static JButton 添加;
private static JButton 修改;
private static JButton 删除;
private static JButton 退出;
static Connection con; // 连接数据库
static ResultSet rs;
static Statement sta3;
static String 表名;
static String s1,s2,s3;
static int 列数 ; // 数据表列数
static String[] 列名; // 数据表列名
static String[] 列数据类型; // 存放当前记录各字段数据类型的数组
static int[] 列数据宽度; // 存放当前记录各字段数据宽度的数组
static int 记录条数; // 记录条数
static Object[][] 表格数据;// 存放表格数据的数组
static DefaultTableModel model;
static int 窗口宽, 窗口高;
static String[] 一条记录;
static String 键盘输入字串="";
static String [] 按钮集=null;
static String 要求按钮号表;
static int 按钮数=0,按钮宽=0;
static String[] 关键字段名;
static int [] 关键字序号;
static String [] 关键字段值;
public static void means(String[] parameter){
frame = new tableTenance12(); // 创建窗体
list1 = new ArrayList<JLabel>();// 存放字段标签
list2 = new ArrayList<JTextField>();// 存放字段内容
String[] 表名表 = parameter[0].split(",");
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){}
frame.setTitle("可随机选择数据表的表格数据维护程序 作者：程学先"); // 设置窗体标题
frame.setBounds(10, 10, 窗口宽, 窗口高); // 设置窗体的位置和大小
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
frame.setLayout(null);
关键字段名=null;
关键字序号=null;
关键字段值=null;
final JPanel panel = new JPanel(false); //定义面板
panel.setLayout(null); //关闭面板布局管理器
panel.setBounds(10, 10,窗口宽,窗口高);
final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
JLabel l0 = new JLabel("请选择数据表");//选择字段名标签
l0.setBounds(840,10,120,20);
panel.add(l0);
final java.awt.List list0 = new java.awt.List();
for (int i=0;i<表名表.length;i++)
list0.add(表名表[i]);
list0.setBounds(840, 40,120,150); //数据表列表框大小位置
list0.setMultipleMode(false); //只能单选
panel.add(list0);
JLabel l1 = new JLabel("请选择关键字");//选择字段名标签
l1.setBounds(840,200,120,20);
panel.add(l1);
final java.awt.List listl0 = new java.awt.List();
listl0.setBounds(840,230,120,200); //选字段列表框大小位置
listl0.setMultipleMode(true); //允许多选
panel.add(listl0);
list0.addMouseListener(new MouseAdapter() { //表名列表框鼠标事件监听器
public void mouseClicked(MouseEvent e) {
表名=list0.getSelectedItem();
try{
main1.driver1();
con=main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 表名;
rs = sta3.executeQuery(s1);
rs.last();
记录条数=rs.getRow();
ResultSetMetaData rsmd = rs.getMetaData();
列数 = rsmd.getColumnCount(); // 获取列数
列名 = new String[列数]; // 定义列名数组
列数据类型 = new String[列数];
列数据宽度 = new int[列数];
一条记录=new String[列数];
//分析数据表元数据特性
for (int i=0;i<列数;i++) {
列名[i] = rsmd.getColumnName(i + 1); // 获取列名存到数组中
列数据类型[i] = rsmd.getColumnTypeName(i+1);
列数据宽度[i] = rsmd.getColumnDisplaySize(i+1);
if (列数据宽度[i] < 列名[i].length())
列数据宽度[i] = 列名[i].length();
else if (列数据宽度[i] > 50)
列数据宽度[i] = 50;
一条记录[i]="";
}
表格数据=new String[记录条数][列数];
rs.absolute(1);
int c=0; //行号
int b=0; //列号
while(c<记录条数) {
rs.absolute(c+1);
while(b<列数){
表格数据[c][b]=rs.getString(b+1);
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch (SQLException e1){
JOptionPane.showMessageDialog( null, "获取数据结构出错！");
}
for (int i=0;i<列数;i++)
listl0.add(列名[i]);
listl0.addMouseListener(new MouseAdapter() { // 添加列表框鼠标事件监听器
public void mouseClicked(MouseEvent e) {
关键字段名=listl0.getSelectedItems();
关键字序号=new int[关键字段名.length];
for (int i=0;i<列名.length;i++){
for (int j=0;j<关键字序号.length;j++){
if (列名[i].equals(关键字段名[j]))
关键字序号[j]=i;
}
}
}
});
model = new DefaultTableModel(表格数据, 列名);
model.addRow(一条记录);
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]);
JTableHeader header = table.getTableHeader();
tc.setPreferredWidth(列数据宽度[i] * 9);
tc.setMaxWidth(列数据宽度[i] * 9);
tc.sizeWidthToFit();
}
scrollPane.setBounds(0,0,窗口宽-220,窗口高-220);
scrollPane.setViewportView(table);
panel.add(scrollPane);
table.addKeyListener(new KeyAdapter() { //键盘事件
public void keyPressed(KeyEvent evt) { //按下某个键时调用此方法
键盘输入字串 = 键盘输入字串 + evt.getKeyChar();
}
});
table.addMouseListener(new MouseAdapter() { //鼠标侦听器
public void mouseClicked(MouseEvent e) { //鼠标按键在组件上单击（按下并释放）时调用
int selectedRow = table.getSelectedRow();
int 行号 = table.getSelectedRow();
int 列号 = table.getSelectedColumn();
int k=0;
if (关键字段名==null) {
JOptionPane.showMessageDialog(null, "请选择关键字！");
return;
}
for (int i = 0; i < 关键字段名.length; i++) {
if (关键字序号[i] == 列号 ) k=1;
}
if (k==0) { //非关键字数据清除，关键字数据保留
model.setValueAt("", 行号, 列号); //清原有数据
}
键盘输入字串 = ""; //清"键盘输入字串"
}
});
table.addFocusListener(new FocusAdapter() { //键盘焦点
public void focusLost(final FocusEvent arg0) {//组件失去键盘焦点时调用
int 行号 = table.getSelectedRow();
int 列号 = table.getSelectedColumn();
if (键盘输入字串.trim().length()>0){
if (键盘输入字串.indexOf(" ")>=0)
键盘输入字串=键盘输入字串.substring(键盘输入字串.lastIndexOf(" ")+1,键盘输入字串.length());
model.setValueAt(键盘输入字串, 行号, 列号);
}
}
});
}
});
按钮宽=(窗口宽-460)/按钮数;
int 左边距=420;
添加 = new JButton();// 添加按钮
添加.setText(按钮集[0]);
添加.setBounds(左边距,500,按钮宽,20);
if (要求按钮号表.indexOf(",0,")>=0) {
左边距=左边距+按钮宽;
panel.add(添加);
}
添加.addActionListener(new ActionListener()
{
public void actionPerformed( ActionEvent e)
{
int m0=table.getSelectedRow();
关键字段值=new String[关键字段名.length]; //检查实体完整性
s1 = "";
for (int i = 0; i < 关键字段名.length; i++) {
关键字段值[i] = model.getValueAt(m0, 关键字序号[i])
.toString();
if (关键字段值[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.数字数据类型.lastIndexOf(列数据类型[关键字序号[i]]) > 0)
s1 = s1 + 关键字段名[i] + "=" + 关键字段值[i];
else
s1 = s1 + 关键字段名[i] + "='" + 关键字段值[i] + "' ";
if (i < 关键字段名.length - 1)
s1 = s1 + " and ";
}
int j1 = 0;
for (int j=0;j<model.getRowCount()-1;j++){
for (int i = 0; i < 关键字段名.length; i++){
if (关键字段值[i].trim().equals(model.getValueAt(j, 关键字序号[i]).toString().trim()))
j1++;
if (j1==关键字段名.length) {
JOptionPane.showMessageDialog(null, "关键字数据重复，请检查！");
return;
}
}
j1=0;
}
s1="";
s2="";
for(int j=0;j<列数;j++){
s1=s1+列名[j];
if (j<列数-1) s1=s1+",";
s3 = model.getValueAt(m0, j) == null ? "" : model
.getValueAt(m0, j).toString();
if(main1.数字数据类型.trim().indexOf(","+列数据类型[j]+",")>=0){
if (s3.trim().length()<1) s3="0";
s2=s2+s3.trim();
}
else {
s2=s2+"'"+s3.trim()+"'";
}
if(j<列数-1)
s2=s2+",";
}
s1="insert into "+表名+"("+s1+")"+" values ("+s2+")";
try {
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能录入，可能是数据出错，请检查！");
return;
}
model.addRow(一条记录);
}
});
// panel.add(添加);
修改 = new JButton();
修改.setText(按钮集[1]);
修改.setBounds(左边距,500,按钮宽,20);
if (要求按钮号表.indexOf(",1,")>=0) {
左边距=左边距+按钮宽;
panel.add(修改);
}
修改.addActionListener(new ActionListener()
{
public void actionPerformed( ActionEvent e)
{
s1 = "";
int j1 = 0;
int m0=table.getSelectedRow();
关键字段值=new String[关键字段名.length]; //检查实体完整性
for (int i = 0; i < 关键字段名.length; i++) {
关键字段值[i] = model.getValueAt(m0, 关键字序号[i]).toString();
if (关键字段值[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.数字数据类型.lastIndexOf(列数据类型[关键字序号[i]]) > 0)
s1 = s1 + 关键字段名[i] + "=" + 关键字段值[i];
else
s1 = s1 + 关键字段名[i] + "='" + 关键字段值[i] + "' ";
if (i < 关键字段名.length - 1)
s1 = s1 + " and ";
}
try{
String str1="";
for(int j=0;j<列数;j++){
if(main1.数字数据类型.trim().indexOf(","+列数据类型[j]+",")>=0)
if (table.getValueAt(m0, j)==null)
str1=str1+列名[j]+"=0";
else str1=str1+列名[j]+"="+
table.getValueAt(m0, j).toString().trim();
else
if (table.getValueAt(m0, j)==null)
str1=str1+列名[j]+"=' '";
else str1=str1+列名[j]+"='"+
table.getValueAt(m0, j).toString().trim()+"'";
if(j<列数-1)
str1=str1+",";
}
s1=" update "+表名+" set "+str1+" where "+s1;
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能修改成功，可能是数据出错，请检查！");
return;
}
}
});
// panel.add(修改);
删除 = new JButton();// 删除按钮
删除.setText(按钮集[2]);
删除.setBounds(左边距,500,按钮宽,20);
if (要求按钮号表.indexOf(",2,")>=0) {
左边距=左边距+按钮宽;
panel.add(删除);
}
删除.addActionListener(new ActionListener(){
public void actionPerformed( ActionEvent e){
s1 = "";
int j1 = 0;
int m0=table.getSelectedRow();
关键字段值=new String[关键字段名.length]; //检查实体完整性
for (int i = 0; i < 关键字段名.length; i++) {
关键字段值[i] = model.getValueAt(m0, 关键字序号[i]).toString();
if (关键字段值[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.数字数据类型.lastIndexOf(列数据类型[关键字序号[i]]) > 0)
s1 = s1 + 关键字段名[i] + "=" + 关键字段值[i];
else
s1 = s1 + 关键字段名[i] + "='" + 关键字段值[i] + "' ";
if (i < 关键字段名.length - 1)
s1 = s1 + " and ";
}
try {
s1="delete from "+表名+" where "+s1;
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能删除成功，可能是数据出错，请检查！");
return;
}
model.removeRow(table.getSelectedRow());
}
});
// panel.add(删除);
退出 = new JButton(按钮集[3]);// 退出按钮
退出.setBounds(左边距,500,按钮宽,20);
if (要求按钮号表.indexOf(",3,")>=0) {
左边距=左边距+按钮宽;
panel.add(退出);
}
退出.addActionListener(new ActionListener()
{
public void actionPerformed(final ActionEvent e)
{
frame.setVisible(false);
frame.dispose();
}
});
退出.setText("退出");
frame.add(panel);
frame.setVisible(true);
}
}
39.源码39，部件程序，可随机选择表名、可变更标签、应用列表框提供代码帮助、有完整性控制的表格式数据维护程序。
/*
* 程序文件名：tableTenance13.java
* 作者：程学先
* 完成时间：2018年5月29日
* 程序功能：可随机选择表名、可变更标签、应用列表框提供代码帮助、有完整性控制的表格式数据维护程序。
* 请首先从下拉组合框选择数据表，
* 再选择关键字，可以为多个字段。
* 再选择字段，点击显示数据表显示数据表内容。
* 之后可作添加、修改、删除等操作。不能修改关键字数据。
* 为方便输入最后一个数据，当鼠标点击非关键字数据时会清掉原有数据，
* 如果不想清除，请点击关键字数据，或点击空行的列。
* 录入一行或修改一行或删除一行的最后一个数据如果是双击之后录入，
* 则要在输完数据后点击同一行记录的关键字再点击有关按钮，否则，最后一个数据修改不成功。
* 如果未双击或对该文本框做其他操作，直接录入了数据，可以不这样做。
* 如果不是点击按钮前最后一个数据，不必另外点击。
* 如果有表名加“字典表”的表，可以变换显示的标签。
* 某些字段如果有代码表，字段名为“**代码”或“**”，相应代码表名为“**代码表”
* 其中字段一个与数据表中字段名相同，另一个对应上一行所说的字段名为“**”或“**代码”
* 当点击数据表中某列时（请点击空行位置，以免误删除数据。）如果该列有对应代码表
* 会将代码数据显示在右边列表框内，否则显示该列去掉重复值后的历史数据。
* 点击列表框中数据，会将数据自动填入表格中。
* 如果应用completeTool4DB.java或secu reTool.java建立了接口参数表，
* 表名为数据表名+“接口参数表”，在录入或修改时会自动进行完整性、安全性检验，不满足条件的不能录入。
* 接口参数表只对数字数据类型字段设置最大值、最小值、值域、条件表达式
* 值域用2个数字表示，之间用逗号分隔，例如 50,100表示数据有效范围在50到100之间。
* 条件表达式时由字段名、数字常数及>=、<=、>、<、=、!=、and、or、算术运算符、某些函数构成的式子
* 例如：基本工资+岗贴<=10000 and 基本工资>3000 or 岗贴>1000
* 调用： tableTenance13.means(parameter)
* 可有简单权限控制
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.EmptyBorder;
import javax.swing.border.LineBorder;
import javax.swing.table.*;
import java.sql.*;
import java.util.*;
import java.util.List;
public class tableTenance13 extends JFrame implements ItemListener
{
static tableTenance13 frame = new tableTenance13(); // 创建窗体
public static JPanel panel = new JPanel(false); //定义面板
public static JTable table; // 创建表格
private static JButton 添加;
private static JButton 修改;
private static JButton 删除;
private static JButton 退出;
private static java.awt.List list0,listl0,listr0 ;
static Connection con; // 连接数据库
static ResultSet rs;
static Statement sta3;
static String 表名,字典表名;
static String 表名表 ;
static String [] 字段名表 ;
static String s1,s2,s3;
static int 列数 ; // 数据表列数
static String[][] 列名; // 数据表列名
static String[] 列数据类型; // 存放当前记录各字段数据类型的数组
static int[] 列数据宽度; // 存放当前记录各字段数据宽度的数组
static int 记录条数; // 记录条数
static Object[][] 表格数据;// 存放表格数据的数组
static DefaultTableModel model;
static int 窗口宽, 窗口高;
static String[] 一条记录;
static String 键盘输入字串="";
static String [] 按钮集=null;
static String 要求按钮号表;
static int 按钮数=0,按钮宽=0;
static String[] 关键字段名;
static int [] 关键字序号;
static String [] 关键字段值;
static JComboBox jcb=new JComboBox();
static String 接口参数表数据[][];
static String 代码表数据[][];
static String 接口参数表名;
static String username="";
static String 是否有登录;
static String 列名表="";
static Set <String> hs=null;
public static void means(String[] parameter){
username=main1.username;
是否有登录=main1.是否有登录;
frame = new tableTenance13();
窗口宽=main1.窗口宽;窗口高=main1.窗口高;
hs=new HashSet();
表名表 = parameter[0];
String [] 按钮集01={"添加","修改","删除","退出"};
按钮集=new String[按钮集01.length];
按钮数=0;
键盘输入字串 = "";
关键字段名=null;
关键字序号=null;
关键字段值=null;
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;
按钮数++;
}
}
要求按钮号表=","+要求按钮号表+",";
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){}
frame.setTitle("随机选择数据表进行维护程序 作者：程学先"); // 设置窗体标题
frame.setBounds(10, 10, 窗口宽, 窗口高); // 设置窗体的位置和大小
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
frame.setLayout(null);
panel = new JPanel(false); //定义面板
panel.setLayout(null); //关闭面板布局管理器
panel.setBounds(10, 10,窗口宽,窗口高);
final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
JLabel jl0 = new JLabel("请选择数据表");//选择字段名标签
jl0.setForeground(Color.RED);
jl0.setBounds(10,10,120,20);
panel.add(jl0);
jcb=new JComboBox();
jcb.setBounds(10,40,120,25);
jcb.setBackground(Color.WHITE);
panel.add(jcb);
String [] s4=表名表.split(",");
for (int i=0;i<s4.length;i++)
jcb.addItem(s4[i]);
JLabel l0 = new JLabel("请选择关键字");//选择字段名标签
l0.setForeground(Color.RED);
l0.setBounds(10,90,120,20);
panel.add(l0);
list0 = new java.awt.List();
list0.setBounds(10,120,120,150); //数据表列表框大小位置
list0.setMultipleMode(true); //允许多选
JLabel l1 = new JLabel("请选择显示列");//选择字段名标签
l1.setBounds(10,280,120,20);
panel.add(l1);
listl0 = new java.awt.List();
listl0.setBounds(10,310,120,200); //选字段列表框大小位置
listl0.setMultipleMode(true);
panel.add(list0);
panel.add(listl0);
jcb.addItemListener(frame);
listr0 = new java.awt.List();
listr0.setBounds(窗口宽-140,10,100,窗口高-200); //选字段列表框大小位置
listr0.setMultipleMode(true);
panel.add(listr0);
listr0.addMouseListener(new MouseAdapter() { //代码数据鼠标事件监听器
public void mouseClicked(MouseEvent e) {
int 行号 = table.getSelectedRow();
int 列号 = table.getSelectedColumn();
model.setValueAt(listr0.getSelectedItem(), 行号, 列号);
}
});
按钮宽=(窗口宽-450)/按钮数;
int 左边距=420;
添加 = new JButton();// 添加按钮
添加.setText(按钮集[0]);
添加.setBounds(左边距,560,按钮宽,20);
if (要求按钮号表.indexOf(",0,")>=0) {
左边距=左边距+按钮宽;
panel.add(添加);
}
添加.addActionListener(new ActionListener()
{
public void actionPerformed( ActionEvent e)
{
int m0=0,m1=0,m2=0;
m0=table.getSelectedRow();
m2=table.getSelectedColumn();
关键字段值=new String[关键字段名.length]; //检查实体完整性
s1 = "";
for (int i = 0; i < 关键字段名.length; i++) {
关键字段值[i] = model.getValueAt(m0, 关键字序号[i])
.toString();
if (关键字段值[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.数字数据类型.lastIndexOf(列数据类型[关键字序号[i]]) > 0)
s1 = s1 + 列名[0][关键字序号[i]] + "=" + 关键字段值[i];
else
s1 = s1 + 列名[0][关键字序号[i]] + "='" + 关键字段值[i] + "' ";
if (i < 关键字段名.length - 1)
s1 = s1 + " and ";
}
int j1 = 0;
for (int j=0;j<model.getRowCount()-1;j++){
for (int i = 0; i < 关键字段名.length; i++){
if (关键字段值[i].trim().equals(model.getValueAt(j, 关键字序号[i]).toString().trim()))
j1++;
if (j1==关键字段名.length) {
JOptionPane.showMessageDialog(null, "关键字数据重复，请检查！");
return;
}
}
j1=0;
}
s1="";
s2="";
for(int j=0;j<列数;j++){
s1=s1+列名[0][j];
if (j<列数-1) s1=s1+",";
if (model.getValueAt(m0, j) == null) s3="";
else
s3 = model.getValueAt(m0, j).toString() ;
if(main1.数字数据类型.trim().indexOf(","+列数据类型[j]+",")>=0){
if (s3.trim().length()<1) s3="0";
s2=s2+s3.trim();
if (compto(s3,m0,j)<0)
return; //完整性检查失败
}
else {
s2=s2+"'"+s3.trim()+"'";
}
if(j<列数-1)
s2=s2+",";
}
s1="insert into "+表名+"("+s1+")"+" values ("+s2+")";
try {
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
键盘输入字串="";
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能录入，可能是数据出错，请检查！");
return;
}
model.addRow(一条记录);
}
});
修改 = new JButton();// 修改按钮
修改.setText(按钮集[1]);
修改.setBounds(左边距,560,按钮宽,20);
if (要求按钮号表.indexOf(",1,")>=0) {
左边距=左边距+按钮宽;
panel.add(修改);
}
修改.addActionListener(new ActionListener()
{
public void actionPerformed( ActionEvent e)
{
s1 = "";
int j1 = 0;
int m0=table.getSelectedRow();
int m1=table.getSelectedColumn();
关键字段值=new String[关键字段名.length]; //检查实体完整性
for (int i = 0; i < 关键字段名.length; i++) {
关键字段值[i] = model.getValueAt(m0, 关键字序号[i]).toString();
if (关键字段值[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.数字数据类型.lastIndexOf(列数据类型[关键字序号[i]]) > 0)
s1 = s1 + 列名[0][关键字序号[i]] + "=" + 关键字段值[i];
else
s1 = s1 + 列名[0][关键字序号[i]] + "='" + 关键字段值[i] + "' ";
if (i < 关键字段名.length - 1)
s1 = s1 + " and ";
}
String str1="";
for(int j=0;j<列数;j++){
if(main1.数字数据类型.trim().indexOf(","+列数据类型[j]+",")>=0){
if ((table.getValueAt(m0, j)==null) ||(table.getValueAt(m0, j).toString().trim().length()==0))
str1=str1+列名[0][j]+"=0";
else str1=str1+列名[0][j]+"="+
table.getValueAt(m0, j).toString().trim();
if ((table.getValueAt(m0, j)!=null)&&(compto(table.getValueAt(m0, j).toString(),m0,j))<0)
return; //完整性检查失败
}
else
if (table.getValueAt(m0, j)==null)
str1=str1+列名[0][j]+"=' '";
else str1=str1+列名[0][j]+"='"+
table.getValueAt(m0, j).toString().trim()+"'";
if(j<列数-1)
str1=str1+",";
}
try{
s1=" update "+表名+" set "+str1+" where "+s1;
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
键盘输入字串="";
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能修改成功，可能是数据出错，请检查！");
return;
}
}
});
删除 = new JButton();// 删除按钮
删除.setText(按钮集[2]);
删除.setBounds(左边距,560,按钮宽,20);
if (要求按钮号表.indexOf(",2,")>=0) {
左边距=左边距+按钮宽;
panel.add(删除);
}
删除.addActionListener(new ActionListener(){
public void actionPerformed( ActionEvent e){
s1 = "";
int j1 = 0;
int m0=table.getSelectedRow();
关键字段值=new String[关键字段名.length]; //检查实体完整性
for (int i = 0; i < 关键字段名.length; i++) {
关键字段值[i] = model.getValueAt(m0, 关键字序号[i]).toString();
if (关键字段值[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.数字数据类型.lastIndexOf(列数据类型[关键字序号[i]]) > 0)
s1 = s1 + 列名[0][关键字序号[i]] + "=" + 关键字段值[i];
else
s1 = s1 + 列名[0][关键字序号[i]] + "='" + 关键字段值[i] + "' ";
if (i < 关键字段名.length - 1)
s1 = s1 + " and ";
}
try {
s1="delete from "+表名+" where "+s1;
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能删除成功，可能是数据出错，请检查！");
return;
}
model.removeRow(table.getSelectedRow());
}
});
退出 = new JButton(按钮集[3]);
退出.setBounds(左边距,560,按钮宽,20);
if (要求按钮号表.indexOf(",3,")>=0) {
左边距=左边距+按钮宽;
panel.add(退出);
}
退出.addActionListener(new ActionListener()
{
public void actionPerformed(final ActionEvent e)
{
frame.setVisible(false);
frame.dispose();
}
});
退出.setText("退出");
JButton 显示表格 = new JButton("显示表格");// 添加按钮
显示表格.setBounds(10,530,120,20);
显示表格.setForeground(Color.RED);
panel.add(显示表格);
显示表格.addActionListener(new ActionListener()
{
public void actionPerformed( ActionEvent e)
{
字段名表=listl0.getSelectedItems();
int [] y0=listl0.getSelectedIndexes();
s1="";
if (字段名表.length>0)
for (int i=0;i<字段名表.length;i++){
if (i==字段名表.length-1)
s1=s1+列名[0][y0[i]];
else
s1=s1+列名[0][y0[i]]+",";
}
else if (JOptionPane.showConfirmDialog(null, "您未选择列名，意味选全部字段，请确认。",
"yes", JOptionPane.YES_NO_OPTION)==1){
return;
}
else {
字段名表=new String[列数];
s1="";
for (int i=0;i<列数;i++){
if (i==列数-1)
s1=s1+列名[0][i];
else
s1=s1+列名[0][i]+",";
字段名表[i]=列名[0][i]; //全部字段
}
}
关键字段名=list0.getSelectedItems();
if (关键字段名.length==0){
JOptionPane.showMessageDialog(null, "未选择关键字，请检查！");
return;
}
关键字序号=new int[关键字段名.length];
for (int i=0;i<字段名表.length;i++){
for (int j=0;j<关键字序号.length;j++){
if (字段名表[i].equals(关键字段名[j]))
关键字序号[j]=i;
}
}
try{
main1.driver1();
con=main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select "+s1+" from " + 表名;
rs = sta3.executeQuery(s1);
rs.last();
记录条数=rs.getRow();
ResultSetMetaData rsmd = rs.getMetaData();
列数 = rsmd.getColumnCount(); // 获取列数
列名 = new String[2][列数]; // 定义列名数组
列数据类型 = new String[列数];
列数据宽度 = new int[列数];
一条记录=new String[列数];
for (int i=0;i<列数;i++) {
列名[0][i] = rsmd.getColumnName(i + 1); // 获取列名存到数组中
列名[1][i]=列名[0][i];
列数据类型[i] = rsmd.getColumnTypeName(i+1);
列数据宽度[i] = rsmd.getColumnDisplaySize(i+1);
if (列数据宽度[i] < 列名[1][i].length())
列数据宽度[i] = 列名[1][i].length();
else if (列数据宽度[i] > 50)
列数据宽度[i] = 50;
一条记录[i]="";
}
表格数据=new String[记录条数][列数];
rs.absolute(1);
int c=0; //行号
int b=0; //列号
while(c<记录条数) {
rs.absolute(c+1);
while(b<列数){
表格数据[c][b]=rs.getString(b+1);
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch (SQLException e1){
JOptionPane.showMessageDialog( null, "获取数据结构出错！");
}
字典表名="";
String []t1;
int b=0,c=0;
if (表名表.lastIndexOf(表名+"字典表")>=0){
t1=表名表.split(",");
for (int i=0;i<t1.length;i++)
if (t1[i].lastIndexOf(表名+"字典表")>=0) 字典表名=t1[i];
}
if (字典表名.length() > 0){
try
{
con = main1.getConn(); // 调用前面方法连接数据库
s1 = "select * from " + 字典表名;
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs=sta3.executeQuery(s1);
while (rs.next())
{
String 字段名称 = rs.getString(1);
String 标签名称 = rs.getString(2);
b = 0;
while (b < 列数)
{
if (列名[0][b].compareTo(字段名称.trim()) == 0)
{
列名[1][b] = 标签名称;
if (列数据宽度[b] < 列名[1][b].length())
列数据宽度[b] = 列名[1][b].length();
break;
}
b++;
}
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1){
e1.printStackTrace();
}
}
if(接口参数表名.length()>0){
con = main1.getConn();
s1 = "select * from " + 接口参数表名;
con=main1.getConn();
try
{
sta3=con.createStatement
(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs=sta3.executeQuery(s1);
ResultSetMetaData rsmd=rs.getMetaData();
rs.last();
int rows=rs.getRow();
rs.absolute(1);
int columns=rsmd.getColumnCount();
接口参数表数据=new String[rows][columns];
int i=0;
while (i<rows)
{
for(int j=0;j<columns;j++)
{
接口参数表数据[i][j]=rs.getString(j+1);
}
i++;
rs.next();
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1)
{
e1.printStackTrace();
}
}
model = new DefaultTableModel(表格数据, 列名[1]);
model.addRow(一条记录);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < 列数; i++)
{
TableColumn tc = table.getColumn(列名[1][i]);
JTableHeader header = table.getTableHeader();
tc.setPreferredWidth(列数据宽度[i] * 9);
tc.setMaxWidth(列数据宽度[i] * 9);
tc.sizeWidthToFit();
}
scrollPane.setBounds(150,20,窗口宽-300,窗口高-180);
scrollPane.setViewportView(table);
panel.add(scrollPane);
table.addKeyListener(new KeyAdapter() { //键盘事件
public void keyPressed(KeyEvent evt) { //按下某个键时调用此方法
键盘输入字串 = 键盘输入字串 + evt.getKeyChar();
}
});
table.addMouseListener(new MouseAdapter() { //鼠标侦听器
public void mouseClicked(MouseEvent e) { // 鼠标按键在组件上单击（按下并释放）时调用
int selectedRow = table.getSelectedRow();
int 行号 = table.getSelectedRow();
int 列号 = table.getSelectedColumn();
if (关键字段名 == null) {
JOptionPane.showMessageDialog(null, "请选择关键字！");
return;
}
int k = 0;
for (int i = 0; i < 关键字段名.length; i++) {
if (关键字序号[i] == 列号)
k = 1;
}
if (k == 0) { // 非关键字数据清除，关键字数据保留
model.setValueAt("", 行号, 列号); // 清原有数据
}
键盘输入字串 = ""; // 清"键盘输入字串"
listr0.removeAll();
hs.clear();
if (代码表数据[列号][0] == null) //本字段无代码表
for (int i1 = 0; i1 < 表格数据.length; i1++) {
if ((表格数据[i1][列号] != null)
&& (表格数据[i1][列号].toString().length() > 0))
hs.add(表格数据[i1][列号].toString());
}
else
for (int i1 = 0; i1 < 代码表数据[列号].length; i1++) {
if (代码表数据[列号][i1]==null) break;
hs.add(代码表数据[列号][i1].toString());
}
Iterator it = hs.iterator();
while (it.hasNext())
listr0.add(it.next().toString());
}
});
table.addFocusListener(new FocusAdapter() { //键盘焦点
public void focusLost(final FocusEvent arg0) {//组件失去键盘焦点时调用
int 行号 = table.getSelectedRow();
int 列号 = table.getSelectedColumn();
Double temp0=0.0;
String sb="";
if (键盘输入字串.trim().length()>0){
if (键盘输入字串.indexOf(" ")>=0)
键盘输入字串=键盘输入字串.substring(键盘输入字串.lastIndexOf(" ")+1,键盘输入字串.length());
model.setValueAt(键盘输入字串, 行号, 列号);
}
}
});
}
});
frame.add(panel);
frame.setVisible(true);
}
public void itemStateChanged(ItemEvent e) {
if (e.getStateChange()==2) return;
表名=jcb.getSelectedItem().toString();
接口参数表名="";
if (表名表.indexOf(表名+"接口参数表")>=0)
接口参数表名=表名+"接口参数表";
try{
main1.driver1();
con=main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 表名;
rs = sta3.executeQuery(s1);
ResultSetMetaData rsmd = rs.getMetaData();
列数 = rsmd.getColumnCount(); // 获取列数
列名 = new String[2][列数]; // 定义列名数组
代码表数据= new String[列数][];
for (int i=0;i<列数;i++) {
列名[0][i] = rsmd.getColumnName(i + 1); // 获取列名存到数组中
列名[1][i]=列名[0][i];
代码表数据[i]=new String[2];
}
rs.close();
sta3.close();
con.close();
} catch (SQLException e1){
JOptionPane.showMessageDialog( null, "获取数据结构出错！");
}
for (int i2=0;i2<列数;i2++) {
if (表名表.lastIndexOf(列名[0][i2]+"代码表")>=0){
s1=列名[0][i2]+"代码表";
数据表查询数据0(s1,列名[0][i2],i2);
}
else if (表名表.lastIndexOf(列名[0][i2]+"表")>=0){
s1=列名[0][i2]+"表";
数据表查询数据0(s1,列名[0][i2],i2);
}
}
字典表名="";
String []t1;
int b=0,c=0;
if (表名表.lastIndexOf(表名+"字典表")>=0){
t1=表名表.split(",");
for (int i=0;i<t1.length;i++)
if (t1[i].lastIndexOf(表名+"字典表")>=0) 字典表名=t1[i];
}
if (字典表名.length() > 0){
try
{
con = main1.getConn(); // 调用前面方法连接数据库
s1 = "select * from " + 字典表名;
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs=sta3.executeQuery(s1);
while (rs.next())
{
String 字段名称 = rs.getString(1);
String 标签名称 = rs.getString(2);
b = 0;
while (b < 列数)
{
if (列名[0][b].compareTo(字段名称.trim()) == 0)
{
列名[1][b] = 标签名称;
break;
}
b++;
}
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1){
e1.printStackTrace();
}
}
if((是否有登录.equals("有"))&&(username.length()>0)&&(接口参数表名.length()>0)){
con = main1.getConn();
s1 = "select * from " + 接口参数表名;
con=main1.getConn();
try
{
sta3=con.createStatement
(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs=sta3.executeQuery(s1);
ResultSetMetaData rsmd=rs.getMetaData();
rs.last();
int rows=rs.getRow();
rs.absolute(1);
int columns=rsmd.getColumnCount();
接口参数表数据=new String[rows][columns];
int i=0;
while (i<rows)
{
for(int j=0;j<columns;j++)
{
接口参数表数据[i][j]=rs.getString(j+1);
}
i++;
rs.next();
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1)
{
e1.printStackTrace();
}
String x8="",x9="";
for (int i1=0;i1<接口参数表数据.length;i1++){
if ((接口参数表数据[i1][0].equals("2"))&&(接口参数表数据[i1][6].equals(username)))
x8=接口参数表数据[i1][7]; //有权操作的列号列表
x9=接口参数表数据[i1][8]; //权限列表
}
if (x8.length()==0){
JOptionPane.showMessageDialog( null, "对不起，您未具有对此表的操作权限，请申请权限。");
return;
}
else {
for (int i=0;i<列数;i++)
if ((","+x9+",").indexOf(","+i+",")<0)
列名[1][i]="";
}
if (x9.indexOf("0")<0)
添加.setVisible(false);
else if (x9.indexOf("1")<0)
修改.setVisible(false);
else if (x9.indexOf("2")<0)
删除.setVisible(false);
}
listl0.removeAll();
list0.removeAll();
for (int i=0;i<列数;i++){
if (列名[1][i].length()>0)
list0.add(列名[1][i]);
}
for (int i=0;i<列数;i++){
if (列名[1][i].length()>0)
listl0.add(列名[1][i]);
}
}
public static int compto(String 键盘输入字串,int 行号,int 列号){
Double temp0=0.0;
String sb="";
if (键盘输入字串.trim().length()>0){
if (接口参数表名.length()>0) {
for(int j=0;j<接口参数表数据.length;j++)
{
if (接口参数表数据[j][0].trim().equals("3")){
if (接口参数表数据[j][1].trim().equals(列名[0][列号].trim())
|| 接口参数表数据[j][1].trim().equals(列名[1][列号].trim()))
{ //检查某一条条件字段名是否相符
if (键盘输入字串.indexOf(" ")>=0)
键盘输入字串=键盘输入字串.substring(键盘输入字串.lastIndexOf(" ")+1,键盘输入字串.length());
try{
temp0=Double.parseDouble(键盘输入字串.trim());
}catch(Exception e1)
{
JOptionPane.showMessageDialog( null, "完整性控制只限数字数据类型！");
return -1;
}
if (接口参数表数据[j][2]!=null){
if (temp0>Double.parseDouble(接口参数表数据[j][2]))
{ //接口参数表数据[j][2] 为最大值，接口参数表数据[j][3]为最小值
JOptionPane.showMessageDialog( null, "数据超过最大值，请修改！");
return -1;
}
}
if (接口参数表数据[j][3] != null){
if (temp0<Double.parseDouble(接口参数表数据[j][3]))
{ //接口参数表数据[j][2] 为最大值，接口参数表数据[j][3]为最小值
JOptionPane.showMessageDialog( null, "数据小于最小值，请修改！");
return -1;
}
}
if(接口参数表数据[j][4]!=null){
String strs[]=接口参数表数据[j][4].split(",");
for(int ii=0;ii<strs.length;ii++)
{ //范围数据要求小的在前，大的在后。例如 (30,80)表示在30到80之间
if (temp0>Double.parseDouble(strs[1]) ||
temp0<Double.parseDouble(strs[0]))
{
JOptionPane.showMessageDialog( null, "数据值域错，请修改！！");
return -1;
}
}
}
if(接口参数表数据[j][5]!=null){
sb=接口参数表数据[j][5];
for (int i1=0;i1<列数;i1++){
if ((sb.indexOf(列名[0][i1])>=0)&&
(main1.数字数据类型.indexOf(列数据类型[i1])>=0)){
sb=sb.replaceAll(列名[0][i1],model.getValueAt(行号, i1).toString());
//将变量名换成输入的数据值，例如输入数据为 90 变量名为年龄，则将：年龄>60变成：90>60 下面程序检查其正确性
}
}
try {
if (! tenanceEval.tenanceeval(sb.toLowerCase())) {
JOptionPane.showMessageDialog( null, "数据不满足完整性条件表达式！");
return -1;
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
}
model.setValueAt(键盘输入字串, 行号, 列号);
}
return 0;
}
static void 数据表查询数据0(String 代码表名0,String 列名9,int j9) {
try
{
int u=0;
s1 = "select "+列名9+" from " + 代码表名0;
//查代码表
con=main1.getConn();// 连接数据库
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs = sta3.executeQuery(s1);
rs.last();
int row=rs.getRow();
rs.beforeFirst();
代码表数据[j9]= new String[row];
for (int i=1;i<=row;i++){
rs.absolute(i);
代码表数据[j9][i-1]=rs.getString(1).trim();
}
rs.close();
sta3.close(); //关闭连接
con.close();
} catch(SQLException e3){
JOptionPane.showMessageDialog( null, "读取数据库数据出错！"+s1);
}
}
}
40.源码40，部件程序，单记录数据维护程序(表单程序)。
/**
* 程序文件名：dataTenance1.java
* 作者：贺红艳
* 功能：单记录数据维护程序
* 以文本框、按钮等构成单记录数据维护界面，包括数据录入、修改、删除数据等功能。
* 本部件不涉及包含有image等二进制数据类型的数据的维护
* 完成日期：2013年12月20日
* 被调用语句：dataTenance1.means(parameter);
* 当无大数据类型时，在窗口中按每字段一行安排控件，各字段统一长度，
* 再按每字段一行均匀布局。如果字段数多，按各字段实际大小布局，行间均匀留空。
* 如果有大数据类型，一般字段紧凑布局，余下空间均匀分配给大数据类型。
* 本部件不涉及包含有image等二进制数据类型的数据的维护
* 必须提供的参数：“表名”、“关键字段名”
* 可选参数：“窗口宽”、“窗口高” 、 “要求字段号表”、“要求按钮号表”。
* 关键字段名为识别与区分记录的主要标志，不允许重复，不允许为空，可以是单一字段，也可以是多个字段，
* 如果是多字段，以英文逗号分隔。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序后，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件“第一条”、“下一条”、“最后一条”、“上一条”、“浏览”、“存盘”、“清屏”、
* “修改存盘”、“删除”、“退出”共 10 个。
* 通过“要求按钮号表”提供所需要显示的按钮在该部件原设计的界面 中的顺序号，各按钮号用逗号分隔。
* 做数据录入程序模块使用时一般选择“存盘”、“清屏”、“退出”等按钮，选择按钮号为：“7,8,12”。
* 做数据修改程序模块使用时，一般选择“第一条”、“下一条”、“最后一条”、“上一条”、“浏览”、“查询”、
* “修改存盘”、“退出”等按钮，选择按钮号为：“1,2,3,4,5,6,9,12”。
* 每录入一条记录后必须点击“存盘”按钮，将新记录填入表内。
* 每修改一条记录，必须点击“修改存盘”按钮，将改后记录填入表内。
* 每删除一条记录，必须点击“删除”按钮，将改后记录填入表内。
* 如果要根据条件选择的结果将满足条件的记录某一字段数据全部改为某数据，
* 需要先进行查询，再在某字段文本框中输入改后数据，之后点击“批处理”按钮。
* 查询只限等值查询，要求先在某字段文本框中输入欲查询的数据值，再点击查询按钮，
* 实现该字段等于该值的查询。
* 注意本程序适用于由基本数据类型构成的数据表，
* 适用数据类型包括各类整型、各浮点类型、各char数据类型、各text数据类型。
*/
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashSet;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.text.JTextComponent;
public class dataTenance1 {
static JFrame frame1 = new JFrame();
static JTextField[] 文本框;
private static Connection cont4; // 连接数据库
private static Statement stat4;
private static ResultSetMetaData rsmdt4;
private static ResultSet rs; // 数据库数据集
private static String 表名; // 数据表名
private static int 窗口宽 = main1.窗口宽;
private static int 窗口高 = main1.窗口高;// 窗口高
private static int 窗口左边距 = 10, 窗口到顶距 = 10;
private static int 列数; // 数据表列数
private static int 表格列数;
private static String[] 列名; // 数据表列名
private static String[] 表格列名;
private static String[] 原始表格列名;
private static String[] 列数据类型; // 存放当前记录各字段数据类型的数组
private static String[] 表列数据类型; // 存放表格各列数据类型的数组
private static int[] 列数据宽度; // 存放当前记录各字段数据宽度的数组
private static int[] 表列数据宽度; // 存放表格各列数据宽度的数组
private static int 记录条数 = 0;
private static int 记录条数1 = 0;
private static String[][] 表格数据;
private static String[] 文本数组值;
static String[][] 备份数据;
private static String 要求按钮号表;
private static String 要求字段号表 = "", 限只读字段号表 = "";
private static String[] 一条空记录;
private static String 列名表 = ""; // 包括全部列名的字符串
private static String[] 关键字段名;// 存放关键字字段名的数组
private static String[] 关键字段值;// 存放某记录关键字字段值的数组
private static int[] 关键字序号;
private static String s1 = "", s2 = "";
private static int b = 0, c = 0;
private static String[] 当前字段值;
private static int[] 列序号;
private static int[][] 位置参数;
private static int 控件个数 = 0;
private static String 键盘输入字串 = "";
private static int 字符宽度 = 15, 字符高度 = 20;
private static String[] 按钮集 = { "第一条", "下一条", "最后一条", "上一条", "浏览", "存盘",
"清屏", "修改存盘", "删除", "退出" };
private static JButton b1; // 定义按钮
private static JButton 第一条, 下一条, 最后一条, 上一条, 浏览, 存盘, 清屏, 修改存盘, 删除, 退出;
private static String 大数据类型 = main1.文本数据类型 + main1.图形数据类型;
public static String[] sw = new String[11];
static int 按钮数 = 0, 按钮宽 = 0;
public static int[][] 按钮位置;
public static int 大数据个数, 文本域高度;
public static int 最大字段宽;
public static int 实际按钮数;
public static int 起始左边距;
public static int 起始到顶距;
public static JTextComponent[] 文本数组;
public static int[] 文本数组号;
public static JButton[] 按钮数组 = new JButton[10];
public static int 按钮定义标志;
private static HashSet set01 = new HashSet();
private static String sd0;
static void means(String parameter[]) {
frame1 = new JFrame();
窗口宽 = main1.窗口宽;
窗口高 = main1.窗口高;
窗口左边距 = 10;
窗口到顶距 = 10;
记录条数 = 0;
记录条数1 = 0;
按钮定义标志 = 0;
s1 = "";
s2 = "";
b = 0;
c = 0;
键盘输入字串 = "";
字符宽度 = 15;
字符高度 = 20;
文本域高度 = 0;
大数据类型 = main1.文本数据类型 + main1.图形数据类型;
表名 = parameter[4]; // 数据表名
sw = new String[11]; // 接来自工作流的数据
sw[1] = main1.sw1 + "";
sw[2] = main1.sw2;
sw[3] = main1.sw3; // 为了不出现0影响判断，在树程序中将工序号统加1
sw[4] = main1.sw4;
sw[5] = main1.sw5;
sw[6] = main1.sw6;
sw[7] = main1.sw7;
sw[8] = main1.sw8;
sw[10] = main1.sw10;
main1.sw1 = 0;
main1.sw2 = "";
main1.sw3 = "";
main1.sw4 = "";
main1.sw5 = "";
main1.sw6 = "";
main1.sw7 = "";
main1.sw8 = "";
main1.sw10 = "";
/*
* main1.sw1 //工序号; main1.sw2//取工作流定义数据;main1//取类图位置数据
* main1.sw4//取关键字;main1.sw5//取关键字值; main1.sw6//取表名
* main1.sw7//取记录序号;main1.sw8//取类名; main1.sw9//取工序号 main1.sw10//取用户名
*/
String[] 按钮集01 = { "第一条", "下一条", "最后一条", "上一条", "浏览", "存盘", "清屏",
"修改存盘", "删除", "退出" };
String 要求按钮号表0;
按钮集 = 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;
}
}
要求按钮号表0 = 要求按钮号表;
要求按钮号表 = "," + 要求按钮号表 + ",";
要求按钮号表 = 要求按钮号表.replaceAll(",,", ",");
按钮数 = 按钮集.length; // 可以供选择的按钮数
窗口宽 = main1.窗口宽;
窗口高 = main1.窗口高;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);// 宽度参数
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
窗口宽 = m1;
窗口高 = m2;
}
} catch (Exception e2) {
}
表名 = parameter[4]; // 数据表名
if (parameter[6].length() <= 0) {
JOptionPane.showMessageDialog(null, "缺少关键字，请说明关键字字段后再运行。");
return;
}
关键字段名 = parameter[6].split(",");
if (sw[5].length() > 0) { // 如果是可视化表单设计器得到的接口表
if (要求按钮号表0.trim().length() > 0) {
String[] ss = 要求按钮号表0.split(",");
要求按钮号表 = "";
for (int j = 0; j < ss.length; j++) {
if (要求按钮号表.length() == 0)
要求按钮号表 = (Integer.parseInt(ss[j]) + 5) + "";
else
要求按钮号表 = 要求按钮号表 + "," + (Integer.parseInt(ss[j]) + 5)
+ "";
}
} else
要求按钮号表 = "5,6,7,8,9";
}
要求字段号表 = parameter[8];
限只读字段号表 = "," + parameter[9] + ",";
关键字序号 = new int[关键字段名.length];
按钮数组 = new JButton[10];
try {
cont4 = main1.getConn();// 连接数据库
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 表名;
if ((sw[3].length() > 0) && (sw[4].length() > 0))
s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";
rs = stat4.executeQuery(s1);
rs.last();
记录条数 = rs.getRow();
rsmdt4 = rs.getMetaData();
列数 = rsmdt4.getColumnCount();
列名 = new String[列数];
列数据类型 = new String[列数];
列数据宽度 = new int[列数];
for (int i = 0; i < 列数; i++) {
列名[i] = rsmdt4.getColumnName(i + 1);
列数据类型[i] = rsmdt4.getColumnTypeName(i + 1);
列数据宽度[i] = rsmdt4.getColumnDisplaySize(i + 1);
if (字符宽度 * (列数据宽度[i] + 列名[i].length()) > 窗口宽)
列数据类型[i] = "text";
}
for (int j = 0; j < 关键字段名.length; j++)
for (int i = 0; i < 列数; i++) {
if (关键字段名[j].trim().equals(列名[i].trim())) {
关键字序号[j] = i;
if ((要求字段号表.length() > 0) &&
(("," + 要求字段号表 + ",").lastIndexOf("," + i+ ",") < 0))
要求字段号表 = 要求字段号表 + "," + i;
break;
}
}
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错！");
}
要求字段号表 = "," + 要求字段号表 + ",";
列序号 = new int[列数];
int b0 = 0, b = -1;
while (b0 < 列数) {
if ((要求字段号表.length() < 3)
|| (要求字段号表.lastIndexOf("," + b0 + ",") >= 0)) {
b = b + 1;
列序号[b] = b0;
} else
列序号[b0] = b0;
b0++;
}
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 表格列数; i++) {
if (关键字序号[j] == i)
关键字序号[j] = 列序号[i];
}
}
if (b < 0)
表格列数 = 列数;
else
表格列数 = b + 1;
位置参数 = new int[表格列数][2];
表格列名 = new String[表格列数];
原始表格列名 = new String[表格列数];
表列数据类型 = new String[表格列数];
表列数据宽度 = new int[表格列数];
表格数据 = new String[记录条数 + 300][表格列数];
一条空记录 = new String[表格列数];
int 列名长度 = 0;
大数据个数 = 0;
最大字段宽 = 0;
int 需求面积 = 0, 原窗口宽 = 窗口宽, 原窗口高 = 窗口高;
b = 0;
while (b < 表格列数) {
原始表格列名[b] = 列名[列序号[b]];
表格列名[b] = 列名[列序号[b]];
列名表 = 列名表 + 表格列名[b];
表列数据类型[b] = 列数据类型[列序号[b]];
表列数据宽度[b] = 列数据宽度[列序号[b]];
if (表格列名[b].length() > 列名长度)
列名长度 = 表格列名[b].length();
if ((大数据类型.indexOf("," + 表列数据类型[b] + ",") < 0)
&& (最大字段宽 < (表格列名[b].length() + 表列数据宽度[b]) * 字符宽度)) {
最大字段宽 = (表格列名[b].length() + 表列数据宽度[b]) * 字符宽度;
}
if (大数据类型.indexOf("," + 表列数据类型[b] + ",") >= 0)
大数据个数++;
b++;
}
大数据个数 = 0;
int 文本区宽度 = (窗口宽 - 30) / 字符宽度;
b = 0;
while (b < 表格列数) {
if (大数据类型.lastIndexOf("," + 表列数据类型[b] + ",") >= 0)
大数据个数++;
if ((列名长度 + 表列数据宽度[b]) > (文本区宽度)) {
表列数据宽度[b] = 文本区宽度 - 列名长度;
}
if (表列数据类型[b].indexOf("datetime") == 0)
一条空记录[b] = "2001-01-01 00:00:00.000";
else if (表列数据类型[b].indexOf("smalldatetime") == 0)
一条空记录[b] = "2001-01-01 00:00:00";
// 以下二类型在JAVA中不被识别，本处考虑今后的扩展，暂时保留
else if (表列数据类型[b].indexOf("datetime2") == 0)
一条空记录[b] = "2001-01-01 00:00:00.0000000";
else if (表列数据类型[b].indexOf("datetimeoffset") == 0)
一条空记录[b] = "2001-01-01 00:00:00.0000000 +08:00";
else if (表列数据类型[b].indexOf("date") == 0)
一条空记录[b] = "2001-01-01";
else if (表列数据类型[b].indexOf("time") == 0)
一条空记录[b] = "00:00:00";
else if (表列数据类型[b].indexOf("money") >= 0)
一条空记录[b] = "0.0000";
else if (main1.小数型数据类型.lastIndexOf(表列数据类型[b]) > 0)
一条空记录[b] = "0.00";
else if (main1.数字数据类型.lastIndexOf(表列数据类型[b]) > 0)
一条空记录[b] = "0";
else
一条空记录[b] = "";
b++;
}
try {
rs.absolute(1);
c = 0;
b = 0;
while (c < 记录条数) {
rs.absolute(c + 1);
while (b < 表格列数) {
表格数据[c][b] = rs.getString(列序号[b] + 1);
b++;
}
c++;
b = 0;
}
rs.close();
stat4.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错！");
}
final JPanel panel1 = new JPanel(false);
panel1.setLayout(null);
int 行间距离 = 0, 按钮宽度 = 0;
int 本行当前宽度 = 0;
int 起始左边距 = 0;
位置参数 = new int[表格列数][2];
int 按钮行数;
if ((按钮数 * 字符宽度 * 6.3) % (窗口宽 - 30) == 0)
按钮行数 = (int) (按钮数 * 字符宽度 * 6.3) % (窗口宽 - 30);
else
按钮行数 = (int) (按钮数 * 字符宽度 * 6.3) / (窗口宽 - 30) + 1;
int 文本控件行数 = 1;
if ((大数据个数 == 0) && (表格列数 * 字符高度 + 按钮行数 * 字符高度 + 40 < 窗口高)) {
文本控件行数 = 表格列数;
for (int j = 0; j < 表格列数; j++) {
位置参数[j][0] = 1 + j;
位置参数[j][1] = 1;
表列数据宽度[j] = 文本区宽度 - 列名长度;
}
行间距离 = (窗口高 - 120 - (按钮行数 + 表格列数) * 字符高度) / (按钮行数 + 表格列数 + 1);
} else {
int 当前列列号 = 1;
for (int i = 0; i < 表格列数; i++) {
if (大数据类型.lastIndexOf("," + 表列数据类型[i] + ",") < 0) {
if ((本行当前宽度 + 列名长度 + 表列数据宽度[i]) <= 文本区宽度) {
本行当前宽度 = 本行当前宽度 + 列名长度 + 表列数据宽度[i];
位置参数[i][0] = 文本控件行数;
起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[i];
位置参数[i][1] = 当前列列号;
当前列列号++;
} else {
表列数据宽度[i - 1] = 表列数据宽度[i - 1] + 文本区宽度 - 本行当前宽度;
文本控件行数++;
当前列列号 = 1;
位置参数[i][0] = 文本控件行数;
位置参数[i][1] = 当前列列号;
当前列列号++;
本行当前宽度 = 列名长度 + 表列数据宽度[i];
起始左边距 = 列名长度 + 表列数据宽度[i];
}
b = i;
}
}
表列数据宽度[b] = 表列数据宽度[b] + 文本区宽度 - 本行当前宽度;
if (大数据个数 > 0)
行间距离 = 0;
else
行间距离 = (窗口高 - 120 - 按钮行数 * 字符高度 - 文本控件行数 * 字符高度)
/ (文本控件行数 + 按钮行数 + 1);
}
文本数组 = new JTextComponent[表格列数];
文本数组值 = new String[文本数组.length];
文本数组号 = new int[文本数组.length];
int 当前列 = 1, 当前行 = 1;
控件个数 = 0;
起始左边距 = 0;
起始到顶距 = 窗口到顶距 + 行间距离;
文本框 = new JTextField[表格列名.length];
for (int j = 0; j < 表格列名.length; j++) {
JLabel 标签 = new JLabel(表格列名[j], 11);
文本框[j] = new JTextField("");
if (限只读字段号表.indexOf("," + j + ",") >= 0) {
文本框[j].setEditable(false);
}
if (大数据类型.lastIndexOf("," + 表列数据类型[j] + ",") < 0) {
panel1.add(标签);
panel1.add((Component) 文本框[j]);
if ((位置参数[j][0] == 当前行) && (位置参数[j][1] == 当前列)) {
标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);
文本框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,
表列数据宽度[j] * 字符宽度, 字符高度);
位置参数[j][0] = 起始左边距 * 字符宽度 + 列名长度 * 字符宽度;
位置参数[j][1] = 起始到顶距;
起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];
当前列++;
} else if (位置参数[j][0] == 当前行) {
当前列++;
标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);
文本框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,
表列数据宽度[j] * 字符宽度, 字符高度);
位置参数[j][0] = 起始左边距 * 字符宽度 + 列名长度 * 字符宽度;
位置参数[j][1] = 起始到顶距;
起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];
} else {
起始到顶距 = 起始到顶距 + 行间距离 + 字符高度;
当前行++;
起始左边距 = 0;
标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);
文本框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,
表列数据宽度[j] * 字符宽度, 字符高度);
位置参数[j][0] = 起始左边距 * 字符宽度 + 列名长度 * 字符宽度;
位置参数[j][1] = 起始到顶距;
当前列 = 2;
起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];
}
文本框[j].setText(一条空记录[j]);
文本框[j].addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
Object s0 = arg0.getSource();
String s1 = s0.toString();
int n1 = 0;
for (int i = 0; i < 表格列名.length; i++) {
if (s1.lastIndexOf("," + 位置参数[i][0] + ","
+ 位置参数[i][1] + ",") > 0) {
break;
}
}
}
});
文本数组[控件个数] = (JTextComponent) 文本框[j];
文本数组号[控件个数] = j;
}
控件个数++;
}
if (大数据个数 > 0) {
起始到顶距 = 起始到顶距 + 字符高度;
文本域高度 = (窗口高 - 起始到顶距 - 150) / 大数据个数;
起始左边距 = 0;
int 文本域宽度 = (文本区宽度 - 列名长度) * 字符宽度;
for (int j = 0; j < 表格列名.length; j++) {
if (大数据类型.lastIndexOf("," + 表列数据类型[j] + ",") >= 0) {
JLabel 标签 = new JLabel(表格列名[j], 11);
if (文本域宽度 < 0)
文本域宽度 = 50;
if (文本域高度 < 0)
文本域高度 = 10;
JTextArea 文本域 = new JTextArea(" ", 文本域宽度, 文本域高度);
JScrollPane 文本域滚动条 = new JScrollPane(文本域);
文本域滚动条.setBounds(起始左边距 + 列名长度 * 字符宽度, 起始到顶距, 文本域宽度, 文本域高度);
panel1.add(标签);
panel1.add((Component) 文本域滚动条);
标签.setBounds(起始左边距, 起始到顶距, 列名长度 * 字符宽度, 字符高度);
起始到顶距 = 起始到顶距 + 文本域高度;
文本数组[j] = (JTextComponent) 文本域;
文本数组号[j] = j;
}
}
}
计算文本框002();
String sd = "";
set01.clear();
for (int i0 = 0; i0 < 记录条数; i0++) {
sd = "";
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 控件个数; i++) {
if (文本数组号[i] == 关键字序号[j]) {
sd = sd + 表格数据[i0][文本数组号[i]].trim() + ",";
break;
}
}
}
set01.add(sd);
}
第一条 = new JButton(按钮集[0]);
第一条.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
记录条数1 = 0;
for (int i = 0; i < 控件个数; i++) {
文本数组[i].setText(表格数据[0][文本数组号[i]]);
if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[i]] + ",") > 0)
if ((文本数组[i].getText() == null)
|| (文本数组[i].getText().trim().length() < 1))
文本数组[i].setText("0");
}
下一条.setEnabled(true);
上一条.setEnabled(false);
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",0,") >= 0)) {
第一条.setBounds(按钮位置[0][0], 按钮位置[0][1], 按钮位置[0][2], 按钮位置[0][3]);
panel1.add(第一条);
}
下一条 = new JButton(按钮集[1]);
下一条.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (记录条数1 < 记录条数 - 1) {
记录条数1++; // 记录指针
if (记录条数1 == 记录条数 - 1)
下一条.setEnabled(false);
for (int i = 0; i < 控件个数; i++) {
文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);
if ((main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[i]]
+ ",")) > 0)
if ((文本数组[i].getText() == null)
|| (文本数组[i].getText().trim().length() < 1))
文本数组[i].setText("0");
}
}
上一条.setEnabled(true);
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",1,") >= 0)) {
下一条.setBounds(按钮位置[1][0], 按钮位置[1][1], 按钮位置[1][2], 按钮位置[1][3]);
panel1.add(下一条);
}
最后一条 = new JButton(按钮集[2]);
最后一条.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (记录条数 > 1)
记录条数1 = 记录条数 - 1; // 记录指针-1
else
记录条数1 = 0;
for (int i = 0; i < 控件个数; i++) {
文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);
if ((main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[i]] + ",")) > 0)
if ((文本数组[i].getText() == null)
|| (文本数组[i].getText().trim().length() < 1))
文本数组[i].setText("0");
}
下一条.setEnabled(false);
上一条.setEnabled(true);
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",2,") >= 0)) {
最后一条.setBounds(按钮位置[2][0], 按钮位置[2][1], 按钮位置[2][2], 按钮位置[2][3]);
panel1.add(最后一条);
}
上一条 = new JButton(按钮集[3]);
上一条.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (记录条数1 > 0) {
记录条数1--; // 记录指针
for (int i = 0; i < 控件个数; i++) {
文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);
if ((main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[i]]
+ ",")) > 0)
if ((文本数组[i].getText() == null)
|| (文本数组[i].getText().trim().length() < 1))
文本数组[i].setText("0");
}
下一条.setEnabled(true);
} else
上一条.setEnabled(false);
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",3,") >= 0)) {
上一条.setBounds(按钮位置[3][0], 按钮位置[3][1], 按钮位置[3][2], 按钮位置[3][3]);
panel1.add(上一条);
上一条.setEnabled(false);
}
浏览 = new JButton(按钮集[4]);
浏览.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (浏览.getText().trim().equals("浏览")) {
浏览.setText("转当前行");
备份数据 = new String[记录条数][表格列数];
for (int i = 0; i < 记录条数; i++)
for (int j = 0; j < 表格列数; j++)
备份数据[i][j] = 表格数据[i][j];
tableTenance1.tableModel(窗口宽, 窗口高, 表格列名, 表列数据宽度, 备份数据,
表列数据类型);
} else {
浏览.setText("浏览");
记录条数1 = main1.当前行行号; // 记录指针
for (int i = 0; i < 控件个数; i++) {
文本数组[i].setText(表格数据[main1.当前行行号][文本数组号[i]]);
}
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",4,") >= 0)) {
浏览.setBounds(按钮位置[4][0], 按钮位置[4][1], 按钮位置[4][2], 按钮位置[4][3]);
panel1.add(浏览);
}
存盘 = new JButton(按钮集[5]);
存盘.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < 控件个数; i++) {
文本数组值[i] = 文本数组[i].getText();
if (文本数组值[i] == null)
文本数组值[i] = " ";
文本数组[i].setText(一条空记录[i]);
}
String sd = "";
int kd = set01.size();
int kd0 = 0;
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 控件个数; i++) {
if (文本数组号[i] == 关键字序号[j]) {
if ((文本数组值[i] == null)
|| (文本数组值[i].trim().length() == 0))
kd0 = 1;
sd = sd + 文本数组值[i].trim() + ",";
break;
}
}
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");
return;
}
set01.add(sd);
if (set01.size() == kd) {
JOptionPane.showMessageDialog(null, "关键字重复，请修改后重新生成！");
return;
}
set01.remove(sd); // 本句是生成SQL语句，在执行成功后再加到set中
sd0 = sd;
cont4 = main1.getConn(); // 连接数据库
try {
记录条数++;
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + 表名 + "(";
for (int j = 0; j < 控件个数; j++)
s1 = s1 + 原始表格列名[文本数组号[j]] + ",";
s1 = s1.substring(0, s1.length() - 1) + ") VALUES (";
for (int j = 0; j < 控件个数; j++) {
表格数据[记录条数 - 1][j] = 文本数组值[j];
if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[j]]
+ ",") >= 0) {
s1 = s1 + 文本数组值[j] + ",";
} else {
s1 = s1 + "'" + 文本数组值[j].trim() + "',";
}
}
s1 = s1.substring(0, s1.length() - 1) + ")";
stat4.executeUpdate(s1);
stat4.close();
cont4.close();
set01.add(sd0); // 添加新记录成功后将关键字加入set
} catch (SQLException e2) {
for (int j = 0; j < 控件个数; j++) {
表格数据[记录条数][j] = "";
}
记录条数--;
System.out.println("SQL语句错");
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",5,") >= 0)) {
存盘.setBounds(按钮位置[5][0], 按钮位置[5][1], 按钮位置[5][2], 按钮位置[5][3]);
panel1.add(存盘);
}
清屏 = new JButton(按钮集[6]);
清屏.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < 控件个数; i++) {
文本数组[i].setText(一条空记录[i]);
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",6,") >= 0)) {
清屏.setBounds(按钮位置[6][0], 按钮位置[6][1], 按钮位置[6][2], 按钮位置[6][3]);
panel1.add(清屏);
}
修改存盘 = new JButton(按钮集[7]);
修改存盘.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < 控件个数; i++) {
文本数组值[i] = 文本数组[i].getText();
if (文本数组值[i] == null) {
文本数组值[i] = " ";
}
}
String sd = "";
int kd = set01.size();
int kd0 = 0;
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 控件个数; i++)
if (文本数组号[i] == 关键字序号[j]) {
if ((文本数组值[i] == null)
|| (文本数组值[i].trim().length() == 0))
kd0 = 1;
sd = sd + 文本数组值[i].trim() + ",";
break;
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");
return;
}
}
sd0 = sd;
set01.add(sd);
if (set01.size() != kd) {
JOptionPane.showMessageDialog(null,
"关键字不存在，请改为生成数据录入语句！");
set01.remove(sd);
return;
}
s2 = "";
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 控件个数; i++)
if (文本数组号[i] == 关键字序号[j]) {
if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[j] + ",") >= 0) {
if (文本数组值[i].length() < 1)
文本数组值[i] = "0";
s2 = s2 + 关键字段名[j] + "=" + 文本数组值[i];
} else
s2 = s2 + 关键字段名[j] + "='" + 文本数组值[i] + "'";
break;
}
if (j < 关键字段名.length - 1)
s2 = s2 + " and ";
}
cont4 = main1.getConn(); // 连接数据库
try {
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "update " + 表名 + " set ";
for (int j = 0; j < 控件个数; j++) {
s1 = s1 + 原始表格列名[文本数组号[j]] + "=";
if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[j]]
+ ",") >= 0) {
if (文本数组值[j].length() < 1)
文本数组值[j] = "0";
s1 = s1 + 文本数组值[j];
} else {
s1 = s1 + "'" + 文本数组值[j].trim() + "'";
}
s1 = s1 + ",";
}
s1 = s1.substring(0, s1.length() - 1) + " where " + s2;
stat4.executeUpdate(s1);
stat4.close();
cont4.close();
for (int j = 0; j < 控件个数; j++) {
表格数据[记录条数1][j] = 文本数组值[j];
}
} catch (SQLException e2) {
System.out.println("SQL语句错");
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",7,") >= 0)) {
修改存盘.setBounds(按钮位置[7][0], 按钮位置[7][1], 按钮位置[7][2], 按钮位置[7][3]);
panel1.add(修改存盘);
}
删除 = new JButton(按钮集[8]);
删除.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < 控件个数; i++)
文本数组值[i] = 文本数组[i].getText().trim();
String sd = "";
int kd = set01.size();
int kd0 = 0;
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 控件个数; i++)
if (文本数组号[i] == 关键字序号[j]) {
if ((文本数组值[i] == null)
|| (文本数组值[i].trim().length() == 0))
kd0 = 1;
sd = sd + 文本数组值[i].trim() + ",";
break;
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");
return;
}
}
set01.add(sd);
if (set01.size() != kd) {
set01.remove(sd);
}
sd0 = sd;
s2 = "";
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 控件个数; i++)
if (文本数组号[i] == 关键字序号[j]) {
if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[j] + ",") >= 0)
s2 = s2 + 关键字段名[j] + "=" + 文本数组值[i];
else
s2 = s2 + 关键字段名[j] + "='" + 文本数组值[i].trim()
+ "'";
break;
}
if (j < 关键字段名.length - 1)
s2 = s2 + " and ";
}
cont4 = main1.getConn(); // 连接数据库
try {
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + 表名 + " where " + s2;
stat4.executeUpdate(s1);
stat4.close();
cont4.close();
deleteData(记录条数1);
set01.remove(sd0);
for (int i = 0; i < 控件个数; i++) {
if (记录条数1 == 记录条数 - 1)
文本数组[i].setText(一条空记录[i]);
else
文本数组[i].setText(表格数据[记录条数1][i]);
}
} catch (SQLException e2) {
System.out.println("SQL语句错");
}
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",8,") >= 0)) {
删除.setBounds(按钮位置[8][0], 按钮位置[8][1], 按钮位置[8][2], 按钮位置[8][3]);
panel1.add(删除);
}
退出 = new JButton(按钮集[9]);
按钮数组[9] = 退出;
退出.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if ((sw[2].length() > 0) && (sw[3].length() > 0)
&& (sw[4].length() > 0)) {
WorkflowDrivek1.means(sw);
}
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
}
});
if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",9,") >= 0)) {
退出.setBounds(按钮位置[9][0], 按钮位置[9][1], 按钮位置[9][2], 按钮位置[9][3]);
panel1.add(退出);
}
frame1.setTitle("单记录数据维护程序 作者：贺红艳"); // 窗口标题
panel1.setBounds(10, 10, 窗口宽 - 10, 窗口高 - 20);
int w1, h1;
if (1200 - 窗口宽 > 0)
w1 = (1200 - 窗口宽) / 2;
else
w1 = 0;
if (600 - 窗口高 > 0)
h1 = (600 - 窗口高) / 2;
else
h1 = 0;
frame1.setBounds(w1, h1, 窗口宽, 窗口高); // 主程序窗口位置大小
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame1.getContentPane().setLayout(null); // 关闭布局管理器
frame1.getContentPane().add(panel1, null); // 安装面板
frame1.setVisible(true); // 安装窗口
if ((sw[3].length() > 0) && (sw[4].length() > 0))
for (int i = 0; i < 控件个数; i++) {
文本数组[i].setText(表格数据[0][文本数组号[i]]);
}
}
static void 计算文本框002() { // 如果没有接口参数表，计算控件位置、大小参数
// 计算按钮位置
if (按钮定义标志 > 0)
return; // 如果在参数表中定义了按钮位置，则不做本性工作
String[] t5 = 要求按钮号表.split(",");
实际按钮数 = t5.length - 1;
按钮位置 = new int[按钮数][15];
for (int j = 0; j < 按钮数; j++) {
按钮位置[j][0] = 0;
按钮位置[j][1] = 0;
按钮位置[j][2] = 0;
按钮位置[j][3] = 0;
}
int 按钮行数, 按钮宽度;
按钮宽度 = (int) (字符宽度 * 6.3);
if ((实际按钮数 * 按钮宽度) % (窗口宽 - 50) == 0)
按钮行数 = (int) (实际按钮数 * 按钮宽度) % (窗口宽 - 50);
else
按钮行数 = (int) (实际按钮数 * 按钮宽度) / (窗口宽 - 50) + 1;
起始左边距 = 20;
if (大数据个数 == 0)
起始到顶距 = 起始到顶距 + 字符高度 * 2;
else
起始到顶距 = 起始到顶距 + 字符高度;
int 一行按钮数 = (窗口宽 - 30) / (int) (6.6 * 字符宽度);
if (一行按钮数 < 1)
一行按钮数 = 1; // 每行最少一个按钮
if (实际按钮数 <= 一行按钮数)
按钮宽度 = (窗口宽 - 60) / 实际按钮数;
else
按钮宽度 = (窗口宽 - 60) / 一行按钮数;
int n = 0, n1 = 0, n2 = 0, n3 = 0; // n：当行按钮数，n1：已排按钮数,n2：按钮行数,n3:一行按钮宽
n3 = 一行按钮数 * 按钮宽度;
for (int j = 0; j < 按钮数; j++) {
if (要求按钮号表.lastIndexOf("," + j + ",") >= 0) {
按钮位置[j][0] = 起始左边距;
按钮位置[j][1] = 起始到顶距;
if (按钮集[j].length() > 4) {
按钮位置[j][2] = (int) (按钮集[j].length() * (字符宽度 * 1.2));
n3 = n3 + 按钮位置[j][2] - 按钮宽度;
起始左边距 = 起始左边距 + 按钮位置[j][2];
} else {
按钮位置[j][2] = 按钮宽度;
起始左边距 = 起始左边距 + 按钮宽度;
}
按钮位置[j][3] = 字符高度;
n++;
n1++;
if (实际按钮数 - n1 == 0)
break;
if ((n >= 一行按钮数) && ((实际按钮数 - n1) - 一行按钮数 != 0)) { // 如果按钮换行
起始左边距 = 20;
起始到顶距 = 起始到顶距 + 字符高度 + 20;
if ((实际按钮数 - n1) <= 一行按钮数)
按钮宽度 = (窗口宽 - 60) / (实际按钮数 - n1);
else
按钮宽度 = (窗口宽 - 60) / 一行按钮数;
n = 0;
n2++; // 按钮行数
} else if (n >= 一行按钮数) { // 按钮数-n1)-一行按钮数==0
起始左边距 = 20;
起始到顶距 = 起始到顶距 + 字符高度 + 20;
n = 0;
n2++;
}
}
}
窗口高 = 起始到顶距 + 字符高度 + 100;
}
public static void deleteData(int pos) {
if (pos == 记录条数 - 1)
记录条数1--;
for (int i = pos; i < 记录条数 - 1; i++) {
for (int j = 0; j < 控件个数 - 1; j++) {
表格数据[i][j] = 表格数据[i + 1][j];
}
}
记录条数--;
}
}
版本2
37.源码37，部件程序，用组合框表示代码数据的单记录、表格式混合部件。
/**
* 程序文件名：tableTenance11.java
* 作者： 齐赛
* 完成时间：2013年5月19日
* 功能： 用组合框表示代码数据的单记录、表格式混合部件。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.BevelBorder;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.plaf.ButtonUI;
import javax.swing.table.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Vector;
import java.io.*;
public class tableTenance11 extends JFrame implements FocusListener
{
private static JLabel statusBar1=new JLabel("一共");
private static JLabel totalItems=new JLabel();
private static JLabel statusBar2=new JLabel("条记录");
private static JLabel statusBar3=new JLabel("当前记录是第");
private static JLabel currentItem=new JLabel();
private static JLabel statusBar4=new JLabel("条");
private static JButton firstItem=new JButton("第一条");
private static JButton nextItem=new JButton("下一条");
private static JButton previousItem=new JButton("上一条");
private static JButton endItem=new JButton("末一条");
private static JButton delete=new JButton("删除记录");
private static JTable table02;
private static JScrollPane scrollPane;
static Connection con;
static Statement sta;
static ResultSet rs;
static ResultSetMetaData rsmd;
static tableTenance11 frame=new tableTenance11();
static String variabl2603;
static String variabl1873;
static String[] variabl1525;
static int variabl2483 = 900, variabl2503 = 700;
static int variabl2651;
static int variabl2113;
static String[] variabl2517;
static String[] variabl1913;
static String[] variabl2411;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489;
static int[] variabl1119;
static int variabl1235=-1, variabl1089=-1;
static String[][] variabl2197;
static String [] variabl2405=null;
static String variabl1187;
static String variabl1153;
static String[][] variabl1377;
static String variabl1633="";
static int[] variabl1287;
static String s1 = "";
static DefaultTableModel model;
static int b = 0, c = 0;
static int[] variabl2345;
static int[] variabl1055;
static String[] variabl1607;
static int count1;
static int count2;
static int count3;
static ArrayList<Fields>fields=new ArrayList<Fields>();
static String variabl1071[][];
static String variabl1431[][];
static String variabl1221;
static int currentRow=-1;
static int currentColumn=-1;
static int variabl2851=0,variabl2339=0;
public static void means(String[] parameter){
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){}
statusBar1=new JLabel("一共");
totalItems=new JLabel();
statusBar2=new JLabel("条记录");
statusBar3=new JLabel("当前记录是第");
currentItem=new JLabel();
statusBar4=new JLabel("条");
firstItem=new JButton(variabl2405[0]);
nextItem=new JButton(variabl2405[1]);
previousItem=new JButton(variabl2405[2]);
endItem=new JButton(variabl2405[3]);
delete=new JButton(variabl2405[4]);
frame=new tableTenance11();
variabl2483 = 900; variabl2503 = 700;
variabl1235=-1; variabl1089=-1;
variabl1633=""; s1 = ""; b = 0; c = 0;
fields=new ArrayList<Fields>();
currentRow=-1;
currentColumn=-1;
variabl2603=parameter[4] ;
variabl1153=parameter[8] ;
variabl1525 = parameter[6].split(",");
variabl1221=parameter[5];
String variabl2429 = parameter[0];
if (variabl1525.length == 0)
{
JOptionPane.showMessageDialog(null, "缺少关键字的说明，请选择关键字后重新操作");
return;
}
frame.setTitle("单记录维护模型 " + variabl2603+" 作者：齐赛");
frame.setBounds(250, 50, variabl2483, variabl2503);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
scrollPane = new JScrollPane();
frame.getContentPane().add(scrollPane);
variabl1287 = new int[variabl1525.length];
variabl1055 = new int[variabl1525.length];
con = main1.getConn();
try
{
String [] s6,s7;
variabl1633="";
if (variabl1153.length()>0) {
s6=variabl1153.split(",");
s7=parameter[19].split(",");
for (int i=0;i<s6.length;i++){
if (variabl1633.length()>0)
variabl1633=variabl1633+","+s7[Integer.valueOf(s6[i])];
else variabl1633=s7[Integer.valueOf(s6[i])];
}
s1="select "+variabl1633+" from "+variabl2603;
}
else{
s7=parameter[19].split(",");
variabl1633="";
for (int k1=0;k1<s7.length;k1++)
if (k1<s7.length-1) variabl1633=variabl1633+s7[k1]+",";
else variabl1633=variabl1633+s7[k1];
s1="select * from "+variabl2603;
}
handleSQL(s1,1);
rs.last();
variabl1089 = rs.getRow();
variabl1235 = variabl1089;
if(variabl1235==0)
{
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
delete.setEnabled(false);
}
Font f=new Font("仿宋",Font.BOLD,15);
statusBar1.setBounds(5,530,50,30);
statusBar1.setFont(f);
frame.add(statusBar1);
totalItems.setBounds(55, 530, 50, 30);
totalItems.setText(String.valueOf(variabl1235));
totalItems.setForeground(Color.RED);
totalItems.setFont(f);
frame.add(totalItems);
statusBar2.setBounds(85, 530, 50, 30);
statusBar2.setFont(f);
frame.add(statusBar2);
statusBar3.setBounds(140, 530, 100, 30);
statusBar3.setFont(f);
frame.add(statusBar3);
currentItem.setBounds(245, 530, 50, 30);
currentItem.setText(String.valueOf(currentRow+1));
currentItem.setForeground(Color.RED);
currentItem.setFont(f);
frame.add(currentItem);
statusBar4.setBounds(295, 530, 50, 30);
statusBar4.setFont(f);
frame.add(statusBar4);
variabl1377 = new String[variabl1235][variabl1525.length];
variabl2651 = rsmd.getColumnCount();
variabl2517 = new String[variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++)
{
variabl2517[i] = rsmd.getColumnName(i + 1);
variabl1501[i] = rsmd.getColumnTypeName(i + 1);
variabl1489[i] = rsmd.getColumnDisplaySize(i + 1);
if (variabl1489[i] < variabl2517[i].length())
variabl1489[i] = variabl2517[i].length();
else if (variabl1489[i] > 50)
variabl1489[i] = 50;
for (int j = 0; j < variabl1525.length; j++)
{
if (variabl1525[j].trim().equals(variabl2517[i].trim()))
{
variabl1287[j] = i;
if (variabl1153.length() <= 0)
variabl1153 += (i + 1);
else
variabl1153 = variabl1153 + "," + (i + 1);
break;
}
}
}
variabl1153 = "," + variabl1153 + ",";
variabl2345 = new int[variabl2651];
variabl2113=variabl2651;
variabl1607 = new String[variabl2113];
variabl2411 = new String[variabl2113];
variabl1913 = new String[variabl2113];
variabl1169 = new String[variabl2113];
variabl1119 = new int[variabl2113];
variabl2197 = new String[variabl1089][variabl2113];
b = 0;
while (b < variabl2113)
{
variabl1913[b] = variabl2517[b];
variabl1169[b] = variabl1501[b];
variabl1119[b] = variabl1489[b];
variabl2411[b] = variabl2517[b];
variabl2345[b] = b;
b++;
}
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1089)
{
rs.absolute(c + 1);
while (b < variabl2113)
{
variabl2197[c][b] = rs.getString(variabl2345[b] + 1);
for (int i = 0; i < variabl1287.length; i++)
{
if (variabl1287[i] == variabl2345[b])
{
variabl1055[i] = b;
variabl1377[c][i] = variabl2197[c][b];
break;
}
}
b++;
}
c++;
b = 0;
}
} catch (Exception e)
{
e.printStackTrace();
} finally
{
closeSQL();
}
variabl1873="";
String []t1;
int b=0,c=0;
if (variabl2429.lastIndexOf(variabl2603+"字典表")>=0){
t1=variabl2429.split(",");
for (int i=0;i<t1.length;i++)
if (t1[i].lastIndexOf(variabl2603+"字典表")>=0) variabl1873=t1[i];
}
if (variabl1873.length() > 0)
{
con = main1.getConn();
s1 = "select * from " + variabl1873;
handleSQL(s1,1);
try
{
while (rs.next())
{
String variabl2153 = rs.getString(1);
String variabl1755 = rs.getString(2);
b = 0;
while (b < variabl2113)
{
if (variabl2411[b].compareTo(variabl2153.trim()) == 0)
{
variabl2411[b] = variabl1755.trim();
}
else variabl2411[b] = variabl1913[b];
b++;
}
}
} catch (Exception e1)
{
e1.printStackTrace();
} finally
{
closeSQL();
}
}
model = new DefaultTableModel(variabl2197, variabl2411);
table02 = new JTable(model);
table02.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table02.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
table02.addMouseListener(new MouseAdapter()
{
public void mouseClicked(final MouseEvent e)
{
currentRow = table02.getSelectedRow();
currentItem.setText(String.valueOf(currentRow+1));
if(currentRow==0)
{
if(currentRow==variabl1235-1)
{
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
}else
{
firstItem.setEnabled(false);
previousItem.setEnabled(false);
nextItem.setEnabled(true);
endItem.setEnabled(true);
}
}else
{
if(currentRow==variabl1235-1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}else
{
nextItem.setEnabled(true);
endItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
}
currentColumn=table02.getSelectedColumn();
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
}
});
for (int i = 0; i < variabl2113; i++)
{
TableColumn tc = table02.getColumn(variabl2411[i]);
for(int j=0;j<variabl1055.length;j++)
{
if(i==variabl1055[j])
{
DefaultTableCellRenderer cellRender=new DefaultTableCellRenderer();
cellRender.setBackground(Color.ORANGE);
tc.setCellRenderer(cellRender);
}
}
JTableHeader header = table02.getTableHeader();
tc.setPreferredWidth(variabl1119[i] * 8);
tc.setMaxWidth(variabl1119[i] * 8);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table02);
variabl2339=(variabl2483-60)/variabl2851;
int variabl2337=30;
firstItem.setBounds(variabl2337,500,variabl2339,30);
if (variabl1187.indexOf(",0,")>=0) {
variabl2337=variabl2337+variabl2339;
frame.add(firstItem);
}
firstItem.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent arg0)
{
currentRow=0;
table02.setRowSelectionInterval(currentRow, currentRow);
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));
currentItem.setText(String.valueOf(currentRow+1));
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if(currentRow==variabl1235-1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
}else
{
nextItem.setEnabled(true);
endItem.setEnabled(true);
}
}
});
nextItem.setBounds(variabl2337,500,variabl2339,30);
if (variabl1187.indexOf(",0,")>=0) {
variabl2337=variabl2337+variabl2339;
frame.add(nextItem);
}
nextItem.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if(currentRow==-1)
{
currentRow=0;
table02.setRowSelectionInterval(currentRow, currentRow);
currentItem.setText(String.valueOf(currentRow+1));
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if(currentRow==variabl1235-1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
}
}else if(currentRow+1==variabl1235-1)
{
currentRow++;
endItem.setEnabled(false);
nextItem.setEnabled(false);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}else
{
currentRow++;
endItem.setEnabled(true);
nextItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
table02.setRowSelectionInterval(currentRow, currentRow);
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));
currentItem.setText(String.valueOf(currentRow+1));
}
});
previousItem.setBounds(variabl2337,500,variabl2339,30);
if (variabl1187.indexOf(",0,")>=0) {
variabl2337=variabl2337+variabl2339;
frame.add(previousItem);
}
previousItem.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent arg0)
{
if(currentRow==-1)
{
currentRow=0;
table02.setRowSelectionInterval(currentRow, currentRow);
currentItem.setText(String.valueOf(currentRow+1));
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
firstItem.setEnabled(false);
previousItem.setEnabled(false);
if(currentRow==variabl1235-1)
{
nextItem.setEnabled(false);
endItem.setEnabled(false);
}
}else if(currentRow-1==0)
{
currentRow--;
firstItem.setEnabled(false);
previousItem.setEnabled(false);
nextItem.setEnabled(true);
endItem.setEnabled(true);
}else
{
currentRow--;
endItem.setEnabled(true);
nextItem.setEnabled(true);
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
table02.setRowSelectionInterval(currentRow, currentRow);
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));
currentItem.setText(String.valueOf(currentRow+1));
}
});
endItem.setBounds(variabl2337,500,variabl2339,30);
if (variabl1187.indexOf(",0,")>=0) {
variabl2337=variabl2337+variabl2339;
frame.add(endItem);
}
endItem.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
currentRow=variabl1235-1;
table02.setRowSelectionInterval(currentRow, currentRow);
currentItem.setText(String.valueOf(currentRow+1));
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));
endItem.setEnabled(false);
nextItem.setEnabled(false);
if(currentRow==0)
{
firstItem.setEnabled(false);
previousItem.setEnabled(false);
}else
{
firstItem.setEnabled(true);
previousItem.setEnabled(true);
}
}
});
delete.setBounds(variabl2337,500,variabl2339,30);
if (variabl1187.indexOf(",0,")>=0) {
variabl2337=variabl2337+variabl2339;
frame.add(delete);
}
delete.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if(currentRow==-1)
{
JOptionPane.showMessageDialog(null,"请先选择一条记录！");
return;
}else
{
int response=JOptionPane.showConfirmDialog(null, "是否真的要删除此条记录？", "请选择", JOptionPane.CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE);
if(response==0)
{
s1="delete from "+variabl2603+" where ";
int p=0;
for(int i=0;i<fields.size();i++)
{
Fields field=fields.get(i);
if(field.variabl1447)
{
s1+=field.variabl1533+"="+field.getFormatText();
p++;
if(p<variabl1525.length)
{
s1+=" AND ";
}
}
}
int status=handleSQL(s1,4);
closeSQL();
if(status==0)
{
JOptionPane.showMessageDialog(null, "此条记录不存在！");
return;
}else
{
JOptionPane.showMessageDialog(null, "删除成功！");
updateTable();
totalItems.setText(String.valueOf(variabl1235));
if(variabl1235==0)
{
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
delete.setEnabled(false);
currentRow=-1;
}else if(variabl1235==1)
{
firstItem.setEnabled(false);
nextItem.setEnabled(false);
previousItem.setEnabled(false);
endItem.setEnabled(false);
delete.setEnabled(true);
currentRow=0;
table02.setRowSelectionInterval(currentRow, currentRow);
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));
currentItem.setText(String.valueOf(currentRow+1));
}else
{
if(currentRow==variabl1235)
{
currentRow--;
table02.setRowSelectionInterval(currentRow, currentRow);
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));
currentItem.setText(String.valueOf(currentRow+1));
firstItem.setEnabled(true);
nextItem.setEnabled(false);
previousItem.setEnabled(true);
endItem.setEnabled(false);
}else
{
table02.setRowSelectionInterval(currentRow, currentRow);
for(int i=0;i<fields.size();i++)
{
fields.get(i).setText((String)table02.getValueAt(currentRow, i
));
}
table02.scrollRectToVisible(table02.getCellRect(currentRow, 0, true));
currentItem.setText(String.valueOf(currentRow+1));
firstItem.setEnabled(true);
nextItem.setEnabled(true);
previousItem.setEnabled(true);
endItem.setEnabled(true);
}
}
}
}else
{
return;
}
}
}
});
JButton nextItem1=new JButton(variabl2405[5]);
nextItem1.setBounds(variabl2337,500,variabl2339,30);
if (variabl1187.indexOf(",0,")>=0) {
variabl2337=variabl2337+variabl2339;
frame.add(nextItem1);
}
nextItem1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Vector<String> v=new Vector<String>(variabl2113);
for(int i=0;i<fields.size();i++)
{
v.add(fields.get(i).getText());
}
model.addRow(v);
table02.repaint();
s1="insert into "+variabl2603+" ("+variabl1633+") values (";
String s2="",s3="";
for(int j=0;j<fields.size();j++){
s3=fields.get(j).getText();
if(main1.variabl1545.trim().indexOf(","+variabl1501[j]+",")>=0){
if ((s3.trim().length()<1)||(s3==null)) s3="0";
s2=s2+s3.trim();
}
else {
s2=s2+"'"+fields.get(j).getText()+"'";
}
if(j<fields.size()-1)
s2=s2+",";
}
s1=s1+s2+")";
try {
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能录入，可能是数据出错，请检查！");
return;
}
int k5=Integer.parseInt(totalItems.getText());
variabl1235=k5+1;
totalItems.setText((k5+1)+"");
currentItem.setText((k5+1)+"");
}
});
JButton nextItem2=new JButton(variabl2405[6]);
nextItem2.setBounds(variabl2337,500,variabl2339,30);
if (variabl1187.indexOf(",0,")>=0) {
variabl2337=variabl2337+variabl2339;
frame.add(nextItem2);
}
nextItem2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Vector<String> v=new Vector<String>(variabl2113);
int m0=table02.getSelectedRow();
for(int i=0;i<fields.size();i++)
{
v.add(fields.get(i).getText());
}
model.removeRow(m0);
model.addRow(v);
table02.repaint();
currentItem.setText(String.valueOf(currentRow+1));
s1="update "+variabl2603+" set ";
String s2="",s3="",s4="";
int k3=0;
for(int j=0;j<fields.size();j++){
s3=fields.get(j).getText();
k3=0;
for (int k2=0;k2<variabl1055.length;k2++)
if (variabl1055[k2]==j){
s4=s4+variabl1913[j]+"=";
if(main1.variabl1545.trim().indexOf(","+variabl1501[j]+",")>=0)
s4=s4+s3.trim();
else
s4=s4+"'"+s3.trim()+"'";
if (k2<variabl1055.length-1)
s4=s4+" and ";
k3=1;
}
if (k3==0){
if(main1.variabl1545.trim().indexOf(","+variabl1501[j]+",")>=0){
if ((s3.trim().length()<1)||(s3==null)) s3="0";
s2=s2+variabl1913[j]+"="+s3.trim();
}
else {
s2=s2+variabl1913[j]+"='"+fields.get(j).getText()+"'";
}
if(j<fields.size()-1)
s2=s2+",";
}
}
s1=s1+s2+" where "+s4;
try {
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能录入，可能是数据出错，请检查！");
return;
}
}
});
JButton nextItem3=new JButton(variabl2405[7]);
nextItem3.setBounds(variabl2337,500,variabl2339,30);
if (variabl1187.indexOf(",0,")>=0) {
variabl2337=variabl2337+variabl2339;
frame.add(nextItem3);
}
nextItem3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
});
if(variabl1221.length()>0)
{
con = main1.getConn();
s1 = "select * from " + variabl1221;
handleSQL(s1,1);
try
{
rs.last();
int rows=rs.getRow();
rs.absolute(1);
int columns=rsmd.getColumnCount();
variabl1071=new String[rows][columns];
int i=0;
while (i<rows)
{
for(int j=0;j<columns;j++)
{
variabl1071[i][j]=rs.getString(j+1);
}
i++;
rs.next();
}
} catch (Exception e1)
{
e1.printStackTrace();
} finally
{
closeSQL();
}
}
for(int i=0;i<variabl2411.length;i++)
{
boolean variabl1267=false;
boolean key=false;
boolean code=false;
if(variabl2429.lastIndexOf(variabl2411[i]+"代码表")>=0)
{
code=true;
}
if(variabl1221.length()>0)
for(int k=0;k<variabl1071.length;k++)
{
if(variabl2411[i].trim().equals(variabl1071[k][1].trim()))
{
variabl1267=true;
break;
}
}
for(int k=0;k<variabl1055.length;k++)
{
if((i)==variabl1055[k])
{
key=true;
break;
}
}
Fields f=frame.new Fields(i, variabl1169[i], variabl2411[i], variabl1913[i], variabl1119[i], variabl1267, key,code);
fields.add(f);
}
JPanel fieldsJp=new JPanel();
FlowLayout fl=new FlowLayout();
fl.setAlignment(FlowLayout.LEFT);
fl.setHgap(10);
fl.setVgap(10);
fieldsJp.setLayout(fl);
fieldsJp.setPreferredSize(new Dimension(variabl2483-45,variabl2503));
ArrayList<Integer> longField=new ArrayList<Integer>();
for(int i=0;i<fields.size();i++)
{
if(fields.get(i).jta !=null)
{
longField.add(i);
continue;
}
fieldsJp.add(fields.get(i));
}
for(int i=0;i<longField.size();i++)
{
fieldsJp.add(fields.get(longField.get(i)));
}
fieldsJp.setBackground(Color.GRAY);
JScrollPane fieldsJSPane=new JScrollPane(fieldsJp);
JSplitPane splitPane=new JSplitPane(JSplitPane.VERTICAL_SPLIT,scrollPane,fieldsJSPane);
splitPane.setBounds(0,0,variabl2483-15,500);
splitPane.setDividerLocation(150);
splitPane.setOneTouchExpandable(true);
fieldsJSPane.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(Color.BLACK),"字段信息"));
fieldsJSPane.getVerticalScrollBar().setUnitIncrement(15);
frame.getContentPane().add(splitPane);
frame.setVisible(true);
}
/**
* 1.遍历表格字段，及其在数据表中的序号，拿到它的标题，数据类型，数据宽度，是否有参数表，构造panel；
2.panel的属性：组合框，文本框，文本域，标签，标题，字段名，是否为主键；
主要方法有面板总长度、面板宽度、面板长度、是否是XX组件、
*/
class Fields extends JPanel implements Comparable<Fields>
{
JComboBox jco;
JTextField jtf;
JTextArea jta;
JLabel jlb;
String variabl2501;
String variabl1533;
int variabl1667;
boolean variabl1447;
boolean variabl1267;
boolean code;
String variabl1815;
public Fields(int variabl1667,String fieldType,String name,String actualName,int dataWidth,boolean referenceTable,boolean isKey,boolean codeTable)
{
this.variabl1447=isKey;
this.variabl1667=variabl1667;
this.variabl2501=name;
this.variabl1533=actualName;
this.variabl1815=fieldType;
this.variabl1267=referenceTable;
this.code=codeTable;
if(dataWidth<60 && !codeTable)
{
jtf=new JTextField();
jtf.addFocusListener(tableTenance11.this);
jlb=new JLabel(name);
jlb.setFont(new Font("仿宋",Font.BOLD,18));
if(isKey)
{
jlb.setForeground(Color.RED);
}
jtf.setPreferredSize(new Dimension(dataWidth*8,25));
this.add(jlb);
this.add(jtf);
}else if(!codeTable)
{
jta=new JTextArea();
jta.addFocusListener(tableTenance11.this);
jlb=new JLabel(name);
jlb.setFont(new Font("仿宋",Font.BOLD,18));
if(isKey)
{
jlb.setForeground(Color.RED);
}
jta.setLineWrap(true);
JScrollPane jsp=new JScrollPane(jta);
jsp.setPreferredSize(new Dimension(200,80));
this.add(jlb);
this.add(jsp);
}else
{
jco=new JComboBox();
jco.addFocusListener(tableTenance11.this);
jlb=new JLabel(name);
jlb.setFont(new Font("仿宋",Font.BOLD,18));
if(isKey)
{
jlb.setForeground(Color.RED);
}
jco.setPreferredSize(new Dimension(dataWidth*10+20,25));
jco.setBackground(Color.WHITE);
con = main1.getConn();
s1 = "select * from " + name+"代码表";
handleSQL(s1,1);
try
{
rs.last();
int rows=rs.getRow();
rs.absolute(1);
int columns=rsmd.getColumnCount();
variabl1431=new String[rows][columns];
int i=0;
while (i<rows)
{
jco.addItem(rs.getString(1));
i++;
rs.next();
}
} catch (Exception e1)
{
e1.printStackTrace();
} finally
{
closeSQL();
}
this.add(jlb);
this.add(jco);
this.setBorder(BorderFactory.createLineBorder(Color.GRAY));
}
}
public int compareTo(Fields f)
{
return this.variabl1667-this.variabl1667;
}
public String getFormatText()
{
String text="";
if(main1.variabl1545.trim().indexOf(this.variabl1815.trim())>=0)
{
text=this.getText();
if(text.isEmpty())
{
text="0";
}
}else
{
text="'"+this.getText()+"'";
}
return text;
}
public String getText()
{
if(this.jco!=null)
{
return (String)jco.getSelectedItem();
}else if(this.jta!=null)
{
return this.jta.getText();
}else
{
return this.jtf.getText();
}
}
public void setText(String text)
{
if(this.jco!=null)
{
if (text==null) return;
for(int i=0;i<jco.getItemCount();i++)
{
String str=(String)jco.getItemAt(i);
if (str.trim().equals(text.trim()))
{
jco.setSelectedIndex(i);
}
}
}else if(this.jta!=null)
{
this.jta.setText(text);
}else
{
this.jtf.setText(text);
}
}
public Component getComponent()
{
if(this.jco!=null)
{
return this.jco;
}else if(this.jta!=null)
{
return this.jta;
}else
{
return this.jtf;
}
}
}
public void focusGained(FocusEvent e)
{
Component c=(Component)e.getSource();
c.setBackground(Color.CYAN);
}
public void focusLost(FocusEvent e)
{
Component c=(Component)e.getSource();
c.setBackground(Color.WHITE);
}
/**
* @param dml DML语句
* @param type 1表示查询，2表示添加，3表示修改，4表示删除
*/
static public int handleSQL(String dml,int type)
{
int status=0;
try
{
con=main1.getConn();
sta=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
switch (type)
{
case 1:
{
rs=sta.executeQuery(dml);
rsmd=rs.getMetaData();
break;
}
case 2:
{
sta.executeUpdate(dml);
JOptionPane.showMessageDialog(null, "数据添加成功！");
break;
}
case 3:
{
sta.executeUpdate(dml);
JOptionPane.showMessageDialog(null, "数据修改成功！");
break;
}
case 4:
{
status=sta.executeUpdate(dml);
break;
}
}
} catch (SQLException e)
{
JOptionPane.showMessageDialog(null, "数据库出错！");
closeSQL();
e.printStackTrace();
}
return status;
}
/**
* 断开数据库的链接
*/
static void closeSQL()
{
try
{
if(rs!=null)
{
rs.close();
rs=null;
}
if(sta!=null)
{
sta.close();
sta=null;
}
if(con!=null)
{
con.close();
con=null;
}
}catch(SQLException sqle1)
{
sqle1.printStackTrace();
}
}
/**
* 当添加数据之后，之前保存的数据要重新更新，以便再次添加数据
*/
public static void updateTable()
{
con = main1.getConn();
s1 = "select * from " + variabl2603;
handleSQL(s1,1);
try
{
rs.last();
variabl1089 = rs.getRow();
variabl1235 = variabl1089;
variabl2197 = new String[variabl1089][variabl2113];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1089)
{
rs.absolute(c + 1);
while (b < variabl2113)
{
variabl2197[c][b] = rs.getString(variabl2345[b] + 1);
for (int i = 0; i < variabl1287.length; i++)
{
if (variabl1287[i] == variabl2345[b])
{
variabl1055[i] = b;
variabl1377[c][i] = variabl2197[c][b];
break;
}
}
b++;
}
c++;
b = 0;
}
} catch (Exception e)
{
e.printStackTrace();
} finally
{
closeSQL();
}
model.setDataVector(variabl2197, variabl2411);
table02.setModel(model);
table02.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table02.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2113; i++)
{
TableColumn tc = table02.getColumn(variabl2411[i]);
for(int j=0;j<variabl1055.length;j++)
{
if(i==variabl1055[j])
{
DefaultTableCellRenderer cellRender=new DefaultTableCellRenderer();
cellRender.setBackground(Color.ORANGE);
tc.setCellRenderer(cellRender);
}
}
JTableHeader header = table02.getTableHeader();
tc.setPreferredWidth(variabl1119[i] * 8);
tc.setMaxWidth(variabl1119[i] * 8);
tc.sizeWidthToFit();
}
scrollPane.setViewportView(table02);
table02.repaint();
}
/**
* 此方法在前端检查记录的关键字是否在数据库中已经存在
* @param array要添加的数据
* @return 返回值若为真，表示有重复关键字，否则无
*/
public static boolean keyJudge(String[] array)
{
boolean flag = false;
for (int i = 0; i < variabl1377.length; i++)
{
int j = 0;
for (; j < variabl1525.length; j++)
{
if ( ! variabl1377[i][j].trim().equals(array[variabl1055[j]].trim()))
break;
}
if (j == variabl1525.length)
{
flag = true;
break;
} else if (i == variabl1377.length - 1)
{
String temp[][] = variabl1377;
variabl1377 = new String[variabl1377.length + 1][variabl1525.length];
for (int i1 = 0; i1 < temp.length; i1++)
for (int j1 = 0; j1 < temp[0].length; j1++)
variabl1377[i1][j1] = temp[i1][j1];
for (int i2 = 0; i2 < variabl1525.length; i2++)
variabl1377[variabl1377.length - 1][i2] = array[variabl1055[i2]];
return false;
}
}
return flag;
}
}
38.源码38，部件程序，可选表名的表格式数据维护程序。
/*
* 程序文件名：tableTenance12.java
* 作者：程学先
* 程序功能：可选表名的表格式数据维护程序。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.table.*;
import java.sql.*;
import java.util.*;
import java.util.List;
public class tableTenance12 extends JFrame
{
static tableTenance12 frame = new tableTenance12();
private static List<JLabel> list1 = new ArrayList<JLabel>();
private static List<JTextField> list2 = new ArrayList<JTextField>();
public static JTable table;
private static JButton variabl2641;
private static JButton variabl2683;
private static JButton variabl2633;
private static JButton variabl2599;
static Connection con;
static ResultSet rs;
static Statement sta3;
static String variabl2603;
static String s1,s2,s3;
static int variabl2651 ;
static String[] variabl2517;
static String[] variabl1501;
static int[] variabl1489;
static int variabl1853;
static Object[][] variabl2197;
static DefaultTableModel model;
static int variabl2483, variabl2503;
static String[] variabl1919;
static String variabl1175="";
static String [] variabl2405=null;
static String variabl1187;
static int variabl2851=0,variabl2339=0;
static String[] variabl1525;
static int [] variabl1287;
static String [] variabl1377;
public static void means(String[] parameter){
frame = new tableTenance12();
list1 = new ArrayList<JLabel>();
list2 = new ArrayList<JTextField>();
String[] variabl2429 = parameter[0].split(",");
String [] variabl240501={"添加","修改","删除","退出"};
variabl2405=new String[variabl240501.length];
variabl2851=0;
variabl1175 = "";
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){}
frame.setTitle("可随机选择数据表的表格数据维护程序 作者：程学先");
frame.setBounds(10, 10, variabl2483, variabl2503);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
variabl1525=null;
variabl1287=null;
variabl1377=null;
final JPanel panel = new JPanel(false);
panel.setLayout(null);
panel.setBounds(10, 10,variabl2483,variabl2503);
final JScrollPane scrollPane = new JScrollPane();
JLabel l0 = new JLabel("请选择数据表");
l0.setBounds(840,10,120,20);
panel.add(l0);
final java.awt.List list0 = new java.awt.List();
for (int i=0;i<variabl2429.length;i++)
list0.add(variabl2429[i]);
list0.setBounds(840, 40,120,150);
list0.setMultipleMode(false);
panel.add(list0);
JLabel l1 = new JLabel("请选择关键字");
l1.setBounds(840,200,120,20);
panel.add(l1);
final java.awt.List listl0 = new java.awt.List();
listl0.setBounds(840,230,120,200);
listl0.setMultipleMode(true);
panel.add(listl0);
list0.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
variabl2603=list0.getSelectedItem();
try{
main1.driver1();
con=main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl2603;
rs = sta3.executeQuery(s1);
rs.last();
variabl1853=rs.getRow();
ResultSetMetaData rsmd = rs.getMetaData();
variabl2651 = rsmd.getColumnCount();
variabl2517 = new String[variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
variabl1919=new String[variabl2651];
for (int i=0;i<variabl2651;i++) {
variabl2517[i] = rsmd.getColumnName(i + 1);
variabl1501[i] = rsmd.getColumnTypeName(i+1);
variabl1489[i] = rsmd.getColumnDisplaySize(i+1);
if (variabl1489[i] < variabl2517[i].length())
variabl1489[i] = variabl2517[i].length();
else if (variabl1489[i] > 50)
variabl1489[i] = 50;
variabl1919[i]="";
}
variabl2197=new String[variabl1853][variabl2651];
rs.absolute(1);
int c=0;
int b=0;
while(c<variabl1853) {
rs.absolute(c+1);
while(b<variabl2651){
variabl2197[c][b]=rs.getString(b+1);
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch (SQLException e1){
JOptionPane.showMessageDialog( null, "获取数据结构出错！");
}
for (int i=0;i<variabl2651;i++)
listl0.add(variabl2517[i]);
listl0.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
variabl1525=listl0.getSelectedItems();
variabl1287=new int[variabl1525.length];
for (int i=0;i<variabl2517.length;i++){
for (int j=0;j<variabl1287.length;j++){
if (variabl2517[i].equals(variabl1525[j]))
variabl1287[j]=i;
}
}
}
});
model = new DefaultTableModel(variabl2197, variabl2517);
model.addRow(variabl1919);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2651; i++)
{
TableColumn tc = table.getColumn(variabl2517[i]);
JTableHeader header = table.getTableHeader();
tc.setPreferredWidth(variabl1489[i] * 9);
tc.setMaxWidth(variabl1489[i] * 9);
tc.sizeWidthToFit();
}
scrollPane.setBounds(0,0,variabl2483-220,variabl2503-220);
scrollPane.setViewportView(table);
panel.add(scrollPane);
table.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent evt) {
variabl1175 = variabl1175 + evt.getKeyChar();
}
});
table.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
int selectedRow = table.getSelectedRow();
int variabl2593 = table.getSelectedRow();
int variabl2547 = table.getSelectedColumn();
int k=0;
if (variabl1525==null) {
JOptionPane.showMessageDialog(null, "请选择关键字！");
return;
}
for (int i = 0; i < variabl1525.length; i++) {
if (variabl1287[i] == variabl2547 ) k=1;
}
if (k==0) {
model.setValueAt("", variabl2593, variabl2547);
}
variabl1175 = "";
}
});
table.addFocusListener(new FocusAdapter() {
public void focusLost(final FocusEvent arg0) {
int variabl2593 = table.getSelectedRow();
int variabl2547 = table.getSelectedColumn();
if (variabl1175.trim().length()>0){
if (variabl1175.indexOf(" ")>=0)
variabl1175=variabl1175.substring(variabl1175.lastIndexOf(" ")+1,variabl1175.length());
model.setValueAt(variabl1175, variabl2593, variabl2547);
}
}
});
}
});
variabl2339=(variabl2483-460)/variabl2851;
int variabl2337=420;
variabl2641 = new JButton();
variabl2641.setText(variabl2405[0]);
variabl2641.setBounds(variabl2337,500,variabl2339,20);
if (variabl1187.indexOf(",0,")>=0) {
variabl2337=variabl2337+variabl2339;
panel.add(variabl2641);
}
variabl2641.addActionListener(new ActionListener()
{
public void actionPerformed( ActionEvent e)
{
int m0=table.getSelectedRow();
variabl1377=new String[variabl1525.length];
s1 = "";
for (int i = 0; i < variabl1525.length; i++) {
variabl1377[i] = model.getValueAt(m0, variabl1287[i])
.toString();
if (variabl1377[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.variabl1545.lastIndexOf(variabl1501[variabl1287[i]]) > 0)
s1 = s1 + variabl1525[i] + "=" + variabl1377[i];
else
s1 = s1 + variabl1525[i] + "='" + variabl1377[i] + "' ";
if (i < variabl1525.length - 1)
s1 = s1 + " and ";
}
int j1 = 0;
for (int j=0;j<model.getRowCount()-1;j++){
for (int i = 0; i < variabl1525.length; i++){
if (variabl1377[i].trim().equals(model.getValueAt(j, variabl1287[i]).toString().trim()))
j1++;
if (j1==variabl1525.length) {
JOptionPane.showMessageDialog(null, "关键字数据重复，请检查！");
return;
}
}
j1=0;
}
s1="";
s2="";
for(int j=0;j<variabl2651;j++){
s1=s1+variabl2517[j];
if (j<variabl2651-1) s1=s1+",";
s3 = model.getValueAt(m0, j) == null ? "" : model
.getValueAt(m0, j).toString();
if(main1.variabl1545.trim().indexOf(","+variabl1501[j]+",")>=0){
if (s3.trim().length()<1) s3="0";
s2=s2+s3.trim();
}
else {
s2=s2+"'"+s3.trim()+"'";
}
if(j<variabl2651-1)
s2=s2+",";
}
s1="insert into "+variabl2603+"("+s1+")"+" values ("+s2+")";
try {
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能录入，可能是数据出错，请检查！");
return;
}
model.addRow(variabl1919);
}
});
variabl2683 = new JButton();
variabl2683.setText(variabl2405[1]);
variabl2683.setBounds(variabl2337,500,variabl2339,20);
if (variabl1187.indexOf(",1,")>=0) {
variabl2337=variabl2337+variabl2339;
panel.add(variabl2683);
}
variabl2683.addActionListener(new ActionListener()
{
public void actionPerformed( ActionEvent e)
{
s1 = "";
int j1 = 0;
int m0=table.getSelectedRow();
variabl1377=new String[variabl1525.length];
for (int i = 0; i < variabl1525.length; i++) {
variabl1377[i] = model.getValueAt(m0, variabl1287[i]).toString();
if (variabl1377[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.variabl1545.lastIndexOf(variabl1501[variabl1287[i]]) > 0)
s1 = s1 + variabl1525[i] + "=" + variabl1377[i];
else
s1 = s1 + variabl1525[i] + "='" + variabl1377[i] + "' ";
if (i < variabl1525.length - 1)
s1 = s1 + " and ";
}
try{
String str1="";
for(int j=0;j<variabl2651;j++){
if(main1.variabl1545.trim().indexOf(","+variabl1501[j]+",")>=0)
if (table.getValueAt(m0, j)==null)
str1=str1+variabl2517[j]+"=0";
else str1=str1+variabl2517[j]+"="+
table.getValueAt(m0, j).toString().trim();
else
if (table.getValueAt(m0, j)==null)
str1=str1+variabl2517[j]+"=' '";
else str1=str1+variabl2517[j]+"='"+
table.getValueAt(m0, j).toString().trim()+"'";
if(j<variabl2651-1)
str1=str1+",";
}
s1=" update "+variabl2603+" set "+str1+" where "+s1;
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能修改成功，可能是数据出错，请检查！");
return;
}
}
});
variabl2633 = new JButton();
variabl2633.setText(variabl2405[2]);
variabl2633.setBounds(variabl2337,500,variabl2339,20);
if (variabl1187.indexOf(",2,")>=0) {
variabl2337=variabl2337+variabl2339;
panel.add(variabl2633);
}
variabl2633.addActionListener(new ActionListener(){
public void actionPerformed( ActionEvent e){
s1 = "";
int j1 = 0;
int m0=table.getSelectedRow();
variabl1377=new String[variabl1525.length];
for (int i = 0; i < variabl1525.length; i++) {
variabl1377[i] = model.getValueAt(m0, variabl1287[i]).toString();
if (variabl1377[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.variabl1545.lastIndexOf(variabl1501[variabl1287[i]]) > 0)
s1 = s1 + variabl1525[i] + "=" + variabl1377[i];
else
s1 = s1 + variabl1525[i] + "='" + variabl1377[i] + "' ";
if (i < variabl1525.length - 1)
s1 = s1 + " and ";
}
try {
s1="delete from "+variabl2603+" where "+s1;
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能删除成功，可能是数据出错，请检查！");
return;
}
model.removeRow(table.getSelectedRow());
}
});
variabl2599 = new JButton(variabl2405[3]);
variabl2599.setBounds(variabl2337,500,variabl2339,20);
if (variabl1187.indexOf(",3,")>=0) {
variabl2337=variabl2337+variabl2339;
panel.add(variabl2599);
}
variabl2599.addActionListener(new ActionListener()
{
public void actionPerformed(final ActionEvent e)
{
frame.setVisible(false);
frame.dispose();
}
});
variabl2599.setText("退出");
frame.add(panel);
frame.setVisible(true);
}
}
39.源码39，部件程序，可随机选择表名、可变更标签、应用列表框提供代码帮助、有完整性控制的表格式数据维护程序。
/*
* 程序文件名：tableTenance13.java
* 作者：程学先
* 完成时间：2018年5月29日
* 程序功能：可随机选择表名、可变更标签的表格式数据维护程序。
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.EmptyBorder;
import javax.swing.border.LineBorder;
import javax.swing.table.*;
import java.sql.*;
import java.util.*;
import java.util.List;
public class tableTenance13 extends JFrame implements ItemListener
{
static tableTenance13 frame = new tableTenance13();
public static JPanel panel = new JPanel(false);
public static JTable table;
private static JButton variabl2641;
private static JButton variabl2683;
private static JButton variabl2633;
private static JButton variabl2599;
private static java.awt.List list0,listl0,listr0 ;
static Connection con;
static ResultSet rs;
static Statement sta3;
static String variabl2603,variabl1873;
static String variabl2429 ;
static String [] variabl1633 ;
static String s1,s2,s3;
static int variabl2651 ;
static String[][] variabl2517;
static String[] variabl1501;
static int[] variabl1489;
static int variabl1853;
static Object[][] variabl2197;
static DefaultTableModel model;
static int variabl2483, variabl2503;
static String[] variabl1919;
static String variabl1175="";
static String [] variabl2405=null;
static String variabl1187;
static int variabl2851=0,variabl2339=0;
static String[] variabl1525;
static int [] variabl1287;
static String [] variabl1377;
static JComboBox jcb=new JComboBox();
static String variabl1071[][];
static String variabl1431[][];
static String variabl1221;
static String username="";
static String variabl1401;
static String variabl2309="";
static Set <String> hs=null;
public static void means(String[] parameter){
username=main1.username;
variabl1401=main1.variabl1401;
frame = new tableTenance13();
variabl2483=main1.variabl2483;variabl2503=main1.variabl2503;
hs=new HashSet();
variabl2429 = parameter[0];
String [] variabl240501={"添加","修改","删除","退出"};
variabl2405=new String[variabl240501.length];
variabl2851=0;
variabl1175 = "";
variabl1525=null;
variabl1287=null;
variabl1377=null;
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+",";
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){}
frame.setTitle("随机选择数据表进行维护程序 作者：程学先");
frame.setBounds(10, 10, variabl2483, variabl2503);
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame.setLayout(null);
panel = new JPanel(false);
panel.setLayout(null);
panel.setBounds(10, 10,variabl2483,variabl2503);
final JScrollPane scrollPane = new JScrollPane();
JLabel jl0 = new JLabel("请选择数据表");
jl0.setForeground(Color.RED);
jl0.setBounds(10,10,120,20);
panel.add(jl0);
jcb=new JComboBox();
jcb.setBounds(10,40,120,25);
jcb.setBackground(Color.WHITE);
panel.add(jcb);
String [] s4=variabl2429.split(",");
for (int i=0;i<s4.length;i++)
jcb.addItem(s4[i]);
JLabel l0 = new JLabel("请选择关键字");
l0.setForeground(Color.RED);
l0.setBounds(10,90,120,20);
panel.add(l0);
list0 = new java.awt.List();
list0.setBounds(10,120,120,150);
list0.setMultipleMode(true);
JLabel l1 = new JLabel("请选择显示列");
l1.setBounds(10,280,120,20);
panel.add(l1);
listl0 = new java.awt.List();
listl0.setBounds(10,310,120,200);
listl0.setMultipleMode(true);
panel.add(list0);
panel.add(listl0);
jcb.addItemListener(frame);
listr0 = new java.awt.List();
listr0.setBounds(variabl2483-140,10,100,variabl2503-200);
listr0.setMultipleMode(true);
panel.add(listr0);
listr0.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
int variabl2593 = table.getSelectedRow();
int variabl2547 = table.getSelectedColumn();
model.setValueAt(listr0.getSelectedItem(), variabl2593, variabl2547);
}
});
variabl2339=(variabl2483-450)/variabl2851;
int variabl2337=420;
variabl2641 = new JButton();
variabl2641.setText(variabl2405[0]);
variabl2641.setBounds(variabl2337,560,variabl2339,20);
if (variabl1187.indexOf(",0,")>=0) {
variabl2337=variabl2337+variabl2339;
panel.add(variabl2641);
}
variabl2641.addActionListener(new ActionListener()
{
public void actionPerformed( ActionEvent e)
{
int m0=0,m1=0,m2=0;
m0=table.getSelectedRow();
m2=table.getSelectedColumn();
variabl1377=new String[variabl1525.length];
s1 = "";
for (int i = 0; i < variabl1525.length; i++) {
variabl1377[i] = model.getValueAt(m0, variabl1287[i])
.toString();
if (variabl1377[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.variabl1545.lastIndexOf(variabl1501[variabl1287[i]]) > 0)
s1 = s1 + variabl2517[0][variabl1287[i]] + "=" + variabl1377[i];
else
s1 = s1 + variabl2517[0][variabl1287[i]] + "='" + variabl1377[i] + "' ";
if (i < variabl1525.length - 1)
s1 = s1 + " and ";
}
int j1 = 0;
for (int j=0;j<model.getRowCount()-1;j++){
for (int i = 0; i < variabl1525.length; i++){
if (variabl1377[i].trim().equals(model.getValueAt(j, variabl1287[i]).toString().trim()))
j1++;
if (j1==variabl1525.length) {
JOptionPane.showMessageDialog(null, "关键字数据重复，请检查！");
return;
}
}
j1=0;
}
s1="";
s2="";
for(int j=0;j<variabl2651;j++){
s1=s1+variabl2517[0][j];
if (j<variabl2651-1) s1=s1+",";
if (model.getValueAt(m0, j) == null) s3="";
else
s3 = model.getValueAt(m0, j).toString() ;
if(main1.variabl1545.trim().indexOf(","+variabl1501[j]+",")>=0){
if (s3.trim().length()<1) s3="0";
s2=s2+s3.trim();
if (compto(s3,m0,j)<0)
return;
}
else {
s2=s2+"'"+s3.trim()+"'";
}
if(j<variabl2651-1)
s2=s2+",";
}
s1="insert into "+variabl2603+"("+s1+")"+" values ("+s2+")";
try {
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
variabl1175="";
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能录入，可能是数据出错，请检查！");
return;
}
model.addRow(variabl1919);
}
});
variabl2683 = new JButton();
variabl2683.setText(variabl2405[1]);
variabl2683.setBounds(variabl2337,560,variabl2339,20);
if (variabl1187.indexOf(",1,")>=0) {
variabl2337=variabl2337+variabl2339;
panel.add(variabl2683);
}
variabl2683.addActionListener(new ActionListener()
{
public void actionPerformed( ActionEvent e)
{
s1 = "";
int j1 = 0;
int m0=table.getSelectedRow();
int m1=table.getSelectedColumn();
variabl1377=new String[variabl1525.length];
for (int i = 0; i < variabl1525.length; i++) {
variabl1377[i] = model.getValueAt(m0, variabl1287[i]).toString();
if (variabl1377[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.variabl1545.lastIndexOf(variabl1501[variabl1287[i]]) > 0)
s1 = s1 + variabl2517[0][variabl1287[i]] + "=" + variabl1377[i];
else
s1 = s1 + variabl2517[0][variabl1287[i]] + "='" + variabl1377[i] + "' ";
if (i < variabl1525.length - 1)
s1 = s1 + " and ";
}
String str1="";
for(int j=0;j<variabl2651;j++){
if(main1.variabl1545.trim().indexOf(","+variabl1501[j]+",")>=0){
if ((table.getValueAt(m0, j)==null) ||(table.getValueAt(m0, j).toString().trim().length()==0))
str1=str1+variabl2517[0][j]+"=0";
else str1=str1+variabl2517[0][j]+"="+
table.getValueAt(m0, j).toString().trim();
if ((table.getValueAt(m0, j)!=null)&&(compto(table.getValueAt(m0, j).toString(),m0,j))<0)
return;
}
else
if (table.getValueAt(m0, j)==null)
str1=str1+variabl2517[0][j]+"=' '";
else str1=str1+variabl2517[0][j]+"='"+
table.getValueAt(m0, j).toString().trim()+"'";
if(j<variabl2651-1)
str1=str1+",";
}
try{
s1=" update "+variabl2603+" set "+str1+" where "+s1;
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
variabl1175="";
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能修改成功，可能是数据出错，请检查！");
return;
}
}
});
variabl2633 = new JButton();
variabl2633.setText(variabl2405[2]);
variabl2633.setBounds(variabl2337,560,variabl2339,20);
if (variabl1187.indexOf(",2,")>=0) {
variabl2337=variabl2337+variabl2339;
panel.add(variabl2633);
}
variabl2633.addActionListener(new ActionListener(){
public void actionPerformed( ActionEvent e){
s1 = "";
int j1 = 0;
int m0=table.getSelectedRow();
variabl1377=new String[variabl1525.length];
for (int i = 0; i < variabl1525.length; i++) {
variabl1377[i] = model.getValueAt(m0, variabl1287[i]).toString();
if (variabl1377[i].trim().compareTo(" ") < 0){
JOptionPane.showMessageDialog(null, "关键字数据不全，请检查！");
return;
}
if (main1.variabl1545.lastIndexOf(variabl1501[variabl1287[i]]) > 0)
s1 = s1 + variabl2517[0][variabl1287[i]] + "=" + variabl1377[i];
else
s1 = s1 + variabl2517[0][variabl1287[i]] + "='" + variabl1377[i] + "' ";
if (i < variabl1525.length - 1)
s1 = s1 + " and ";
}
try {
s1="delete from "+variabl2603+" where "+s1;
con= main1.getConn();
Statement statement=con.createStatement();
statement.executeUpdate(s1);
statement.close();
con.close();
} catch (SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "未能删除成功，可能是数据出错，请检查！");
return;
}
model.removeRow(table.getSelectedRow());
}
});
variabl2599 = new JButton(variabl2405[3]);
variabl2599.setBounds(variabl2337,560,variabl2339,20);
if (variabl1187.indexOf(",3,")>=0) {
variabl2337=variabl2337+variabl2339;
panel.add(variabl2599);
}
variabl2599.addActionListener(new ActionListener()
{
public void actionPerformed(final ActionEvent e)
{
frame.setVisible(false);
frame.dispose();
}
});
variabl2599.setText("退出");
JButton 显示表格 = new JButton("显示表格");
显示表格.setBounds(10,530,120,20);
显示表格.setForeground(Color.RED);
panel.add(显示表格);
显示表格.addActionListener(new ActionListener()
{
public void actionPerformed( ActionEvent e)
{
variabl1633=listl0.getSelectedItems();
int [] y0=listl0.getSelectedIndexes();
s1="";
if (variabl1633.length>0)
for (int i=0;i<variabl1633.length;i++){
if (i==variabl1633.length-1)
s1=s1+variabl2517[0][y0[i]];
else
s1=s1+variabl2517[0][y0[i]]+",";
}
else if (JOptionPane.showConfirmDialog(null, "您未选择列名，意味选全部字段，请确认。",
"yes", JOptionPane.YES_NO_OPTION)==1){
return;
}
else {
variabl1633=new String[variabl2651];
s1="";
for (int i=0;i<variabl2651;i++){
if (i==variabl2651-1)
s1=s1+variabl2517[0][i];
else
s1=s1+variabl2517[0][i]+",";
variabl1633[i]=variabl2517[0][i];
}
}
variabl1525=list0.getSelectedItems();
if (variabl1525.length==0){
JOptionPane.showMessageDialog(null, "未选择关键字，请检查！");
return;
}
variabl1287=new int[variabl1525.length];
for (int i=0;i<variabl1633.length;i++){
for (int j=0;j<variabl1287.length;j++){
if (variabl1633[i].equals(variabl1525[j]))
variabl1287[j]=i;
}
}
try{
main1.driver1();
con=main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select "+s1+" from " + variabl2603;
rs = sta3.executeQuery(s1);
rs.last();
variabl1853=rs.getRow();
ResultSetMetaData rsmd = rs.getMetaData();
variabl2651 = rsmd.getColumnCount();
variabl2517 = new String[2][variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
variabl1919=new String[variabl2651];
for (int i=0;i<variabl2651;i++) {
variabl2517[0][i] = rsmd.getColumnName(i + 1);
variabl2517[1][i]=variabl2517[0][i];
variabl1501[i] = rsmd.getColumnTypeName(i+1);
variabl1489[i] = rsmd.getColumnDisplaySize(i+1);
if (variabl1489[i] < variabl2517[1][i].length())
variabl1489[i] = variabl2517[1][i].length();
else if (variabl1489[i] > 50)
variabl1489[i] = 50;
variabl1919[i]="";
}
variabl2197=new String[variabl1853][variabl2651];
rs.absolute(1);
int c=0;
int b=0;
while(c<variabl1853) {
rs.absolute(c+1);
while(b<variabl2651){
variabl2197[c][b]=rs.getString(b+1);
b++;
}
c++;
b=0;
}
rs.close();
sta3.close();
con.close();
} catch (SQLException e1){
JOptionPane.showMessageDialog( null, "获取数据结构出错！");
}
variabl1873="";
String []t1;
int b=0,c=0;
if (variabl2429.lastIndexOf(variabl2603+"字典表")>=0){
t1=variabl2429.split(",");
for (int i=0;i<t1.length;i++)
if (t1[i].lastIndexOf(variabl2603+"字典表")>=0) variabl1873=t1[i];
}
if (variabl1873.length() > 0){
try
{
con = main1.getConn();
s1 = "select * from " + variabl1873;
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs=sta3.executeQuery(s1);
while (rs.next())
{
String variabl2153 = rs.getString(1);
String variabl1755 = rs.getString(2);
b = 0;
while (b < variabl2651)
{
if (variabl2517[0][b].compareTo(variabl2153.trim()) == 0)
{
variabl2517[1][b] = variabl1755;
if (variabl1489[b] < variabl2517[1][b].length())
variabl1489[b] = variabl2517[1][b].length();
break;
}
b++;
}
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1){
e1.printStackTrace();
}
}
if(variabl1221.length()>0){
con = main1.getConn();
s1 = "select * from " + variabl1221;
con=main1.getConn();
try
{
sta3=con.createStatement
(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs=sta3.executeQuery(s1);
ResultSetMetaData rsmd=rs.getMetaData();
rs.last();
int rows=rs.getRow();
rs.absolute(1);
int columns=rsmd.getColumnCount();
variabl1071=new String[rows][columns];
int i=0;
while (i<rows)
{
for(int j=0;j<columns;j++)
{
variabl1071[i][j]=rs.getString(j+1);
}
i++;
rs.next();
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1)
{
e1.printStackTrace();
}
}
model = new DefaultTableModel(variabl2197, variabl2517[1]);
model.addRow(variabl1919);
table = new JTable(model);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2651; i++)
{
TableColumn tc = table.getColumn(variabl2517[1][i]);
JTableHeader header = table.getTableHeader();
tc.setPreferredWidth(variabl1489[i] * 9);
tc.setMaxWidth(variabl1489[i] * 9);
tc.sizeWidthToFit();
}
scrollPane.setBounds(150,20,variabl2483-300,variabl2503-180);
scrollPane.setViewportView(table);
panel.add(scrollPane);
table.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent evt) {
variabl1175 = variabl1175 + evt.getKeyChar();
}
});
table.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
int selectedRow = table.getSelectedRow();
int variabl2593 = table.getSelectedRow();
int variabl2547 = table.getSelectedColumn();
if (variabl1525 == null) {
JOptionPane.showMessageDialog(null, "请选择关键字！");
return;
}
int k = 0;
for (int i = 0; i < variabl1525.length; i++) {
if (variabl1287[i] == variabl2547)
k = 1;
}
if (k == 0) {
model.setValueAt("", variabl2593, variabl2547);
}
variabl1175 = "";
listr0.removeAll();
hs.clear();
if (variabl1431[variabl2547][0] == null)
for (int i1 = 0; i1 < variabl2197.length; i1++) {
if ((variabl2197[i1][variabl2547] != null)
&& (variabl2197[i1][variabl2547].toString().length() > 0))
hs.add(variabl2197[i1][variabl2547].toString());
}
else
for (int i1 = 0; i1 < variabl1431[variabl2547].length; i1++) {
if (variabl1431[variabl2547][i1]==null) break;
hs.add(variabl1431[variabl2547][i1].toString());
}
Iterator it = hs.iterator();
while (it.hasNext())
listr0.add(it.next().toString());
}
});
table.addFocusListener(new FocusAdapter() {
public void focusLost(final FocusEvent arg0) {
int variabl2593 = table.getSelectedRow();
int variabl2547 = table.getSelectedColumn();
Double temp0=0.0;
String sb="";
if (variabl1175.trim().length()>0){
if (variabl1175.indexOf(" ")>=0)
variabl1175=variabl1175.substring(variabl1175.lastIndexOf(" ")+1,variabl1175.length());
model.setValueAt(variabl1175, variabl2593, variabl2547);
}
}
});
}
});
frame.add(panel);
frame.setVisible(true);
}
public void itemStateChanged(ItemEvent e) {
if (e.getStateChange()==2) return;
variabl2603=jcb.getSelectedItem().toString();
variabl1221="";
if (variabl2429.indexOf(variabl2603+"接口参数表")>=0)
variabl1221=variabl2603+"接口参数表";
try{
main1.driver1();
con=main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl2603;
rs = sta3.executeQuery(s1);
ResultSetMetaData rsmd = rs.getMetaData();
variabl2651 = rsmd.getColumnCount();
variabl2517 = new String[2][variabl2651];
variabl1431= new String[variabl2651][];
for (int i=0;i<variabl2651;i++) {
variabl2517[0][i] = rsmd.getColumnName(i + 1);
variabl2517[1][i]=variabl2517[0][i];
variabl1431[i]=new String[2];
}
rs.close();
sta3.close();
con.close();
} catch (SQLException e1){
JOptionPane.showMessageDialog( null, "获取数据结构出错！");
}
for (int i2=0;i2<variabl2651;i2++) {
if (variabl2429.lastIndexOf(variabl2517[0][i2]+"代码表")>=0){
s1=variabl2517[0][i2]+"代码表";
数据表查询数据0(s1,variabl2517[0][i2],i2);
}
else if (variabl2429.lastIndexOf(variabl2517[0][i2]+"表")>=0){
s1=variabl2517[0][i2]+"表";
数据表查询数据0(s1,variabl2517[0][i2],i2);
}
}
variabl1873="";
String []t1;
int b=0,c=0;
if (variabl2429.lastIndexOf(variabl2603+"字典表")>=0){
t1=variabl2429.split(",");
for (int i=0;i<t1.length;i++)
if (t1[i].lastIndexOf(variabl2603+"字典表")>=0) variabl1873=t1[i];
}
if (variabl1873.length() > 0){
try
{
con = main1.getConn();
s1 = "select * from " + variabl1873;
sta3 = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs=sta3.executeQuery(s1);
while (rs.next())
{
String variabl2153 = rs.getString(1);
String variabl1755 = rs.getString(2);
b = 0;
while (b < variabl2651)
{
if (variabl2517[0][b].compareTo(variabl2153.trim()) == 0)
{
variabl2517[1][b] = variabl1755;
break;
}
b++;
}
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1){
e1.printStackTrace();
}
}
if((variabl1401.equals("有"))&&(username.length()>0)&&(variabl1221.length()>0)){
con = main1.getConn();
s1 = "select * from " + variabl1221;
con=main1.getConn();
try
{
sta3=con.createStatement
(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs=sta3.executeQuery(s1);
ResultSetMetaData rsmd=rs.getMetaData();
rs.last();
int rows=rs.getRow();
rs.absolute(1);
int columns=rsmd.getColumnCount();
variabl1071=new String[rows][columns];
int i=0;
while (i<rows)
{
for(int j=0;j<columns;j++)
{
variabl1071[i][j]=rs.getString(j+1);
}
i++;
rs.next();
}
rs.close();
sta3.close();
con.close();
} catch (Exception e1)
{
e1.printStackTrace();
}
String x8="",x9="";
for (int i1=0;i1<variabl1071.length;i1++){
if ((variabl1071[i1][0].equals("2"))&&(variabl1071[i1][6].equals(username)))
x8=variabl1071[i1][7];
x9=variabl1071[i1][8];
}
if (x8.length()==0){
JOptionPane.showMessageDialog( null, "对不起，您未具有对此表的操作权限，请申请权限。");
return;
}
else {
for (int i=0;i<variabl2651;i++)
if ((","+x9+",").indexOf(","+i+",")<0)
variabl2517[1][i]="";
}
if (x9.indexOf("0")<0)
variabl2641.setVisible(false);
else if (x9.indexOf("1")<0)
variabl2683.setVisible(false);
else if (x9.indexOf("2")<0)
variabl2633.setVisible(false);
}
listl0.removeAll();
list0.removeAll();
for (int i=0;i<variabl2651;i++){
if (variabl2517[1][i].length()>0)
list0.add(variabl2517[1][i]);
}
for (int i=0;i<variabl2651;i++){
if (variabl2517[1][i].length()>0)
listl0.add(variabl2517[1][i]);
}
}
public static int compto(String variabl1175,int variabl2593,int variabl2547){
Double temp0=0.0;
String sb="";
if (variabl1175.trim().length()>0){
if (variabl1221.length()>0) {
for(int j=0;j<variabl1071.length;j++)
{
if (variabl1071[j][0].trim().equals("3")){
if (variabl1071[j][1].trim().equals(variabl2517[0][variabl2547].trim())
|| variabl1071[j][1].trim().equals(variabl2517[1][variabl2547].trim()))
{
if (variabl1175.indexOf(" ")>=0)
variabl1175=variabl1175.substring(variabl1175.lastIndexOf(" ")+1,variabl1175.length());
try{
temp0=Double.parseDouble(variabl1175.trim());
}catch(Exception e1)
{
JOptionPane.showMessageDialog( null, "完整性控制只限数字数据类型！");
return -1;
}
if (variabl1071[j][2]!=null){
if (temp0>Double.parseDouble(variabl1071[j][2]))
{
JOptionPane.showMessageDialog( null, "数据超过最大值，请修改！");
return -1;
}
}
if (variabl1071[j][3] != null){
if (temp0<Double.parseDouble(variabl1071[j][3]))
{
JOptionPane.showMessageDialog( null, "数据小于最小值，请修改！");
return -1;
}
}
if(variabl1071[j][4]!=null){
String strs[]=variabl1071[j][4].split(",");
for(int ii=0;ii<strs.length;ii++)
{
if (temp0>Double.parseDouble(strs[1]) ||
temp0<Double.parseDouble(strs[0]))
{
JOptionPane.showMessageDialog( null, "数据值域错，请修改！！");
return -1;
}
}
}
if(variabl1071[j][5]!=null){
sb=variabl1071[j][5];
for (int i1=0;i1<variabl2651;i1++){
if ((sb.indexOf(variabl2517[0][i1])>=0)&&
(main1.variabl1545.indexOf(variabl1501[i1])>=0)){
sb=sb.replaceAll(variabl2517[0][i1],model.getValueAt(variabl2593, i1).toString());
}
}
try {
if (! tenanceEval.tenanceeval(sb.toLowerCase())) {
JOptionPane.showMessageDialog( null, "数据不满足完整性条件表达式！");
return -1;
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
}
model.setValueAt(variabl1175, variabl2593, variabl2547);
}
return 0;
}
static void 数据表查询数据0(String variabl22330,String variabl25179,int j9) {
try
{
int u=0;
s1 = "select "+variabl25179+" from " + variabl22330;
con=main1.getConn();
sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs = sta3.executeQuery(s1);
rs.last();
int row=rs.getRow();
rs.beforeFirst();
variabl1431[j9]= new String[row];
for (int i=1;i<=row;i++){
rs.absolute(i);
variabl1431[j9][i-1]=rs.getString(1).trim();
}
rs.close();
sta3.close();
con.close();
} catch(SQLException e3){
JOptionPane.showMessageDialog( null, "读取数据库数据出错！"+s1);
}
}
}
40.源码40，部件程序，单记录数据维护程序(表单程序)。
/**
* 程序文件名：dataTenance1.java
* 作者：贺红艳
* 功能：单记录数据维护程序
* 以文本框、按钮等构成单记录数据维护界面，包括数据录入、修改、删除数据等功能。
* 本部件不涉及包含有image等二进制数据类型的数据的维护
* 完成日期：2013年12月20日
* 被调用语句：dataTenance1.means(parameter);
* 当无大数据类型时，在窗口中按每字段一行安排控件，各字段统一长度，
* 再按每字段一行均匀布局。如果字段数多，按各字段实际大小布局，行间均匀留空。
* 如果有大数据类型，一般字段紧凑布局，余下空间均匀分配给大数据类型。
* 本部件不涉及包含有image等二进制数据类型的数据的维护
* 必须提供的参数：“表名”、“关键字段名”
* 可选参数：“窗口宽”、“窗口高” 、 “要求字段号表”、“要求按钮号表”。
* 关键字段名为识别与区分记录的主要标志，不允许重复，不允许为空，可以是单一字段，也可以是多个字段，
* 如果是多字段，以英文逗号分隔。
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序后，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件“第一条”、“下一条”、“最后一条”、“上一条”、“浏览”、“存盘”、“清屏”、
* “修改存盘”、“删除”、“退出”共 10 个。
* 通过“要求按钮号表”提供所需要显示的按钮在该部件原设计的界面 中的顺序号，各按钮号用逗号分隔。
* 做数据录入程序模块使用时一般选择“存盘”、“清屏”、“退出”等按钮，选择按钮号为：“7,8,12”。
* 做数据修改程序模块使用时，一般选择“第一条”、“下一条”、“最后一条”、“上一条”、“浏览”、“查询”、
* “修改存盘”、“退出”等按钮，选择按钮号为：“1,2,3,4,5,6,9,12”。
* 每录入一条记录后必须点击“存盘”按钮，将新记录填入表内。
* 每修改一条记录，必须点击“修改存盘”按钮，将改后记录填入表内。
* 每删除一条记录，必须点击“删除”按钮，将改后记录填入表内。
* 如果要根据条件选择的结果将满足条件的记录某一字段数据全部改为某数据，
* 需要先进行查询，再在某字段文本框中输入改后数据，之后点击“批处理”按钮。
* 查询只限等值查询，要求先在某字段文本框中输入欲查询的数据值，再点击查询按钮，
* 实现该字段等于该值的查询。
* 注意本程序适用于由基本数据类型构成的数据表，
* 适用数据类型包括各类整型、各浮点类型、各char数据类型、各text数据类型。
*/
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashSet;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.text.JTextComponent;
public class dataTenance1 {
static JFrame frame1 = new JFrame();
static JTextField[] variabl2403;
private static Connection cont4;
private static Statement stat4;
private static ResultSetMetaData rsmdt4;
private static ResultSet rs;
private static String variabl2603;
private static int variabl2483 = main1.variabl2483;
private static int variabl2503 = main1.variabl2503;
private static int variabl1531 = 10, variabl1477 = 10;
private static int variabl2651;
private static int variabl2113;
private static String[] variabl2517;
private static String[] variabl1913;
private static String[] variabl1231;
private static String[] variabl1501;
private static String[] variabl1169;
private static int[] variabl1489;
private static int[] variabl1119;
private static int variabl1853 = 0;
private static int variabl18531 = 0;
private static String[][] variabl2197;
private static String[] variabl1419;
static String[][] variabl1701;
private static String variabl1187;
private static String variabl1153 = "", variabl2803 = "";
private static String[] variabl1507;
private static String variabl2309 = "";
private static String[] variabl1525;
private static String[] variabl1377;
private static int[] variabl1287;
private static String s1 = "", s2 = "";
private static int b = 0, c = 0;
private static String[] variabl1425;
private static int[] variabl2345;
private static int[][] variabl1921;
private static int variabl1843 = 0;
private static String variabl1175 = "";
private static int variabl1647 = 15, variabl1849 = 20;
private static String[] variabl2405 = { "第一条", "下一条", "最后一条", "上一条", "浏览",
"存盘", "清屏", "修改存盘", "删除", "退出" };
private static JButton b1;
private static JButton variabl2375, variabl2325, variabl1971, variabl2255,
variabl2531, variabl2611, variabl2601, variabl1697, variabl2633,
variabl2599;
private static String variabl1597 = main1.variabl1537 + main1.variabl1539;
public static String[] sw = new String[11];
static int variabl2851 = 0, variabl2339 = 0;
public static int[][] variabl1885;
public static int variabl1473, variabl1313;
public static int variabl1293;
public static int variabl1371;
public static int variabl1577;
public static int variabl1459;
public static JTextComponent[] variabl1733;
public static int[] variabl1467;
public static JButton[] variabl2185 = new JButton[10];
public static int variabl2833;
private static HashSet set01 = new HashSet();
private static String sd0;
static void means(String parameter[]) {
frame1 = new JFrame();
variabl2483 = main1.variabl2483;
variabl2503 = main1.variabl2503;
variabl1531 = 10;
variabl1477 = 10;
variabl1853 = 0;
variabl18531 = 0;
variabl2833 = 0;
s1 = "";
s2 = "";
b = 0;
c = 0;
variabl1175 = "";
variabl1647 = 15;
variabl1849 = 20;
variabl1313 = 0;
variabl1597 = main1.variabl1537 + main1.variabl1539;
variabl2603 = parameter[4];
sw = new String[11];
sw[1] = main1.sw1 + "";
sw[2] = main1.sw2;
sw[3] = main1.sw3;
sw[4] = main1.sw4;
sw[5] = main1.sw5;
sw[6] = main1.sw6;
sw[7] = main1.sw7;
sw[8] = main1.sw8;
sw[10] = main1.sw10;
main1.sw1 = 0;
main1.sw2 = "";
main1.sw3 = "";
main1.sw4 = "";
main1.sw5 = "";
main1.sw6 = "";
main1.sw7 = "";
main1.sw8 = "";
main1.sw10 = "";
/*
* main1.sw1 main1.sw4 main1.sw7
*/
String[] variabl240501 = { "第一条", "下一条", "最后一条", "上一条", "浏览", "存盘",
"清屏", "修改存盘", "删除", "退出" };
String variabl11870;
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];
} else {
variabl1187 = variabl1187 + "," + s601[i01];
}
}
} 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];
}
}
} else {
variabl1187 = "";
for (int i1 = 0; i1 < variabl2405.length; i1++) {
if (i1 == 0)
variabl1187 = variabl1187 + i1;
else
variabl1187 = variabl1187 + "," + i1;
}
}
variabl11870 = variabl1187;
variabl1187 = "," + variabl1187 + ",";
variabl1187 = variabl1187.replaceAll(",,", ",");
variabl2851 = variabl2405.length;
variabl2483 = main1.variabl2483;
variabl2503 = main1.variabl2503;
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
variabl2483 = m1;
variabl2503 = m2;
}
} catch (Exception e2) {
}
variabl2603 = parameter[4];
if (parameter[6].length() <= 0) {
JOptionPane.showMessageDialog(null, "缺少关键字，请说明关键字字段后再运行。");
return;
}
variabl1525 = parameter[6].split(",");
if (sw[5].length() > 0) {
if (variabl11870.trim().length() > 0) {
String[] ss = variabl11870.split(",");
variabl1187 = "";
for (int j = 0; j < ss.length; j++) {
if (variabl1187.length() == 0)
variabl1187 = (Integer.parseInt(ss[j]) + 5) + "";
else
variabl1187 = variabl1187 + ","
+ (Integer.parseInt(ss[j]) + 5) + "";
}
} else
variabl1187 = "5,6,7,8,9";
}
variabl1153 = parameter[8];
variabl2803 = "," + parameter[9] + ",";
variabl1287 = new int[variabl1525.length];
variabl2185 = new JButton[10];
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl2603;
if ((sw[3].length() > 0) && (sw[4].length() > 0))
s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";
rs = stat4.executeQuery(s1);
rs.last();
variabl1853 = rs.getRow();
rsmdt4 = rs.getMetaData();
variabl2651 = rsmdt4.getColumnCount();
variabl2517 = new String[variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[i] = rsmdt4.getColumnName(i + 1);
variabl1501[i] = rsmdt4.getColumnTypeName(i + 1);
variabl1489[i] = rsmdt4.getColumnDisplaySize(i + 1);
if (variabl1647 * (variabl1489[i] + variabl2517[i].length()) > variabl2483)
variabl1501[i] = "text";
}
for (int j = 0; j < variabl1525.length; j++)
for (int i = 0; i < variabl2651; i++) {
if (variabl1525[j].trim().equals(variabl2517[i].trim())) {
variabl1287[j] = i;
if ((variabl1153.length() > 0)
&& (("," + variabl1153 + ",").lastIndexOf(","
+ i + ",") < 0))
variabl1153 = variabl1153 + "," + i;
break;
}
}
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错！");
}
variabl1153 = "," + variabl1153 + ",";
variabl2345 = new int[variabl2651];
int b0 = 0, b = -1;
while (b0 < variabl2651) {
if ((variabl1153.length() < 3)
|| (variabl1153.lastIndexOf("," + b0 + ",") >= 0)) {
b = b + 1;
variabl2345[b] = b0;
} else
variabl2345[b0] = b0;
b0++;
}
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl2113; i++) {
if (variabl1287[j] == i)
variabl1287[j] = variabl2345[i];
}
}
if (b < 0)
variabl2113 = variabl2651;
else
variabl2113 = b + 1;
variabl1921 = new int[variabl2113][2];
variabl1913 = new String[variabl2113];
variabl1231 = new String[variabl2113];
variabl1169 = new String[variabl2113];
variabl1119 = new int[variabl2113];
variabl2197 = new String[variabl1853 + 300][variabl2113];
variabl1507 = new String[variabl2113];
int variabl1925 = 0;
variabl1473 = 0;
variabl1293 = 0;
int variabl2119 = 0, variabl1745 = variabl2483, variabl1923 = variabl2503;
b = 0;
while (b < variabl2113) {
variabl1231[b] = variabl2517[variabl2345[b]];
variabl1913[b] = variabl2517[variabl2345[b]];
variabl2309 = variabl2309 + variabl1913[b];
variabl1169[b] = variabl1501[variabl2345[b]];
variabl1119[b] = variabl1489[variabl2345[b]];
if (variabl1913[b].length() > variabl1925)
variabl1925 = variabl1913[b].length();
if ((variabl1597.indexOf("," + variabl1169[b] + ",") < 0)
&& (variabl1293 < (variabl1913[b].length() + variabl1119[b])
* variabl1647)) {
variabl1293 = (variabl1913[b].length() + variabl1119[b])
* variabl1647;
}
if (variabl1597.indexOf("," + variabl1169[b] + ",") >= 0)
variabl1473++;
b++;
}
variabl1473 = 0;
int variabl1315 = (variabl2483 - 30) / variabl1647;
b = 0;
while (b < variabl2113) {
if (variabl1597.lastIndexOf("," + variabl1169[b] + ",") >= 0)
variabl1473++;
if ((variabl1925 + variabl1119[b]) > (variabl1315)) {
variabl1119[b] = variabl1315 - variabl1925;
}
if (variabl1169[b].indexOf("datetime") == 0)
variabl1507[b] = "2001-01-01 00:00:00.000";
else if (variabl1169[b].indexOf("smalldatetime") == 0)
variabl1507[b] = "2001-01-01 00:00:00";
else if (variabl1169[b].indexOf("datetime2") == 0)
variabl1507[b] = "2001-01-01 00:00:00.0000000";
else if (variabl1169[b].indexOf("datetimeoffset") == 0)
variabl1507[b] = "2001-01-01 00:00:00.0000000 +08:00";
else if (variabl1169[b].indexOf("date") == 0)
variabl1507[b] = "2001-01-01";
else if (variabl1169[b].indexOf("time") == 0)
variabl1507[b] = "00:00:00";
else if (variabl1169[b].indexOf("money") >= 0)
variabl1507[b] = "0.0000";
else if (main1.variabl1541.lastIndexOf(variabl1169[b]) > 0)
variabl1507[b] = "0.00";
else if (main1.variabl1545.lastIndexOf(variabl1169[b]) > 0)
variabl1507[b] = "0";
else
variabl1507[b] = "";
b++;
}
try {
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2113) {
variabl2197[c][b] = rs.getString(variabl2345[b] + 1);
b++;
}
c++;
b = 0;
}
rs.close();
stat4.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错！");
}
final JPanel panel1 = new JPanel(false);
panel1.setLayout(null);
int variabl1637 = 0, variabl1629 = 0;
int variabl1133 = 0;
int variabl1577 = 0;
variabl1921 = new int[variabl2113][2];
int variabl2179;
if ((variabl2851 * variabl1647 * 6.3) % (variabl2483 - 30) == 0)
variabl2179 = (int) (variabl2851 * variabl1647 * 6.3)
% (variabl2483 - 30);
else
variabl2179 = (int) (variabl2851 * variabl1647 * 6.3)
/ (variabl2483 - 30) + 1;
int variabl1239 = 1;
if ((variabl1473 == 0)
&& (variabl2113 * variabl1849 + variabl2179 * variabl1849 + 40 < variabl2503)) {
variabl1239 = variabl2113;
for (int j = 0; j < variabl2113; j++) {
variabl1921[j][0] = 1 + j;
variabl1921[j][1] = 1;
variabl1119[j] = variabl1315 - variabl1925;
}
variabl1637 = (variabl2503 - 120 - (variabl2179 + variabl2113)
* variabl1849)
/ (variabl2179 + variabl2113 + 1);
} else {
int variabl1385 = 1;
for (int i = 0; i < variabl2113; i++) {
if (variabl1597.lastIndexOf("," + variabl1169[i] + ",") < 0) {
if ((variabl1133 + variabl1925 + variabl1119[i]) <= variabl1315) {
variabl1133 = variabl1133 + variabl1925
+ variabl1119[i];
variabl1921[i][0] = variabl1239;
variabl1577 = variabl1577 + variabl1925
+ variabl1119[i];
variabl1921[i][1] = variabl1385;
variabl1385++;
} else {
variabl1119[i - 1] = variabl1119[i - 1] + variabl1315
- variabl1133;
variabl1239++;
variabl1385 = 1;
variabl1921[i][0] = variabl1239;
variabl1921[i][1] = variabl1385;
variabl1385++;
variabl1133 = variabl1925 + variabl1119[i];
variabl1577 = variabl1925 + variabl1119[i];
}
b = i;
}
}
variabl1119[b] = variabl1119[b] + variabl1315 - variabl1133;
if (variabl1473 > 0)
variabl1637 = 0;
else
variabl1637 = (variabl2503 - 120 - variabl2179 * variabl1849 - variabl1239
* variabl1849)
/ (variabl1239 + variabl2179 + 1);
}
variabl1733 = new JTextComponent[variabl2113];
variabl1419 = new String[variabl1733.length];
variabl1467 = new int[variabl1733.length];
int variabl2247 = 1, variabl2331 = 1;
variabl1843 = 0;
variabl1577 = 0;
variabl1459 = variabl1477 + variabl1637;
variabl2403 = new JTextField[variabl1913.length];
for (int j = 0; j < variabl1913.length; j++) {
JLabel variabl2533 = new JLabel(variabl1913[j], 11);
variabl2403[j] = new JTextField("");
if (variabl2803.indexOf("," + j + ",") >= 0) {
variabl2403[j].setEditable(false);
}
if (variabl1597.lastIndexOf("," + variabl1169[j] + ",") < 0) {
panel1.add(variabl2533);
panel1.add((Component) variabl2403[j]);
if ((variabl1921[j][0] == variabl2331)
&& (variabl1921[j][1] == variabl2247)) {
variabl2533
.setBounds(variabl1577 * variabl1647, variabl1459,
variabl1925 * variabl1647, variabl1849);
variabl2403[j].setBounds(variabl1577 * variabl1647
+ variabl1925 * variabl1647, variabl1459,
variabl1119[j] * variabl1647, variabl1849);
variabl1921[j][0] = variabl1577 * variabl1647 + variabl1925
* variabl1647;
variabl1921[j][1] = variabl1459;
variabl1577 = variabl1577 + variabl1925 + variabl1119[j];
variabl2247++;
} else if (variabl1921[j][0] == variabl2331) {
variabl2247++;
variabl2533
.setBounds(variabl1577 * variabl1647, variabl1459,
variabl1925 * variabl1647, variabl1849);
variabl2403[j].setBounds(variabl1577 * variabl1647
+ variabl1925 * variabl1647, variabl1459,
variabl1119[j] * variabl1647, variabl1849);
variabl1921[j][0] = variabl1577 * variabl1647 + variabl1925
* variabl1647;
variabl1921[j][1] = variabl1459;
variabl1577 = variabl1577 + variabl1925 + variabl1119[j];
} else {
variabl1459 = variabl1459 + variabl1637 + variabl1849;
variabl2331++;
variabl1577 = 0;
variabl2533
.setBounds(variabl1577 * variabl1647, variabl1459,
variabl1925 * variabl1647, variabl1849);
variabl2403[j].setBounds(variabl1577 * variabl1647
+ variabl1925 * variabl1647, variabl1459,
variabl1119[j] * variabl1647, variabl1849);
variabl1921[j][0] = variabl1577 * variabl1647 + variabl1925
* variabl1647;
variabl1921[j][1] = variabl1459;
variabl2247 = 2;
variabl1577 = variabl1577 + variabl1925 + variabl1119[j];
}
variabl2403[j].setText(variabl1507[j]);
variabl2403[j].addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
Object s0 = arg0.getSource();
String s1 = s0.toString();
int n1 = 0;
for (int i = 0; i < variabl1913.length; i++) {
if (s1.lastIndexOf("," + variabl1921[i][0] + ","
+ variabl1921[i][1] + ",") > 0) {
break;
}
}
}
});
variabl1733[variabl1843] = (JTextComponent) variabl2403[j];
variabl1467[variabl1843] = j;
}
variabl1843++;
}
if (variabl1473 > 0) {
variabl1459 = variabl1459 + variabl1849;
variabl1313 = (variabl2503 - variabl1459 - 150) / variabl1473;
variabl1577 = 0;
int variabl1319 = (variabl1315 - variabl1925) * variabl1647;
for (int j = 0; j < variabl1913.length; j++) {
if (variabl1597.lastIndexOf("," + variabl1169[j] + ",") >= 0) {
JLabel variabl2533 = new JLabel(variabl1913[j], 11);
if (variabl1319 < 0)
variabl1319 = 50;
if (variabl1313 < 0)
variabl1313 = 10;
JTextArea variabl2463 = new JTextArea(" ", variabl1319,
variabl1313);
JScrollPane variabl1147 = new JScrollPane(variabl2463);
variabl1147.setBounds(variabl1577 + variabl1925
* variabl1647, variabl1459, variabl1319,
variabl1313);
panel1.add(variabl2533);
panel1.add((Component) variabl1147);
variabl2533.setBounds(variabl1577, variabl1459, variabl1925
* variabl1647, variabl1849);
variabl1459 = variabl1459 + variabl1313;
variabl1733[j] = (JTextComponent) variabl2463;
variabl1467[j] = j;
}
}
}
variabl2819002();
String sd = "";
set01.clear();
for (int i0 = 0; i0 < variabl1853; i0++) {
sd = "";
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl1843; i++) {
if (variabl1467[i] == variabl1287[j]) {
sd = sd + variabl2197[i0][variabl1467[i]].trim() + ",";
break;
}
}
}
set01.add(sd);
}
variabl2375 = new JButton(variabl2405[0]);
variabl2375.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl18531 = 0;
for (int i = 0; i < variabl1843; i++) {
variabl1733[i].setText(variabl2197[0][variabl1467[i]]);
if (main1.variabl1545.lastIndexOf(","
+ variabl1169[variabl1467[i]] + ",") > 0)
if ((variabl1733[i].getText() == null)
|| (variabl1733[i].getText().trim().length() < 1))
variabl1733[i].setText("0");
}
variabl2325.setEnabled(true);
variabl2255.setEnabled(false);
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
variabl2375.setBounds(variabl1885[0][0], variabl1885[0][1],
variabl1885[0][2], variabl1885[0][3]);
panel1.add(variabl2375);
}
variabl2325 = new JButton(variabl2405[1]);
variabl2325.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (variabl18531 < variabl1853 - 1) {
variabl18531++;
if (variabl18531 == variabl1853 - 1)
variabl2325.setEnabled(false);
for (int i = 0; i < variabl1843; i++) {
variabl1733[i]
.setText(variabl2197[variabl18531][variabl1467[i]]);
if ((main1.variabl1545.lastIndexOf(","
+ variabl1169[variabl1467[i]] + ",")) > 0)
if ((variabl1733[i].getText() == null)
|| (variabl1733[i].getText().trim()
.length() < 1))
variabl1733[i].setText("0");
}
}
variabl2255.setEnabled(true);
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
variabl2325.setBounds(variabl1885[1][0], variabl1885[1][1],
variabl1885[1][2], variabl1885[1][3]);
panel1.add(variabl2325);
}
variabl1971 = new JButton(variabl2405[2]);
variabl1971.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (variabl1853 > 1)
variabl18531 = variabl1853 - 1;
else
variabl18531 = 0;
for (int i = 0; i < variabl1843; i++) {
variabl1733[i]
.setText(variabl2197[variabl18531][variabl1467[i]]);
if ((main1.variabl1545.lastIndexOf(","
+ variabl1169[variabl1467[i]] + ",")) > 0)
if ((variabl1733[i].getText() == null)
|| (variabl1733[i].getText().trim().length() < 1))
variabl1733[i].setText("0");
}
variabl2325.setEnabled(false);
variabl2255.setEnabled(true);
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
variabl1971.setBounds(variabl1885[2][0], variabl1885[2][1],
variabl1885[2][2], variabl1885[2][3]);
panel1.add(variabl1971);
}
variabl2255 = new JButton(variabl2405[3]);
variabl2255.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (variabl18531 > 0) {
variabl18531--;
for (int i = 0; i < variabl1843; i++) {
variabl1733[i]
.setText(variabl2197[variabl18531][variabl1467[i]]);
if ((main1.variabl1545.lastIndexOf(","
+ variabl1169[variabl1467[i]] + ",")) > 0)
if ((variabl1733[i].getText() == null)
|| (variabl1733[i].getText().trim()
.length() < 1))
variabl1733[i].setText("0");
}
variabl2325.setEnabled(true);
} else
variabl2255.setEnabled(false);
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
variabl2255.setBounds(variabl1885[3][0], variabl1885[3][1],
variabl1885[3][2], variabl1885[3][3]);
panel1.add(variabl2255);
variabl2255.setEnabled(false);
}
variabl2531 = new JButton(variabl2405[4]);
variabl2531.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (variabl2531.getText().trim().equals("浏览")) {
variabl2531.setText("转当前行");
variabl1701 = new String[variabl1853][variabl2113];
for (int i = 0; i < variabl1853; i++)
for (int j = 0; j < variabl2113; j++)
variabl1701[i][j] = variabl2197[i][j];
tableTenance1.tableModel(variabl2483, variabl2503,
variabl1913, variabl1119, variabl1701, variabl1169);
} else {
variabl2531.setText("浏览");
variabl18531 = main1.variabl1327;
for (int i = 0; i < variabl1843; i++) {
variabl1733[i]
.setText(variabl2197[main1.variabl1327][variabl1467[i]]);
}
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 0)) {
variabl2531.setBounds(variabl1885[4][0], variabl1885[4][1],
variabl1885[4][2], variabl1885[4][3]);
panel1.add(variabl2531);
}
variabl2611 = new JButton(variabl2405[5]);
variabl2611.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < variabl1843; i++) {
variabl1419[i] = variabl1733[i].getText();
if (variabl1419[i] == null)
variabl1419[i] = " ";
variabl1733[i].setText(variabl1507[i]);
}
String sd = "";
int kd = set01.size();
int kd0 = 0;
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl1843; i++) {
if (variabl1467[i] == variabl1287[j]) {
if ((variabl1419[i] == null)
|| (variabl1419[i].trim().length() == 0))
kd0 = 1;
sd = sd + variabl1419[i].trim() + ",";
break;
}
}
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");
return;
}
set01.add(sd);
if (set01.size() == kd) {
JOptionPane.showMessageDialog(null, "关键字重复，请修改后重新生成！");
return;
}
set01.remove(sd);
sd0 = sd;
cont4 = main1.getConn();
try {
variabl1853++;
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + variabl2603 + "(";
for (int j = 0; j < variabl1843; j++)
s1 = s1 + variabl1231[variabl1467[j]] + ",";
s1 = s1.substring(0, s1.length() - 1) + ") VALUES (";
for (int j = 0; j < variabl1843; j++) {
variabl2197[variabl1853 - 1][j] = variabl1419[j];
if (main1.variabl1545.lastIndexOf(","
+ variabl1169[variabl1467[j]] + ",") >= 0) {
s1 = s1 + variabl1419[j] + ",";
} else {
s1 = s1 + "'" + variabl1419[j].trim() + "',";
}
}
s1 = s1.substring(0, s1.length() - 1) + ")";
stat4.executeUpdate(s1);
stat4.close();
cont4.close();
set01.add(sd0);
} catch (SQLException e2) {
for (int j = 0; j < variabl1843; j++) {
variabl2197[variabl1853][j] = "";
}
variabl1853--;
System.out.println("SQL语句错");
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",5,") >= 0)) {
variabl2611.setBounds(variabl1885[5][0], variabl1885[5][1],
variabl1885[5][2], variabl1885[5][3]);
panel1.add(variabl2611);
}
variabl2601 = new JButton(variabl2405[6]);
variabl2601.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < variabl1843; i++) {
variabl1733[i].setText(variabl1507[i]);
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",6,") >= 0)) {
variabl2601.setBounds(variabl1885[6][0], variabl1885[6][1],
variabl1885[6][2], variabl1885[6][3]);
panel1.add(variabl2601);
}
variabl1697 = new JButton(variabl2405[7]);
variabl1697.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < variabl1843; i++) {
variabl1419[i] = variabl1733[i].getText();
if (variabl1419[i] == null) {
variabl1419[i] = " ";
}
}
String sd = "";
int kd = set01.size();
int kd0 = 0;
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl1843; i++)
if (variabl1467[i] == variabl1287[j]) {
if ((variabl1419[i] == null)
|| (variabl1419[i].trim().length() == 0))
kd0 = 1;
sd = sd + variabl1419[i].trim() + ",";
break;
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");
return;
}
}
sd0 = sd;
set01.add(sd);
if (set01.size() != kd) {
JOptionPane.showMessageDialog(null, "关键字不存在，请改为生成数据录入语句！");
set01.remove(sd);
return;
}
s2 = "";
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl1843; i++)
if (variabl1467[i] == variabl1287[j]) {
if (main1.variabl1545.lastIndexOf(","
+ variabl1169[j] + ",") >= 0) {
if (variabl1419[i].length() < 1)
variabl1419[i] = "0";
s2 = s2 + variabl1525[j] + "=" + variabl1419[i];
} else
s2 = s2 + variabl1525[j] + "='"
+ variabl1419[i] + "'";
break;
}
if (j < variabl1525.length - 1)
s2 = s2 + " and ";
}
cont4 = main1.getConn();
try {
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "update " + variabl2603 + " set ";
for (int j = 0; j < variabl1843; j++) {
s1 = s1 + variabl1231[variabl1467[j]] + "=";
if (main1.variabl1545.lastIndexOf(","
+ variabl1169[variabl1467[j]] + ",") >= 0) {
if (variabl1419[j].length() < 1)
variabl1419[j] = "0";
s1 = s1 + variabl1419[j];
} else {
s1 = s1 + "'" + variabl1419[j].trim() + "'";
}
s1 = s1 + ",";
}
s1 = s1.substring(0, s1.length() - 1) + " where " + s2;
stat4.executeUpdate(s1);
stat4.close();
cont4.close();
for (int j = 0; j < variabl1843; j++) {
variabl2197[variabl18531][j] = variabl1419[j];
}
} catch (SQLException e2) {
System.out.println("SQL语句错");
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",7,") >= 0)) {
variabl1697.setBounds(variabl1885[7][0], variabl1885[7][1],
variabl1885[7][2], variabl1885[7][3]);
panel1.add(variabl1697);
}
variabl2633 = new JButton(variabl2405[8]);
variabl2633.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < variabl1843; i++)
variabl1419[i] = variabl1733[i].getText().trim();
String sd = "";
int kd = set01.size();
int kd0 = 0;
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl1843; i++)
if (variabl1467[i] == variabl1287[j]) {
if ((variabl1419[i] == null)
|| (variabl1419[i].trim().length() == 0))
kd0 = 1;
sd = sd + variabl1419[i].trim() + ",";
break;
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");
return;
}
}
set01.add(sd);
if (set01.size() != kd) {
set01.remove(sd);
}
sd0 = sd;
s2 = "";
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl1843; i++)
if (variabl1467[i] == variabl1287[j]) {
if (main1.variabl1545.lastIndexOf(","
+ variabl1169[j] + ",") >= 0)
s2 = s2 + variabl1525[j] + "=" + variabl1419[i];
else
s2 = s2 + variabl1525[j] + "='"
+ variabl1419[i].trim() + "'";
break;
}
if (j < variabl1525.length - 1)
s2 = s2 + " and ";
}
cont4 = main1.getConn();
try {
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + variabl2603 + " where " + s2;
stat4.executeUpdate(s1);
stat4.close();
cont4.close();
deleteData(variabl18531);
set01.remove(sd0);
for (int i = 0; i < variabl1843; i++) {
if (variabl18531 == variabl1853 - 1)
variabl1733[i].setText(variabl1507[i]);
else
variabl1733[i]
.setText(variabl2197[variabl18531][i]);
}
} catch (SQLException e2) {
System.out.println("SQL语句错");
}
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",8,") >= 0)) {
variabl2633.setBounds(variabl1885[8][0], variabl1885[8][1],
variabl1885[8][2], variabl1885[8][3]);
panel1.add(variabl2633);
}
variabl2599 = new JButton(variabl2405[9]);
variabl2185[9] = variabl2599;
variabl2599.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if ((sw[2].length() > 0) && (sw[3].length() > 0)
&& (sw[4].length() > 0)) {
WorkflowDrivek1.means(sw);
}
panel1.setVisible(false);
frame1.setVisible(false);
frame1.dispose();
}
});
if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",9,") >= 0)) {
variabl2599.setBounds(variabl1885[9][0], variabl1885[9][1],
variabl1885[9][2], variabl1885[9][3]);
panel1.add(variabl2599);
}
frame1.setTitle("单记录数据维护程序 作者：贺红艳");
panel1.setBounds(10, 10, variabl2483 - 10, variabl2503 - 20);
int w1, h1;
if (1200 - variabl2483 > 0)
w1 = (1200 - variabl2483) / 2;
else
w1 = 0;
if (600 - variabl2503 > 0)
h1 = (600 - variabl2503) / 2;
else
h1 = 0;
frame1.setBounds(w1, h1, variabl2483, variabl2503);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame1.getContentPane().setLayout(null);
frame1.getContentPane().add(panel1, null);
frame1.setVisible(true);
if ((sw[3].length() > 0) && (sw[4].length() > 0))
for (int i = 0; i < variabl1843; i++) {
variabl1733[i].setText(variabl2197[0][variabl1467[i]]);
}
}
static void variabl2819002() {
if (variabl2833 > 0)
return;
String[] t5 = variabl1187.split(",");
variabl1371 = t5.length - 1;
variabl1885 = new int[variabl2851][15];
for (int j = 0; j < variabl2851; j++) {
variabl1885[j][0] = 0;
variabl1885[j][1] = 0;
variabl1885[j][2] = 0;
variabl1885[j][3] = 0;
}
int variabl2179, variabl1629;
variabl1629 = (int) (variabl1647 * 6.3);
if ((variabl1371 * variabl1629) % (variabl2483 - 50) == 0)
variabl2179 = (int) (variabl1371 * variabl1629)
% (variabl2483 - 50);
else
variabl2179 = (int) (variabl1371 * variabl1629)
/ (variabl2483 - 50) + 1;
variabl1577 = 20;
if (variabl1473 == 0)
variabl1459 = variabl1459 + variabl1849 * 2;
else
variabl1459 = variabl1459 + variabl1849;
int variabl1505 = (variabl2483 - 30) / (int) (6.6 * variabl1647);
if (variabl1505 < 1)
variabl1505 = 1;
if (variabl1371 <= variabl1505)
variabl1629 = (variabl2483 - 60) / variabl1371;
else
variabl1629 = (variabl2483 - 60) / variabl1505;
int n = 0, n1 = 0, n2 = 0, n3 = 0;
n3 = variabl1505 * variabl1629;
for (int j = 0; j < variabl2851; j++) {
if (variabl1187.lastIndexOf("," + j + ",") >= 0) {
variabl1885[j][0] = variabl1577;
variabl1885[j][1] = variabl1459;
if (variabl2405[j].length() > 4) {
variabl1885[j][2] = (int) (variabl2405[j].length() * (variabl1647 * 1.2));
n3 = n3 + variabl1885[j][2] - variabl1629;
variabl1577 = variabl1577 + variabl1885[j][2];
} else {
variabl1885[j][2] = variabl1629;
variabl1577 = variabl1577 + variabl1629;
}
variabl1885[j][3] = variabl1849;
n++;
n1++;
if (variabl1371 - n1 == 0)
break;
if ((n >= variabl1505)
&& ((variabl1371 - n1) - variabl1505 != 0)) {
variabl1577 = 20;
variabl1459 = variabl1459 + variabl1849 + 20;
if ((variabl1371 - n1) <= variabl1505)
variabl1629 = (variabl2483 - 60) / (variabl1371 - n1);
else
variabl1629 = (variabl2483 - 60) / variabl1505;
n = 0;
n2++;
} else if (n >= variabl1505) {
variabl1577 = 20;
variabl1459 = variabl1459 + variabl1849 + 20;
n = 0;
n2++;
}
}
}
variabl2503 = variabl1459 + variabl1849 + 100;
}
public static void deleteData(int pos) {
if (pos == variabl1853 - 1)
variabl18531--;
for (int i = pos; i < variabl1853 - 1; i++) {
for (int j = 0; j < variabl1843 - 1; j++) {
variabl2197[i][j] = variabl2197[i + 1][j];
}
}
variabl1853--;
}
}
https://blog.sciencenet.cn/blog-2551-1117437.html
上一篇：管理信息系统软件生产线源码32-36
下一篇：管理信息系统软件生产线源码41-45
全部作者的精选博文
全部作者的其他最新博文
全部精选博文导读
相关博文
- • 聚英才 建高地 | 北京理工大学“特立青年学者”全球招聘开启
- • 700年后日本或濒临灭绝？日本学者推算预测：届时或仅剩1名15岁以下孩子
- • [转载]【同位素视角】非英语母语学者如何区分’e.g.’, ‘i.e.’, ‘namely’与‘such as’等混淆难题
- • 美国佐治亚大学等机构学者：刈割策略对Bulldog 805紫花苜蓿+Tifton 85狗牙根混播草地产量及品质的影响
- • 美国堪萨斯州立大学、密苏里大学等机构学者研究成果：土壤水分管理策略和品种多样性对紫花苜蓿产量、营养品质和农场盈利能力的影
- • 德国、捷克草业科学学者长期放牧实验：异质草地斑块中的土壤有机碳储量和地下生物量