版本1
9.源码9，公共表格数据显示程序
/*
 * 作者：程传庆
 * 功能：共用查询结果显示程序。
 * 完成日期：2013年10月11日
 * 调用本程序命令格式：tableTenance.tableModel(窗口宽,窗口高,表格列名,列宽度,表格数据,表列数据类型);
 * 程序功能：以表格形式显示数据，可进行对单字段排序也可对多字段排序之后显示表格数据，
 * 还可以对传送过来的数据做打印预览或打印操作。按字段宽度以固定方式定义打印格式。
 * 打印预览调用dataPreview0.java程序实现，打印通过调用JAVA自身表格类的打印程序实现。
 * 这些打印功能比较简单，只用于打印要求不高的场合，要求较高的打印请调用专门打印部件程序实现。
 * 排序通过“索引”按钮程序实现，操作时先在表格中点击欲排序的某一列任意位置，
 * 再点击“索引”按钮，实现按该列排序显示。如果还想在满足所选第一列字段排序的情况下再按新字段排序，
 * 可通过“接续索引”按钮实现。
 * “接续索引”的意义是在前面所有排序相同情况下再按新的某一列排序。
 * 操作时先点击已排序外某一列任意位置，再点击“接续索引”按钮实现按多字段从小到大排序。
 * 本程序还用于单记录数据维护部件程序，如果记录条数很多，一条条移动指针位置效率很低。
 * 可以调用本程序，以表格形式显示全部记录，拖动滚动条，将指针快速移动到需要记录位置，
 * 再点击本程序“退出”按钮，在返回主程序同时将“当前行行号”数值返回主程序，
 * 再点击“上一条”或“下一条”按钮，实现将指针快速移动到新的记录上。
 * 要求按钮号表数据两边预加逗号
 */
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;

public class tableTenance extends JFrame {
 static String[][] 表格数据1;
 static String[][] 排序数据;
 static String[][] 排序备份;
 static String[][] 备份数据;
 static int 记录条数;
 static int 起始序号 = 0, 终了序号 = 0, 当前列号 = 0, 上次列号 = 0;
 static int 表格列数;
 static JButton sortButton1, sortButton, printButton, exitButton;
 static String[] rowValues;
 static String[] 列名0;
 static int[] 列宽度0;

 static void tableModel(int 窗口宽度, int 窗口高度, String[] 列名3, int[] 列宽度,
   String[][] 表格数据, String[] 表列数据类型) {
  列名0 = new String[列名3.length];
  列宽度0 = new int[列名3.length];
  for (int i = 0; i < 列名3.length; i++) {
   列名0[i] = 列名3[i];
   列宽度0[i] = 列宽度[i];
  }
  起始序号 = 0;
  终了序号 = 0;
  当前列号 = 0;
  上次列号 = 0;
  if (窗口高度 > 600)
   窗口高度 = 600;
  final tableTenance frame = new tableTenance(); // 创建窗体
  final JTable table;
  final DefaultTableModel model;
  frame.setTitle("表格式显示部件                          作者：程传庆"); // 设置窗体标题
  frame.setBounds(10, 10, 窗口宽度, 窗口高度); // 设置窗体的位置和大小
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
  frame.setVisible(true); // 显示窗体
  final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
  scrollPane.setBounds(10, 10, 窗口宽度 - 20, 窗口高度 - 100); // 定义滚动面板大小位置
  frame.setLayout(null);
  frame.getContentPane().add(scrollPane); // 在窗体中央添加滚动面板
  int j = 5;
  int 按钮宽 = (窗口宽度 - 50) / j;
  int 按钮左边距 = 5;
  表格列数 = 列名0.length;
  记录条数 = 表格数据.length;
  rowValues = new String[表格列数]; // 准备添加到表格的一行记录
  备份数据 = new String[记录条数][表格列数];
  表格数据1 = new String[记录条数][表格列数];
  int b = 0;
  for (int c = 0; c < 记录条数; c++)
   for (b = 0; b < 表格列数; b++) {
    备份数据[c][b] = 表格数据[c][b];
    表格数据1[c][b] = 表格数据[c][b];
   }
  model = new DefaultTableModel(表格数据1, 列名0); // 建立表格模型
  table = new JTable(model);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
  for (int i = 0; i < 列名0.length; i++) {
   TableColumn tc = table.getColumn(列名0[i]);// 返回表格的列对象
   JTableHeader header = table.getTableHeader();
   if (列宽度[i] < 列名0[i].length())
    列宽度[i] = 列名0[i].length();
   tc.setPreferredWidth(列宽度[i] * 9);
   tc.setMaxWidth(列宽度[i] * 9);
  }
  scrollPane.setViewportView(table); // 把表格添加到滚动面板中
  table.addMouseListener(new MouseAdapter() {
   public void mouseClicked(MouseEvent e) {
    main1.当前行行号 = table.getSelectedRow();
   }
  });

  排序数据 = new String[记录条数][表格列数 + 1];
  排序备份 = new String[记录条数][表格列数 + 1];
  for (b = 0; b < 表格列数; b++) {
   for (int c = 0; c < 记录条数; c++) {
    if (备份数据[c][b] == null)
     排序数据[c][b] = "";
    else
     排序数据[c][b] = 备份数据[c][b];
   }
   if (表列数据类型[b].compareTo("int") == 0) {
    for (int c = 0; c < 记录条数; c++) {
     排序数据[c][b] = "0000000000" + 排序数据[c][b];
     排序数据[c][b] = 排序数据[c][b].substring(排序数据[c][b].length() - 10);
    }
   } else if ((表列数据类型[b].compareTo("float") == 0)
     || (表列数据类型[b].compareTo("numeric") == 0)) {
    for (int c = 0; c < 记录条数; c++) {
     排序数据[c][b] = "0000000000" + 排序数据[c][b];
     int k1 = 排序数据[c][b].lastIndexOf('.');
     if (k1 == -1) { // 原数为整数，无小数点
      k1 = 排序数据[c][b].length();
      排序数据[c][b] = 排序数据[c][b] + ".000000";
     } else
      排序数据[c][b] = 排序数据[c][b] + "000000";
     排序数据[c][b] = 排序数据[c][b].substring(k1 - 10, k1 + 1)
       + 排序数据[c][b].substring(k1 + 1, k1 + 6);
    }
   }
  }
  for (int c = 0; c < 记录条数; c++)
   排序数据[c][表格列数] = "" + c;
  for (int c = 0; c < 记录条数; c++)
   for (b = 0; b < 表格列数 + 1; b++)
    排序备份[c][b] = 排序数据[c][b];

  起始序号 = 0;
  终了序号 = 0;
  sortButton = new JButton("排序"); // 定义排序按钮
  sortButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    rowValues = new String[表格列数];
    if (sortButton.getText().trim().equals("排序")) {
     if (table.getSelectedColumn() < 0)
      JOptionPane.showMessageDialog(null,
        "请先点击要排序的某一列，再按本按钮！");
     else {
      sortButton.setText("还原");
      sortButton1.setEnabled(true);
      上次列号 = table.getSelectedColumn();
      当前列号 = table.getSelectedColumn();
     }
     String s;
     int i, j, k = 0;
     for (int c = 0; c < 记录条数; c++) {
      for (i = 0; i < 记录条数 - c - 1; i++) {
       if (排序数据[i][当前列号].compareTo(排序数据[i + 1][当前列号]) > 0)
        for (j = 0; j <= 表格列数; j++) {
         s = 排序数据[i][j];
         排序数据[i][j] = 排序数据[i + 1][j];
         排序数据[i + 1][j] = s;
        }
      }
     }
     model.setRowCount(0);

     for (int c = 0; c < 记录条数; c++) {
      int n = Integer.parseInt(排序数据[c][表格列数]);
      for (int b = 0; b < 表格列数; b++) {
       表格数据1[c][b] = 备份数据[n][b];
       rowValues[b] = 备份数据[n][b];
      }
      model.addRow(rowValues);
     }
    } else {
     sortButton.setText("排序");
     sortButton1.setEnabled(false);
     model.setRowCount(0);
     for (int c = 0; c < 记录条数; c++) {
      for (int b = 0; b < 表格列数; b++) {
       rowValues[b] = 备份数据[c][b];
       排序数据[c][b] = 排序备份[c][b];
      }
      model.addRow(rowValues);
      排序数据[c][表格列数] = 排序备份[c][表格列数];
     }
    }
   }
  });

  sortButton.setBounds(按钮左边距, 窗口高度 - 80, 按钮宽 - 10, 20);
  frame.add(sortButton);
  按钮左边距 = 按钮左边距 + 按钮宽;

  sortButton1 = new JButton("接续排序");
  sortButton1.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    当前列号 = table.getSelectedColumn();
    String s = "", s1 = 排序数据[0][上次列号];
    int n1 = 0, n2 = 0;
    int i, j, k = 0;
    for (int c = 0; c < 记录条数; c++) {
     if ((c == 记录条数 - 1)
       || (s1.compareTo(排序数据[c + 1][上次列号]) != 0)) {
      if (c < 记录条数 - 1)
       s1 = 排序数据[c + 1][上次列号];
      n2 = c;

      for (i = n1; i < n2; i++) {
       for (j = n1; j < n2 + n1 - i; j++) {
        if (排序数据[j][当前列号].compareTo(排序数据[j + 1][当前列号]) > 0)
         for (k = 0; k <= 表格列数; k++) {
          s = 排序数据[j][k];
          排序数据[j][k] = 排序数据[j + 1][k];
          排序数据[j + 1][k] = s;
         }
       }
      }
      n1 = n2 + 1;
     }
    }
    上次列号 = 当前列号;
    model.setRowCount(0);
    for (int c = 0; c < 记录条数; c++) {
     int n = Integer.parseInt(排序数据[c][表格列数]);
     for (int b = 0; b < 表格列数; b++) {
      rowValues[b] = 备份数据[n][b];
     }
     model.addRow(rowValues);
    }

   }
  });
  sortButton1.setBounds(按钮左边距, 窗口高度 - 80, 按钮宽 - 5, 20);
  frame.add(sortButton1);
  按钮左边距 = 按钮左边距 + 按钮宽;
  sortButton1.setEnabled(false);

  JButton printButton0 = new JButton("打印预览");
  printButton0.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    try {
     dataPreview0.printView1(列名0, 备份数据, 列宽度0, "表格预览");
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "打印预览失败！");
    }
   }
  });
  printButton0.setBounds(按钮左边距, 窗口高度 - 80, 按钮宽 - 5, 20);
  frame.add(printButton0);
  // 加入打印预览按钮
  按钮左边距 = 按钮左边距 + 按钮宽;
  printButton = new JButton("打印");
  printButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    try {
     table.print();
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "打印失败！");
    }
   }
  });
  printButton.setBounds(按钮左边距, 窗口高度 - 80, 按钮宽 - 5, 20);
  frame.add(printButton);
  ; // 加入打印按钮
  按钮左边距 = 按钮左边距 + 按钮宽;

  exitButton = new JButton("退            出");
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    // main1.当前行行号=table.getSelectedRow();
    // System.out.println("main1.当前行行号="+main1.当前行行号);
    frame.setVisible(false);
    return;
   }
  });
  exitButton.setBounds(按钮左边距, 窗口高度 - 80, 按钮宽 - 5, 20);
  frame.add(exitButton);
  按钮左边距 = 按钮左边距 + 按钮宽;
 }
}

10.源码10，公共程序：单数据表的表格式报表打印预览
/*
 * 作者：程传庆
 * 程序功能：单数据表的表格式报表打印预览，内容只限表格数据中数据。
 * 要求在上级程序中生成表格数据，根据所传过来字段数据与所定义的宽度以固定格式实现打印。
 * 主要参数：String[] 列名,String[][] 表格数据,int[] 字段宽度，String 标题
 * 调用命令：dataPreview0.printView1(列名，表格数据,字段宽度，标题);
 */
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JComponent;
import javax.swing.JFrame;

public class dataPreview0 extends JComponent {
 private static JFrame frameView;
 private static int[] 字段宽度;
 private static String 表格标题;
 private static String[][] 表格数据;
 private static String[] 列名;
 private static int 标题字号 = 32;
 private static int x1 = 0, y1 = 0, w1 = 0, h1 = 0;
 private static Graphics2D g3;
 private static int 页宽 = 800;

 protected void paintComponent(Graphics g) {
  g3 = (Graphics2D) g;
  g3 = (Graphics2D) g;
  g3.setFont(new Font("宋体", Font.PLAIN, 标题字号));
  g3.drawString(表格标题, (页宽 - 表格标题.length()) / 2, 30);
  int 表格宽度 = 0;
  for (int i = 0; i < 字段宽度.length; i++)
   表格宽度 = 表格宽度 + 字段宽度[i];
  int 表格字号 = (页宽 - 80) / 表格宽度;
  x1 = 30;
  y1 = 标题字号 + 50;
  h1 = (int) (表格字号 * 1.2);
  g3.setFont(new Font("宋体", Font.PLAIN, 表格字号));
  for (int i = 0; i < 列名.length; i++) {
   w1 = 字段宽度[i] * 表格字号;
   g3.drawLine(x1, y1, x1 + w1, y1);
   g3.drawLine(x1, y1, x1, y1 + h1);
   g3.drawString(列名[i], x1 + 4, y1 + 表格字号);
   g3.drawLine(x1, y1 + h1, x1 + w1, y1 + h1);
   g3.drawLine(x1 + w1, y1, x1 + w1, y1 + h1);
   x1 = x1 + w1;
  }
  y1 = y1 + h1;
  h1 = (int) (表格字号 * 1.2);
  for (int i = 0; i < 表格数据.length; i++) {
   x1 = 30;
   g3.drawLine(x1, y1, x1, y1 + h1);
   for (int j = 0; j < 列名.length; j++) {
    w1 = 字段宽度[j] * 表格字号;
    if (表格数据[i][j] == null)
     表格数据[i][j] = " ";
    g3.drawString(表格数据[i][j], x1 + 4, y1 + 表格字号);
    g3.drawLine(x1, y1 + h1, x1 + w1, y1 + h1);
    g3.drawLine(x1 + w1, y1, x1 + w1, y1 + h1);
    x1 = x1 + w1;
   }
   y1 = y1 + h1;
  }
 }

 public static void printView1(String[] 列名1, String[][] 表格数据1, int[] 字段宽度1,
   String 标题) {
  表格标题 = 标题;
  表格数据 = new String[表格数据1.length][列名1.length];
  列名 = new String[列名1.length];
  字段宽度 = new int[列名1.length];
  for (int i = 0; i < 表格数据1.length; i++)
   for (int j = 0; j < 列名1.length; j++)
    表格数据[i][j] = 表格数据1[i][j];
  for (int j = 0; j < 列名1.length; j++) {
   列名[j] = 列名1[j];
   字段宽度[j] = 字段宽度1[j];
  }
  frameView = new JFrame("报表预览程序             作者：程传庆");
  frameView.setBounds(10, 10, 1000, 1000);
  frameView.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frameView.add(new dataPreview0());
  frameView.setVisible(true);
 }
}

11.源码11.部件程序，利用二个指定的字段和表达式进行单数据表二固定条件查询。
/**
 * 程序文件名：dataQuery5.java
 * 作者：程学先
 * 完成时间：2013年11月27日
 * 部件功能：利用二个指定的字段和表达式进行单数据表二固定条件查询。
 * 被调用语句：datadataQuery5.means(parameter);
 * 必须提供的参数：“数据表表名”、“查询字段号1”、“查询字段号2”、“关系符1”
 *            “关系符2”，这些参数由主程序带入。
 * 操作方法与注意事项：因为该部件要求对指定的字段和指定的表达式查询，所以在“数据表表名”、
 *              “查询字段号1”、“查询字段号2”处各只允许输入一个参数，且必须输入一个参数。
 *              “关系符1”、“关系符2”的参数各只能从{"大于"、"小于"、"等于"、大于等于"、
 *              小于等于"、"不等于"、"包含"、"不包含"}中选择一个，如果输入错误
 *              会导致程序显示错误或无法进行查询。
 */

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;

import java.sql.*;

public class dataQuery5 extends JFrame {
 static dataQuery5 frame = new dataQuery5();
 static String 表名 = "";
 static DefaultTableModel tableModel;
 static JTable table;
 static JScrollPane scrollPane = new JScrollPane();
 static JTextField aTextField, aTextField2;
 static JButton b1, b2;
 static String s1 = "";
 static ResultSet rs;
 static int b = 0, c = 0;
 static int 列数;
 static int 表格列数;
 static String[] 列名;
 static String[][] 关系表 = { { " > ", "大于" }, { " < ", "小于" },
   { " = ", "等于" }, { " >= ", "大于等于" }, { " <= ", "小于等于" },
   { "<>", "不等于" }, { " like ", "包含" }, { " not like ", "不包含" } };
 static String[] 表格列名;
 static String[] 列标题;
 static String[] 列数据类型;
 static String[] 表列数据类型;
 static int[] 列数据宽度;
 static int[] 表列数据宽度;
 static int 记录条数, 记录条数1;
 static int 列序号, 列序号1;
 static String 关系符, 关系符1;
 static String[][] 表格数据;// 存放表格数据的数组
 static String 字段名字串;
 static String[] 字段号表;

 static int 左边距 = 80;
 static String 打印格式文件名;

 static Connection con; // 连接数据库
 static ResultSetMetaData rsmd3;
 static Statement sta3;
 static int 窗口宽 = 1000, 窗口高 = 700;
 static JButton printViewButton, printButton;
 static String[] 按钮集 = null;
 static String 要求按钮号表;
 static int 按钮数 = 0, 按钮宽 = 0;

 public static void means(String[] parameter) {
  frame = new dataQuery5();
  表名 = "";
  scrollPane = new JScrollPane();
  s1 = "";
  b = 0;
  c = 0;
  关系符 = "";
  关系符1 = "";
  左边距 = 80;
  窗口宽 = 1000;
  窗口高 = 700;
  关系表[0][0] = " > ";
  关系表[0][1] = "大于";
  关系表[1][0] = " < ";
  关系表[1][1] = "小于";
  关系表[2][0] = " = ";
  关系表[2][1] = "等于";
  关系表[3][0] = " >= ";
  关系表[3][1] = "大于等于";
  关系表[4][0] = " <= ";
  关系表[4][1] = "小于等于";
  关系表[5][0] = " <> ";
  关系表[5][1] = "不等于";
  关系表[6][0] = " like ";
  关系表[6][1] = "包含";
  关系表[7][0] = " not like ";
  关系表[7][1] = "不包含";

  String[] 按钮集01 = { "查询", "打印预览", "打印", "退出" };
  按钮集 = new String[按钮集01.length];
  按钮数 = 0;
  for (int i0 = 0; i0 < 按钮集01.length; i0++)
   按钮集[i0] = 按钮集01[i0];
  if (parameter[11].length() > 0) {
   要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号
   // 将中文分号、冒号、句号、英文分号统一为英文分号
   要求按钮号表 = 要求按钮号表.replaceAll("；", ";");
   要求按钮号表 = 要求按钮号表.replaceAll("。", ";");
   要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
   要求按钮号表 = 要求按钮号表.replaceAll("：", ";");
   if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求
    String s601[] = 要求按钮号表.split(",");
    要求按钮号表 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (s601[i01].indexOf(";") > 0) {
      String s602[] = s601[i01].split(";");
      按钮集[Integer.parseInt((s602[0]))] = s602[1];
      要求按钮号表 = 要求按钮号表 + "," + s602[0];// 只留号，去更名
      按钮数++;
     } else {
      要求按钮号表 = 要求按钮号表 + "," + s601[i01];// 只留号，原无更名
      按钮数++;
     }
    }
   } // 如果没有按钮更名要求，要求按钮号长度又大于0，保持原有摸样
   else {
    String s601[] = 要求按钮号表.split(",");
    要求按钮号表 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (i01 == 0)
      要求按钮号表 = s601[i01];
     else
      要求按钮号表 = 要求按钮号表 + "," + s601[i01];
     按钮数++;
    }
   }
  } else {
   要求按钮号表 = ""; // 没输入要求按钮号，定全部按钮号
   for (int i1 = 0; i1 < 按钮集.length; i1++) {
    if (i1 == 0)
     要求按钮号表 = 要求按钮号表 + i1;
    else
     要求按钮号表 = 要求按钮号表 + "," + i1;
    按钮数++;
   }
  }
  要求按钮号表 = "," + 要求按钮号表 + ",";
  窗口宽 = 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) {
  }
  列序号 = Integer.valueOf(parameter[9]);
  列序号1 = Integer.valueOf(parameter[10]);
  关系符 = parameter[12];
  关系符1 = parameter[13];
  表名 = parameter[4]; // 数据表名
  打印格式文件名 = parameter[15];
  字段名字串 = parameter[19];
  if (字段名字串.lastIndexOf(",") == 字段名字串.length() - 1)
   字段名字串 = 字段名字串.substring(0, 字段名字串.length() - 1);
  String[] s6 = 字段名字串.split(",");
  String 指定的字段名 = s6[列序号];
  String 指定的字段名1 = s6[列序号1];
  String s2 = "";
  if (parameter[8].length() > 0) {
   字段号表 = parameter[8].split(",");
   列名 = new String[字段号表.length];
   for (int i = 0; i < 字段号表.length; i++) {
    列名[i] = s6[Integer.parseInt(字段号表[i])];
    if (s2.length() > 0)
     s2 = s2 + "," + 列名[i];
    else
     s2 = 列名[i];
   }
   字段名字串 = s2;
  } else {
   列名 = new String[s6.length];
   for (int i = 0; i < s6.length; i++) {
    列名[i] = s6[i];
    if (s2.length() > 0)
     s2 = s2 + "," + 列名[i];
    else
     s2 = 列名[i];
   }
   字段名字串 = s2;
   s2 = " * ";
  }
  try {
   con = main1.getConn();// 连接数据库
   sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
     ResultSet.CONCUR_UPDATABLE);
   ResultSet rs = sta3.executeQuery("select " + s2 + " from " + 表名);
   rsmd3 = rs.getMetaData();
   列数 = rsmd3.getColumnCount();
   列数据类型 = new String[列数]; // 定义列字段类型数组
   列数据宽度 = new int[列数]; // 定义列数据宽度
   列序号 = -1;
   列序号1 = -1;
   for (int i = 0; i < 列数; i++) {
    列数据类型[i] = rsmd3.getColumnTypeName(i + 1); // 获取列数据类型名存到数组中
    列数据宽度[i] = rsmd3.getColumnDisplaySize(i + 1);
    if (列数据宽度[i] < 列名[i].length())
     列数据宽度[i] = 列名[i].length();
    if (列数据宽度[i] > 50)
     列数据宽度[i] = 50;
    if (("," + 列名[i] + ",").lastIndexOf("," + 指定的字段名 + ",") >= 0)
     列序号 = i;
    if (("," + 列名[i] + ",").lastIndexOf("." + 指定的字段名 + ",") >= 0)
     列序号 = i;
    if (("," + 列名[i] + ",").lastIndexOf("," + 指定的字段名1 + ",") >= 0)
     列序号1 = i;
    if (("," + 列名[i] + ",").lastIndexOf("." + 指定的字段名1 + ",") >= 0)
     列序号1 = i;
    b++;
   }
   if (列序号 < 0) {
    JOptionPane.showMessageDialog(null, "查询要求字段未包含在所选字段号表中，没法查询！");
    return;
   }
   if (列序号1 < 0) {
    JOptionPane.showMessageDialog(null, "查询要求字段未包含在所选字段号表中，没法查询！");
    return;
   }

   int rowNumber = 0; // 记录条数
   rs.last();
   rowNumber = rs.getRow();
   表格数据 = new String[rowNumber][列数];
   rs.absolute(1);
   c = 0; // 行号
   b = 0; // 列号
   while (c < rowNumber) {
    rs.absolute(c + 1);
    while (b < 列数) {
     表格数据[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close(); // 关闭查询结果集
   sta3.close(); // 关闭连接
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "连接数据库出错！");
  }

  frame.setTitle("查询部件程序                                作者：程学先"); // 窗口标题
  frame.setBounds(10, 10, 窗口宽 - 10, 窗口高 + 20); // 窗口位置大小
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
  frame.getContentPane().setLayout(null); // 关闭窗口布局管理器
  final JPanel panel = new JPanel(false); // 定义面板
  panel.setLayout(null); // 关闭面板布局管理器
  panel.setBounds(20, 20, 窗口宽 - 50, 窗口高 + 20);
  tableModel = new DefaultTableModel(表格数据, 列名); // 创建表格模型
  table = new JTable(tableModel); // 创建指定表格模型的表格
  table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);// 设置表格的选择模式为单选
  scrollPane.getViewport().add(table, null); // 表格加滚动条
  scrollPane.setBounds(30, 70, 窗口宽 - 100, 窗口高 - 150);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  for (int i = 0; i < 列数; i++) {
   TableColumn tc = table.getColumn(列名[i]);// 返回表格的列对象
   tc.setPreferredWidth(列数据宽度[i] * 12);
  }
  panel.add(scrollPane); // 滚动条加到面板中
  JLabel label1 = new JLabel(列名[列序号]); // 用标签显示指定的字段名 列名[列序号]
  label1.setBounds(左边距, 10, 列名[列序号].length() * 15, 20);
  panel.add(label1);
  左边距 = 左边距 + 列名[列序号].length() * 15;
  JLabel label2 = new JLabel(关系符);// 用标签显示指定表达式
  label2.setBounds(左边距, 10, 关系符.length() * 15, 20);
  panel.add(label2);
  左边距 = 左边距 + 关系符.length() * 15;
  aTextField = new JTextField("", 10); // 定义文本框，预设值
  aTextField.setBounds(左边距, 10, 150, 20);
  panel.add(aTextField);
  左边距 = 左边距 + 150;

  JLabel label3 = new JLabel(列名[列序号1]); // 用标签显示指定的字段名
  label3.setBounds(左边距, 10, 列名[列序号1].length() * 15, 20);
  panel.add(label3);
  左边距 = 左边距 + 列名[列序号1].length() * 15;

  JLabel label4 = new JLabel(关系符1);// 用标签显示指定表达式
  label4.setBounds(左边距, 10, 关系符1.length() * 15, 20);
  panel.add(label4);
  左边距 = 左边距 + 关系符1.length() * 15;

  aTextField2 = new JTextField("    ", 10);
  aTextField2.setBounds(左边距, 10, 150, 20);
  panel.add(aTextField2);

  按钮宽 = (窗口宽 - 380) / 按钮数;
  int 左边距 = 350;
  final JButton selectButton = new JButton(按钮集[0]); // 查询
  selectButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    String 关系符0 = "", 关系符01 = "";
    try {
     con = main1.getConn();// 连接数据库
     sta3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     for (int i = 0; i < 关系表.length; i++) {
      if (关系表[i][1].trim().equals(关系符.trim())) {
       关系符0 = 关系表[i][0];
      }
      if (关系表[i][1].trim().equals(关系符1.trim())) {
       关系符01 = 关系表[i][0];
      }
     }
     String s1 = "select * from " + 表名 + " where " + 列名[列序号];
     String s2 = 列数据类型[列序号];
     String s3 = aTextField.getText().trim(); // 数据值
     String s4 = 关系符0;
     if ((main1.图形数据类型.lastIndexOf(s2)) >= 0) {
      JOptionPane.showMessageDialog(null,
        "不允许使用图形与二进制数据类型作为查询条件!", "提示",
        JOptionPane.INFORMATION_MESSAGE);
      return;
     } else if (main1.数字数据类型.lastIndexOf("," + s2 + ",") >= 0) { // 数字数据类型
      if (s4.indexOf("like") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字数据类型不能进行模式匹配！", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      } else {
       s1 = s1 + s4 + s3.trim();
      }
     } else if (main1.文本数据类型.lastIndexOf(s2) >= 0) { // 判断如果是大数据类型
      if (s4.indexOf("like") >= 0) {
       s3 = " '%" + s3 + "%'";
       s1 = s1 + s4 + s3;
      } else {
       JOptionPane.showMessageDialog(null,
         "文本类大数据类型只能用包含或不包含进行查询", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      }
     } else { // 如果查询对象是字符类型、日期类型
      if (s4.indexOf("like") >= 0)
       s3 = "%" + s3 + "%";
      else {
       if ((s2.indexOf("datetime") >= 0)
         && (s3.length() < 10)) {
        JOptionPane.showMessageDialog(null,
          "日期时间类型进行查询时数据格式必须为yyyy-yy-dd", "提示",
          JOptionPane.INFORMATION_MESSAGE);
        return;
       } else if ((s2.equals("datetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000";
       else if ((s2.equals("smalldatetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.00";
       else if ((s2.indexOf("datetimeoffset") >= 0)
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000 +08:00";
      }
      s1 = s1 + s4 + "'" + s3 + "'";
     }
     s1 = s1 + " and " + 列名[列序号1] + " ";
     s2 = 列数据类型[列序号1];
     s3 = aTextField2.getText().trim(); // 数据值
     s4 = 关系符01;
     if ((main1.图形数据类型.lastIndexOf(s2)) >= 0) {
      JOptionPane.showMessageDialog(null,
        "不允许使用图形与二进制数据类型作为查询条件!", "提示",
        JOptionPane.INFORMATION_MESSAGE);
      return;
     } else if (main1.数字数据类型.lastIndexOf("," + s2 + ",") >= 0) { // 数字数据类型
      if (s4.indexOf("like") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字数据类型不能进行模式匹配！", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      } else {
       s1 = s1 + s4 + s3.trim();
      }
     }

     else if (main1.文本数据类型.lastIndexOf(s2) >= 0) { // 判断如果是大数据类型
      if (s4.indexOf("like") >= 0) {
       s3 = " '%" + s3 + "%'";
       s1 = s1 + s4 + s3;
      } else {
       JOptionPane.showMessageDialog(null,
         "文本类大数据类型只能用包含或不包含进行查询", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      }
     } else { // 如果查询对象是字符类型、日期类型
      if (s4.indexOf("like") >= 0)
       s3 = "%" + s3 + "%";
      else {
       if ((s2.indexOf("datetime") >= 0)
         && (s3.length() < 10)) {
        JOptionPane.showMessageDialog(null,
          "日期时间类型进行查询时数据格式必须为yyyy-yy-dd", "提示",
          JOptionPane.INFORMATION_MESSAGE);
        return;
       } else if ((s2.equals("datetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000";
       else if ((s2.equals("smalldatetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.00";
       else if ((s2.indexOf("datetimeoffset") >= 0)
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000 +08:00";
      }
      s1 = s1 + s4 + "'" + s3 + "'";
     }

     ResultSet rs = sta3.executeQuery(s1);
     int rowNumber = 0; // 记录条数
     rs.last();
     rowNumber = rs.getRow();
     rsmd3 = rs.getMetaData();
     列数 = rsmd3.getColumnCount(); // 获取列数
     表格数据 = new String[rowNumber][列数];
     rs.absolute(1);
     c = 0; // 行号
     b = 0; // 列号
     while (c < rowNumber) {
      rs.absolute(c + 1);
      while (b < 列数) {
       表格数据[c][b] = rs.getString(b + 1);
       b++;
      }
      c++;
      b = 0;
     }
     rs.close(); // 关闭查询结果集
     sta3.close(); // 关闭连接
     tableModel = new DefaultTableModel(表格数据, 列名);
     table = new JTable(tableModel);
     table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
     scrollPane.setViewportView(table);
     printViewButton.setEnabled(true);
     printButton.setEnabled(true);
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "查询数据出错！" + s1);
    }
   }
  });
  selectButton.setBounds(左边距, 40, 按钮宽, 20);
  if (要求按钮号表.indexOf(",0,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(selectButton);
  }
  printViewButton = new JButton(按钮集[1]);
  printViewButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    dataPreview1.printView1(表格数据, 打印格式文件名);
   }
  });
  printViewButton.setBounds(左边距, 40, 按钮宽, 20);
  if (要求按钮号表.indexOf(",1,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(printViewButton);
   printViewButton.setEnabled(false);
  }
  printButton = new JButton(按钮集[2]);
  printButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    dataPrint1.print1(表格数据, 打印格式文件名);
   }
  });
  printButton.setBounds(左边距, 40, 按钮宽, 20);
  if (要求按钮号表.indexOf(",2,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(printButton);
   printButton.setEnabled(false);
  }

  final JButton exitButton = new JButton(按钮集[3]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    panel.setVisible(false);
    frame.setVisible(false);
    frame.dispose();
   }
  });
  exitButton.setBounds(左边距, 40, 按钮宽, 20);
  if (要求按钮号表.indexOf(",3,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(exitButton);
  }
  frame.getContentPane().add(panel, null); // 安装面板
  frame.setVisible(true); // 安装窗口
  frame.getContentPane().add(panel, BorderLayout.SOUTH);
 }
}

12.源码12.部件程序，利用二个指定的字段和表达式进行多数据表二固定条件查询。
/**
 * 程序文件名：dataQuery6.java
 * 作者：程学先
 * 完成时间：2013年12月3日
 * 部件功能：利用二个指定的字段和表达式进行多数据二固定条件查询。
 * 被调用语句：datadataQuery6.means(parameter);
 * 必须提供的参数：“数据表表名”、“查询字段号1”、“查询字段号2”、“关系符1”
 *            “关系符2”，这些参数由主程序带入。
 * 操作方法与注意事项：因为该部件要求对指定的字段和指定的表达式查询，
 *              在“表名集”中允许输入多个数据表表名，彼此间用逗号分隔。
 *              在“查询字段号1”、“查询字段号2”处各只允许输入一个参数，且必须输入一个参数。
 *              “关系符1”、“关系符2”的参数各只能从{"大于"、"小于"、"等于"、大于等于"、
 *              小于等于"、"不等于"、"包含"、"不包含"}中选择一个，如果输入错误
 *              会导致程序显示错误或无法进行查询。
 * 可以联系代码表进行查询。如果涉及代码表，在填表名时，应当先在列表框中选主表，再依次选代码表。
 * 可涉及字典表，将根据字典表给定的对应关系变换标签，在填表名时不要输入字典表的名称。
 * 但是，要求在当前数据库中有一个表的名字为某某某字典表，即表名最后3个字是“字典表”，本程序将根据该表变换。
 * 要求该表中只有二个字段，第一个字段（命名为字段名）中内容为所查询的数据表中字段名，
 * 第二个字段（命名为标签名）内容为变换后的标签名。
 * 在当前数据库中最好不要有第二个名字中带“字典名”的表，如果必须有，请恰当取名，使本程序需要的字典表
 * 在表名表中排在前面。
 *
 */
import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.table.*;

import java.sql.*;

public class dataQuery6 extends JFrame {
 static dataQuery6 frame = new dataQuery6();
 static String 表名;
 static String 字典表名;
 static String 表名表;
 static DefaultTableModel tableModel;
 static JTable table;
 static JScrollPane scrollPane = new JScrollPane();
 static JTextField aTextField, aTextField2;
 static JButton b1, b2;
 static String s1 = "";
 static ResultSet rs;
 static int b = 0, c = 0;
 static int 列数;
 static int 表格列数;
 static String[][] 列名;
 static String 指定的字段名 = "", 字段名串 = "", 字段名串1 = "";
 static String[][] 关系表 = { { " > ", "大于" }, { " < ", "小于" },
   { " = ", "等于" }, { " >= ", "大于等于" }, { " <= ", "小于等于" },
   { "<>", "不等于" }, { " like ", "包含" }, { " not like ", "不包含" } };
 static String[] 列标题;
 static String[] 列数据类型;
 static String[] 表列数据类型;
 static int[] 列数据宽度;
 static int[] 表列数据宽度;
 static int 记录条数, 记录条数1;
 static String[][] 表格数据;
 static String[] 字段号表;

 static String 关系符, 关系符0, 关系符1, 关系符01;
 static int 列序号 = 0, 列序号1 = 0;
 static String 连接条件;
 static String 字段名字串;
 static int 左边距 = 80;

 static Connection con; // 连接数据库
 static ResultSetMetaData rsmd3;
 static Statement sta3;
 static int 窗口宽 = 1000, 窗口高 = 600;// 窗口高
 static int 按钮数 = 0, 按钮宽 = 0;
 static String[] 按钮集 = null;
 static String 要求按钮号表;

 public static void means(String[] parameter) {
  frame = new dataQuery6();
  表名 = "";
  scrollPane = new JScrollPane();
  s1 = "";
  b = 0;
  c = 0;
  关系符 = "";
  关系符1 = "";
  关系符0 = "";
  关系符01 = "";
  左边距 = 80;
  窗口宽 = 1000;
  窗口高 = 700;
  关系表[0][0] = " > ";
  关系表[0][1] = "大于";
  关系表[1][0] = " < ";
  关系表[1][1] = "小于";
  关系表[2][0] = " = ";
  关系表[2][1] = "等于";
  关系表[3][0] = " >= ";
  关系表[3][1] = "大于等于";
  关系表[4][0] = " <= ";
  关系表[4][1] = "小于等于";
  关系表[5][0] = " <> ";
  关系表[5][1] = "不等于";
  关系表[6][0] = " like ";
  关系表[6][1] = "包含";
  关系表[7][0] = " not like ";
  关系表[7][1] = "不包含";

  String[] 按钮集01 = { "查询", "退出" };
  按钮集 = new String[按钮集01.length];
  按钮数 = 0;
  for (int i0 = 0; i0 < 按钮集01.length; i0++)
   按钮集[i0] = 按钮集01[i0];
  if (parameter[11].length() > 0) {
   要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号
   // 将中文分号、冒号、句号、英文分号统一为英文分号
   要求按钮号表 = 要求按钮号表.replaceAll("；", ";");
   要求按钮号表 = 要求按钮号表.replaceAll("。", ";");
   要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
   要求按钮号表 = 要求按钮号表.replaceAll("：", ";");
   if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求
    String s601[] = 要求按钮号表.split(",");
    要求按钮号表 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (s601[i01].indexOf(";") > 0) {
      String s602[] = s601[i01].split(";");
      按钮集[Integer.parseInt((s602[0]))] = s602[1];
      要求按钮号表 = 要求按钮号表 + "," + s602[0];// 只留号，去更名
      按钮数++;
     } else {
      要求按钮号表 = 要求按钮号表 + "," + s601[i01];// 只留号，原无更名
      按钮数++;
     }
    }
   } // 如果没有按钮更名要求，要求按钮号长度又大于0，保持原有摸样
   else {
    String s601[] = 要求按钮号表.split(",");
    要求按钮号表 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (i01 == 0)
      要求按钮号表 = s601[i01];
     else
      要求按钮号表 = 要求按钮号表 + "," + s601[i01];
     按钮数++;
    }
   }
  } else {
   要求按钮号表 = ""; // 没输入要求按钮号，定全部按钮号
   for (int i1 = 0; i1 < 按钮集.length; i1++) {
    if (i1 == 0)
     要求按钮号表 = 要求按钮号表 + i1;
    else
     要求按钮号表 = 要求按钮号表 + "," + i1;
    按钮数++;
   }
  }
  要求按钮号表 = "," + 要求按钮号表 + ",";
  窗口宽 = 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[12];
  关系符1 = parameter[13];
  列序号 = Integer.valueOf(parameter[9]);
  列序号1 = Integer.valueOf(parameter[10]);
  表名 = parameter[4];
  连接条件 = parameter[20];
  列名 = new String[2][];

  字段名字串 = parameter[19];
  if (字段名字串.lastIndexOf(",") == 字段名字串.length() - 1)
   字段名字串 = 字段名字串.substring(0, 字段名字串.length() - 1);
  String[] s6 = 字段名字串.split(",");
  String 指定的字段名 = s6[列序号];
  String 指定的字段名1 = s6[列序号1];

  String s2 = "";
  if (parameter[8].length() > 0) {
   字段号表 = parameter[8].split(",");
   列名 = new String[2][字段号表.length];
   for (int i = 0; i < 字段号表.length; i++) {
    列名[0][i] = s6[Integer.parseInt(字段号表[i])];
    列名[1][i] = 列名[0][i];
    if (s2.length() > 0)
     s2 = s2 + "," + 列名[0][i];
    else
     s2 = 列名[0][i];
   }
   字段名字串 = s2;
  } else {
   列名 = new String[2][s6.length];
   for (int i = 0; i < s6.length; i++) {
    列名[0][i] = s6[i];
    列名[1][i] = s6[i];
    if (s2.length() > 0)
     s2 = s2 + "," + 列名[0][i];
    else
     s2 = 列名[0][i];
   }
   s2 = " * ";
  }
  String s11 = 表名;
  if (表名.indexOf(",") > 0) {
   String[] s12 = 表名.split(",");
   s11 = s12[0];
  }
  表名表 = parameter[0];
  String[] t1;
  字典表名 = "";
  if (表名表.lastIndexOf(s11 + "字典表") > 0) {
   t1 = 表名表.split(",");
   for (int i = 0; i < t1.length; i++)
    if (t1[i].lastIndexOf(s11 + "字典表") >= 0)
     字典表名 = t1[i];
  }
  if (字典表名.length() > 0) {
   try {
    con = main1.getConn();
    sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select * from " + 字典表名;
    rs = sta3.executeQuery(s1);
    ResultSetMetaData rsmd = rs.getMetaData();
    int 列数0 = rsmd.getColumnCount();
    int numberOfColumns = rsmd.getColumnCount(); // 记录数
    String s14 = "";
    String s15 = "";
    int b = 1;
    while (rs.absolute(b)) {
     b++;
     s14 = rs.getString(1).trim(); // 字段名
     s15 = rs.getString(2).trim(); // 标签名
     for (int j = 0; j < 列名[0].length; j++) {
      if (列名[0][j].trim().equalsIgnoreCase(s14.trim())) {
       列名[1][j] = s15;
       break;
      } else if ((列名[0][j].trim() + ",").indexOf("." + s14
        + ",") > 0) {
       列名[1][j] = 列名[1][j].replace(s14, s15);
       break;
      }
     }
    }
    rs.close(); // 关闭查询结果集
    con.close();
    sta3.close();
   } catch (SQLException e) {
    JOptionPane.showMessageDialog(null, "连接数据库出错！");
   }
  }
  try {
   con = main1.getConn();// 连接数据库
   sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
     ResultSet.CONCUR_UPDATABLE);
   if (连接条件.trim().length() > 0)
    s1 = "select " + 字段名字串 + " from " + 表名 + " where " + 连接条件;
   else
    s1 = "select " + 字段名字串 + " from " + 表名;
   ResultSet rs = sta3.executeQuery(s1);
   rsmd3 = rs.getMetaData();
   列数 = rsmd3.getColumnCount(); // 获取列数
   列数据类型 = new String[列数]; // 定义列字段类型数组
   列数据宽度 = new int[列数]; // 定义列数据宽度
   列序号 = -1;
   列序号1 = -1;
   for (int i = 0; i < 列数; i++) {
    列数据类型[i] = rsmd3.getColumnTypeName(i + 1);
    列数据宽度[i] = rsmd3.getColumnDisplaySize(i + 1);
    if (列数据宽度[i] < 列名[0][i].length())
     列数据宽度[i] = 列名[0][i].length();
    if (列数据宽度[i] > 50)
     列数据宽度[i] = 50;
    if (列数据宽度[i] < 列名[0][i].length())
     列数据宽度[i] = 列名[0][i].length();
    if (列数据宽度[i] > 50)
     列数据宽度[i] = 50;
    if (("," + 列名[0][i] + ",").lastIndexOf("," + 指定的字段名 + ",") >= 0)
     列序号 = i;
    if (("," + 列名[0][i] + ",").lastIndexOf("." + 指定的字段名 + ",") >= 0)
     列序号 = i;
    if (("," + 列名[0][i] + ",").lastIndexOf("," + 指定的字段名1 + ",") >= 0)
     列序号1 = i;
    if (("," + 列名[0][i] + ",").lastIndexOf("." + 指定的字段名1 + ",") >= 0)
     列序号1 = i;
    b++;
   }
   if (列序号 < 0) {
    JOptionPane.showMessageDialog(null, "查询要求字段未包含在所选字段号表中，没法查询！");
    return;
   }
   if (列序号1 < 0) {
    JOptionPane.showMessageDialog(null, "查询要求字段未包含在所选字段号表中，没法查询！");
    return;
   }

   int rowNumber = 0; // 记录条数
   rs.last();
   rowNumber = rs.getRow();
   表格数据 = new String[rowNumber][列数];
   rs.absolute(1);
   c = 0; // 行号
   b = 0; // 列号
   while (c < rowNumber) {
    rs.absolute(c + 1);
    while (b < 列数) {
     表格数据[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close(); // 关闭查询结果集
   sta3.close(); // 关闭连接
   con.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "查询数据出错！" + s1);
  }

  frame.setTitle("查询部件程序                                作者：程学先"); // 窗口标题
  frame.setBounds(10, 10, 窗口宽 - 10, 窗口高 - 10); // 窗口位置大小
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
  frame.getContentPane().setLayout(null); // 关闭窗口布局管理器
  final JPanel panel = new JPanel(false); // 定义面板
  panel.setLayout(null); // 关闭面板布局管理器
  panel.setBounds(20, 20, 窗口宽 - 50, 窗口高 - 20);
  tableModel = new DefaultTableModel(表格数据, 列名[1]); // 创建表格模型
  table = new JTable(tableModel); // 创建指定表格模型的表格
  table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);// 设置表格的选择模式为单选
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  scrollPane.getViewport().add(table, null);
  scrollPane.setBounds(30, 60, 窗口宽 - 100, 窗口高 - 200);
  for (int i = 0; i < 列数; i++) {
   TableColumn tc = table.getColumn(列名[1][i]);// 返回表格的列对象
   tc.setPreferredWidth(列数据宽度[i] * 12);
  }
  panel.add(scrollPane);

  JLabel label1 = new JLabel(列名[1][列序号]);
  label1.setBounds(左边距, 10, 列名[1][列序号].length() * 15, 20);
  panel.add(label1);
  左边距 = 左边距 + 列名[1][列序号].length() * 15;

  JLabel label2 = new JLabel(关系符);
  label2.setBounds(左边距, 10, 关系符.length() * 15, 20);
  panel.add(label2);
  左边距 = 左边距 + 关系符.length() * 15;

  aTextField = new JTextField("", 10);
  aTextField.setBounds(左边距, 10, 150, 20);
  panel.add(aTextField);
  左边距 = 左边距 + 150;

  JLabel label3 = new JLabel(列名[1][列序号1]);
  label3.setBounds(左边距, 10, 列名[1][列序号1].length() * 15, 20);
  panel.add(label3);
  左边距 = 左边距 + 列名[1][列序号1].length() * 15;

  JLabel label4 = new JLabel(关系符1);
  label4.setBounds(左边距, 10, 关系符1.length() * 15, 20);
  panel.add(label4);
  左边距 = 左边距 + 关系符1.length() * 15;

  aTextField2 = new JTextField("", 10);
  aTextField2.setBounds(左边距, 10, 150, 20);
  panel.add(aTextField2);

  按钮宽 = (窗口宽 - 630) / 按钮数;
  int 左边距 = 600;
  final JButton selectButton = new JButton(按钮集[0]);
  selectButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    try {
     con = main1.getConn();
     sta3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     for (int i = 0; i < 关系表.length; i++) {
      if (关系表[i][1].trim().equalsIgnoreCase(关系符.trim())) {
       关系符0 = 关系表[i][0];
      }
      if (关系表[i][1].trim().equalsIgnoreCase(关系符1.trim())) {
       关系符01 = 关系表[i][0];
      }
     }
     if (字段名字串.lastIndexOf(",") == 字段名字串.length() - 1)
      字段名字串 = 字段名字串.substring(0, 字段名字串.length() - 1);
     s1 = "select " + 字段名字串 + " from " + 表名;
     if (连接条件.trim().length() > 0)
      s1 = s1 + " where " + 连接条件 + " and " + 列名[0][列序号];
     else
      s1 = s1 + " where " + 列名[0][列序号];

     String s2 = 列数据类型[列序号];
     String s3 = aTextField.getText().trim(); // 数据值
     String s4 = 关系符0;
     if ((main1.图形数据类型.lastIndexOf(s2)) >= 0) {
      JOptionPane.showMessageDialog(null,
        "不允许使用图形与二进制数据类型作为查询条件!", "提示",
        JOptionPane.INFORMATION_MESSAGE);
      return;
     } else if (main1.数字数据类型.lastIndexOf("," + s2 + ",") >= 0) { // 数字数据类型
      if (s4.indexOf("like") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字数据类型不能进行模式匹配！", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      } else {
       s1 = s1 + s4 + s3.trim();
      }
     } else if (main1.文本数据类型.lastIndexOf(s2) >= 0) { // 判断如果是大数据类型
      if (s4.indexOf("like") >= 0) {
       s3 = " '%" + s3 + "%'";
       s1 = s1 + s4 + s3;
      } else {
       JOptionPane.showMessageDialog(null,
         "文本类大数据类型只能用包含或不包含进行查询", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      }
     } else { // 如果查询对象是字符类型、日期类型
      if (s4.indexOf("like") >= 0)
       s3 = "%" + s3 + "%";
      else {
       if ((s2.indexOf("datetime") >= 0)
         && (s3.length() < 10)) {
        JOptionPane.showMessageDialog(null,
          "日期时间类型进行查询时数据格式必须为yyyy-yy-dd", "提示",
          JOptionPane.INFORMATION_MESSAGE);
        return;
       } else if ((s2.equals("datetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000";
       else if ((s2.equals("smalldatetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.00";
       else if ((s2.indexOf("datetimeoffset") >= 0)
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000 +08:00";
      }
      s1 = s1 + s4 + "'" + s3 + "'";
     }

     s1 = s1 + " and " + 列名[0][列序号1] + " ";
     s2 = 列数据类型[列序号1];
     s3 = aTextField2.getText().trim(); // 数据值
     s4 = 关系符01;
     if ((main1.图形数据类型.lastIndexOf(s2)) >= 0) {
      JOptionPane.showMessageDialog(null,
        "不允许使用图形与二进制数据类型作为查询条件!", "提示",
        JOptionPane.INFORMATION_MESSAGE);
      return;
     } else if (main1.数字数据类型.lastIndexOf("," + s2 + ",") >= 0) { // 数字数据类型
      if (s4.indexOf("like") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字数据类型不能进行模式匹配！", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      } else {
       s1 = s1 + s4 + s3.trim();
      }
     }

     else if (main1.文本数据类型.lastIndexOf(s2) >= 0) { // 判断如果是大数据类型
      if (s4.indexOf("like") >= 0) {
       s3 = " '%" + s3 + "%'";
       s1 = s1 + s4 + s3;
      } else {
       JOptionPane.showMessageDialog(null,
         "文本类大数据类型只能用包含或不包含进行查询", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      }
     } else { // 如果查询对象是字符类型、日期类型
      if (s4.indexOf("like") >= 0)
       s3 = "%" + s3 + "%";
      else {
       if ((s2.indexOf("datetime") >= 0)
         && (s3.length() < 10)) {
        JOptionPane.showMessageDialog(null,
          "日期时间类型进行查询时数据格式必须为yyyy-yy-dd", "提示",
          JOptionPane.INFORMATION_MESSAGE);
        return;
       } else if ((s2.equals("datetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000";
       else if ((s2.equals("smalldatetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.00";
       else if ((s2.indexOf("datetimeoffset") >= 0)
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000 +08:00";
      }
      s1 = s1 + s4 + "'" + s3 + "'";
     }
     System.out.println(s1);
     ResultSet rs = sta3.executeQuery(s1);
     int rowNumber = 0; // 记录条数
     rs.last();
     rowNumber = rs.getRow();
     rsmd3 = rs.getMetaData();
     列数 = rsmd3.getColumnCount();
     表格数据 = new String[rowNumber][列数];
     c = 0; // 行号
     b = 0; // 列号
     while (c < rowNumber) {
      rs.absolute(c + 1);
      while (b < 列数) {
       表格数据[c][b] = rs.getString(b + 1);
       b++;
      }
      c++;
      b = 0;
     }
     rs.close(); // 关闭查询结果集
     sta3.close(); // 关闭连接
     con.close();
     tableModel = new DefaultTableModel(表格数据, 列名[1]);
     table = new JTable(tableModel);
     table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
     scrollPane.setViewportView(table);
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "查询数据出错！" + s1);
    }
   }
  });
  selectButton.setBounds(左边距, 10, 按钮宽, 20);
  if (要求按钮号表.indexOf(",0,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(selectButton);
  }

  final JButton exitButton = new JButton(按钮集[1]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    panel.setVisible(false);
    frame.setVisible(false);
    frame.dispose();
   }
  });
  exitButton.setBounds(左边距, 10, 按钮宽, 20);
  if (要求按钮号表.indexOf(",1,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(exitButton); // 加入退出按钮
  }

  frame.getContentPane().add(panel, null); // 安装面板
  frame.setVisible(true); // 安装窗口
  frame.getContentPane().add(panel, BorderLayout.SOUTH);
 }

 public static String[] getArray(String str) {
  String[] array;
  String s1 = str;
  int i = 1;
  while (s1.indexOf(",") != -1) {
   s1 = s1.substring(s1.indexOf(",") + 1, s1.length());
   i++;
  }
  array = new String[i];
  int j = 0;
  while (str.indexOf(",") != -1) {
   array[j] = str.substring(0, str.indexOf(","));
   str = str.substring(str.indexOf(",") + 1, str.length());
   array[j + 1] = str;
   j++;
  }
  return array;
 }
}

13.源码13.部件程序，多表通用二条件查询程序。
/**
 * 程序文件名：dataQuery7.java
 * 作者：程学先
 * 完成时间：2013年12月3日
 * 部件功能：多表通用二条件查询程序。
 * 提供二组组合框供任意选择二个字段、任意二个关系符，随意组成二条件的组合进行单数据表或多数据表查询。
 * 由主程序调用。被调用语句：datadataQuery7.means(parameter);
 * 必须提供的参数：“表名集”，可以为多个数据表，包括可以有代码表，表名间用逗号分隔。这些参数由主程序带入。
 */
import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.table.*;

import java.sql.*;

public class dataQuery7 extends JFrame {
 static dataQuery7 frame = new dataQuery7();
 static String 表名;
 static String 字典表名;
 static String 表名表;
 static DefaultTableModel tableModel;
 static JTable table;
 static JScrollPane scrollPane = new JScrollPane();
 static JTextField aTextField, aTextField2;
 static JButton b1, b2;
 static Choice choice, choice1;
 static Choice choice0, choice01;
 static String s1 = "";
 static ResultSet rs;
 static int b = 0, c = 0;
 static int 列数;
 static int 表格列数;
 static String[][] 列名;
 static String 指定的字段名 = "", 字段名串 = "", 字段名串1 = "";
 static String[][] 关系表 = { { " > ", "大于" }, { " < ", "小于" },
   { " = ", "等于" }, { " >= ", "大于等于" }, { " <= ", "小于等于" },
   { "<>", "不等于" }, { " like ", "包含" }, { " not like ", "不包含" } };
 static String[] 列标题;
 static String[] 列数据类型;
 static String[] 表列数据类型;
 static int[] 列数据宽度;
 static int[] 表列数据宽度;
 static int 记录条数, 记录条数1;
 static String[][] 表格数据;
 static String 关系符, 关系符0, 关系符1, 关系符01;
 static int 列序号 = 0, 列序号1 = 0;
 static String 连接条件;
 static int 左边距 = 80;
 static String 字段名字串;
 static String[] 字段号表;
 static Connection con; // 连接数据库
 static ResultSetMetaData rsmd3;
 static Statement sta3;
 static int 窗口宽 = 1000, 窗口高 = 600;// 窗口高
 static int 按钮数 = 0, 按钮宽 = 0;
 static String[] 按钮集 = null;
 static String 要求按钮号表;

 public static void means(String[] parameter) {
  frame = new dataQuery7();
  表名 = "";
  scrollPane = new JScrollPane();
  s1 = "";
  b = 0;
  c = 0;
  关系符 = "";
  关系符1 = "";
  关系符0 = "";
  关系符01 = "";
  左边距 = 80;
  窗口宽 = 1000;
  窗口高 = 700;
  关系表[0][0] = " > ";
  关系表[0][1] = "大于";
  关系表[1][0] = " < ";
  关系表[1][1] = "小于";
  关系表[2][0] = " = ";
  关系表[2][1] = "等于";
  关系表[3][0] = " >= ";
  关系表[3][1] = "大于等于";
  关系表[4][0] = " <= ";
  关系表[4][1] = "小于等于";
  关系表[5][0] = " <> ";
  关系表[5][1] = "不等于";
  关系表[6][0] = " like ";
  关系表[6][1] = "包含";
  关系表[7][0] = " not like ";
  关系表[7][1] = "不包含";
  String[] 按钮集01 = { "查询", "退出" };
  按钮集 = new String[按钮集01.length];
  按钮数 = 0;
  for (int i0 = 0; i0 < 按钮集01.length; i0++)
   按钮集[i0] = 按钮集01[i0];
  if (parameter[11].length() > 0) {
   要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号
   // 将中文分号、冒号、句号、英文分号统一为英文分号
   要求按钮号表 = 要求按钮号表.replaceAll("；", ";");
   要求按钮号表 = 要求按钮号表.replaceAll("。", ";");
   要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
   要求按钮号表 = 要求按钮号表.replaceAll("：", ";");
   if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求
    String s601[] = 要求按钮号表.split(",");
    要求按钮号表 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (s601[i01].indexOf(";") > 0) {
      String s602[] = s601[i01].split(";");
      按钮集[Integer.parseInt((s602[0]))] = s602[1];
      要求按钮号表 = 要求按钮号表 + "," + s602[0];// 只留号，去更名
      按钮数++;
     } else {
      要求按钮号表 = 要求按钮号表 + "," + s601[i01];// 只留号，原无更名
      按钮数++;
     }
    }
   } // 如果没有按钮更名要求，要求按钮号长度又大于0，保持原有摸样
   else {
    String s601[] = 要求按钮号表.split(",");
    要求按钮号表 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (i01 == 0)
      要求按钮号表 = s601[i01];
     else
      要求按钮号表 = 要求按钮号表 + "," + s601[i01];
     按钮数++;
    }
   }
  } else {
   要求按钮号表 = ""; // 没输入要求按钮号，定全部按钮号
   for (int i1 = 0; i1 < 按钮集.length; i1++) {
    if (i1 == 0)
     要求按钮号表 = 要求按钮号表 + i1;
    else
     要求按钮号表 = 要求按钮号表 + "," + i1;
    按钮数++;
   }
  }
  要求按钮号表 = "," + 要求按钮号表 + ",";
  窗口宽 = main1.窗口宽;
  窗口高 = main1.窗口高;
  int m1, m2;
  try {
   if (parameter[17].length() == 0) {
    m1 = 0;
    m2 = 0;
   } else {
    m1 = Integer.parseInt(parameter[17]);// 宽度参数
    m2 = Integer.parseInt(parameter[18]);
   }
   if (m1 > 0) {
    if (m2 < 80) {
     m1 = m1 * 10;
     m2 = m2 * 10;
    }
    窗口宽 = m1;
    窗口高 = m2;
   }
  } catch (Exception e2) {
  }

  表名 = parameter[4];
  连接条件 = parameter[20];
  表名表 = parameter[0];
  列名 = new String[2][];
  字段名字串 = parameter[19];
  if (字段名字串.lastIndexOf(",") == 字段名字串.length() - 1)
   字段名字串 = 字段名字串.substring(0, 字段名字串.length() - 1);
  String[] s6 = 字段名字串.split(",");
  String s2 = "";
  if (parameter[8].length() > 0) {
   字段号表 = parameter[8].split(",");
   列名 = new String[2][字段号表.length];
   for (int i = 0; i < 字段号表.length; i++) {

    列名[0][i] = s6[Integer.parseInt(字段号表[i])];
    列名[1][i] = 列名[0][i];
    if (s2.length() > 0)
     s2 = s2 + "," + 列名[0][i];
    else
     s2 = 列名[0][i];
   }
   字段名字串 = s2;
  } else {
   列名 = new String[2][s6.length];
   for (int i = 0; i < s6.length; i++) {
    列名[0][i] = s6[i];
    列名[1][i] = 列名[0][i];
    if (s2.length() > 0)
     s2 = s2 + "," + 列名[0][i];
    else
     s2 = 列名[0][i];
   }
   字段名字串 = s2;
   s2 = " * ";
  }
  String s11 = 表名;
  if (表名.indexOf(",") > 0) {
   String[] s12 = 表名.split(",");
   s11 = s12[0];
  }
  String[] t1;
  字典表名 = "";
  if (表名表.lastIndexOf(s11 + "字典表") > 0) {
   t1 = 表名表.split(",");
   for (int i = 0; i < t1.length; i++)
    if (t1[i].lastIndexOf(s11 + "字典表") >= 0)
     字典表名 = t1[i];
  }
  if (字典表名.length() > 0) {
   try {
    con = main1.getConn();
    sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select * from " + 字典表名;
    rs = sta3.executeQuery(s1);
    ResultSetMetaData rsmd = rs.getMetaData();
    int 列数0 = rsmd.getColumnCount();
    int numberOfColumns = rsmd.getColumnCount(); // 记录数
    String s14 = "";
    String s15 = "";
    int b = 1;
    while (rs.absolute(b)) {
     b++;
     s14 = rs.getString(1).trim(); // 字段名
     s15 = rs.getString(2).trim(); // 标签名
     for (int j = 0; j < 列名[0].length; j++) {
      if (列名[0][j].trim().equalsIgnoreCase(s14.trim())) {
       列名[1][j] = s15;
       break;
      } else if ((列名[0][j].trim() + ",").indexOf("." + s14
        + ",") > 0) {
       列名[1][j] = 列名[1][j].replace(s14, s15);
       break;
      }
     }
    }
    rs.close(); // 关闭查询结果集
    con.close();
    sta3.close();
   } catch (SQLException e) {
    JOptionPane.showMessageDialog(null, "连接数据库出错！");
   }
  }
  try {
   con = main1.getConn();// 连接数据库
   sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
     ResultSet.CONCUR_UPDATABLE);
   if (连接条件.trim().length() > 0)
    s1 = "select " + 字段名字串 + " from " + 表名 + " where " + 连接条件;
   else
    s1 = "select " + 字段名字串 + " from " + 表名;
   ResultSet rs = sta3.executeQuery(s1);
   rsmd3 = rs.getMetaData();
   列数 = rsmd3.getColumnCount(); // 获取列数
   列数据类型 = new String[列数]; // 定义列字段类型数组
   列数据宽度 = new int[列数]; // 定义列数据宽度
   for (int i = 0; i < 列数; i++) {
    列数据类型[i] = rsmd3.getColumnTypeName(i + 1);
    列数据宽度[i] = rsmd3.getColumnDisplaySize(i + 1);
    if (列数据宽度[i] < 列名[0][i].length())
     列数据宽度[i] = 列名[0][i].length();
    if (列数据宽度[i] > 50)
     列数据宽度[i] = 50;
    b++;
   }

   int rowNumber = 0; // 记录条数
   rs.last();
   rowNumber = rs.getRow();
   rsmd3 = rs.getMetaData();
   列数 = rsmd3.getColumnCount(); // 获取列数
   表格数据 = new String[rowNumber][列数];
   rs.absolute(1);
   c = 0; // 行号
   b = 0; // 列号
   while (c < rowNumber) {
    rs.absolute(c + 1);
    while (b < 列数) {
     表格数据[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close(); // 关闭查询结果集
   sta3.close(); // 关闭连接
   con.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "查询数据出错！" + s1);
  }
  frame.setTitle("查询部件程序                                作者：程学先"); // 窗口标题
  frame.setBounds(10, 10, 窗口宽 - 10, 窗口高); // 窗口位置大小
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
  frame.getContentPane().setLayout(null); // 关闭窗口布局管理器
  final JPanel panel = new JPanel(false); // 定义面板
  panel.setLayout(null); // 关闭面板布局管理器
  panel.setBounds(20, 20, 窗口宽 - 50, 窗口高 - 10);
  tableModel = new DefaultTableModel(表格数据, 列名[1]); // 创建表格模型
  table = new JTable(tableModel); // 创建指定表格模型的表格
  table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);// 设置表格的选择模式为单选
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  scrollPane.getViewport().add(table, null); // 滚动条加到表格中
  scrollPane.setBounds(30, 70, 窗口宽 - 100, 窗口高 - 200);
  for (int i = 0; i < 列数; i++) {
   TableColumn tc = table.getColumn(列名[1][i]);// 返回表格的列对象
   tc.setPreferredWidth(列数据宽度[i] * 12);
  }
  panel.add(scrollPane);
  左边距 = 30;
  JLabel label1 = new JLabel("请选字段名：");
  label1.setBounds(左边距 + 20, 10, 80, 20);
  panel.add(label1);
  左边距 = 左边距 + 100;
  choice = new Choice();
  for (int i = 0; i < 列数; i++) {
   choice.add(列名[1][i]);
  }
  choice.setBounds(左边距, 10, 100, 60);
  panel.add(choice);
  左边距 = 左边距 + 100;
  choice1 = new Choice();
  for (int i = 0; i < 8; i++) {
   choice1.add(关系表[i][1]);
  }
  choice1.setBounds(左边距, 10, 80, 60);
  panel.add(choice1);
  左边距 = 左边距 + 100;
  aTextField = new JTextField("", 10);
  aTextField.setBounds(左边距, 10, 150, 20);
  panel.add(aTextField);
  左边距 = 左边距 + 150;

  JLabel label01 = new JLabel("请选字段名：");
  label01.setBounds(左边距 + 20, 10, 80, 20);
  panel.add(label01);
  左边距 = 左边距 + 100;
  choice0 = new Choice();
  for (int i = 0; i < 列数; i++) {
   choice0.add(列名[1][i]);
  }
  choice0.setBounds(左边距, 10, 100, 60);
  panel.add(choice0);
  左边距 = 左边距 + 100;

  choice01 = new Choice();
  for (int i = 0; i < 8; i++) {
   choice01.add(关系表[i][1]);
  }
  choice01.setBounds(左边距, 10, 80, 60);
  panel.add(choice01);
  左边距 = 左边距 + 80;

  aTextField2 = new JTextField("", 10);
  aTextField2.setBounds(左边距, 10, 150, 20);
  panel.add(aTextField2);

  按钮宽 = (窗口宽 - 630) / 按钮数;
  int 左边距 = 600;
  final JButton selectButton = new JButton(按钮集[0]);
  selectButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    列序号 = choice.getSelectedIndex();
    关系符 = choice1.getSelectedItem();
    列序号1 = choice0.getSelectedIndex();
    关系符1 = choice01.getSelectedItem();
    try {
     con = main1.getConn();
     sta3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     for (int i = 0; i < 关系表.length; i++) {
      if (关系表[i][1].trim().equalsIgnoreCase(关系符.trim())) {
       关系符0 = 关系表[i][0];
      }
      if (关系表[i][1].trim().equalsIgnoreCase(关系符1.trim())) {
       关系符01 = 关系表[i][0];
      }
     }
     if (字段名字串.lastIndexOf(",") == 字段名字串.length() - 1)
      字段名字串 = 字段名字串.substring(0, 字段名字串.length() - 1);
     s1 = "select " + 字段名字串 + " from " + 表名;
     if (连接条件.trim().length() > 0)
      s1 = s1 + " where " + 连接条件 + " and " + 列名[0][列序号];
     else
      s1 = s1 + " where " + 列名[0][列序号];

     String s3 = aTextField.getText().trim(); // 数据值
     if (((main1.图形数据类型.lastIndexOf("," + 列数据类型[列序号] + ",")) >= 0)
       || ((main1.图形数据类型.lastIndexOf("," + 列数据类型[列序号1]
         + ",")) >= 0)) {
      JOptionPane.showMessageDialog(null,
        "不允许使用图形与二进制数据类型作为查询条件!", "提示",
        JOptionPane.INFORMATION_MESSAGE);
      return;
     }
     if (关系符.lastIndexOf("包含") < 0) {
      if (main1.数字数据类型.lastIndexOf("," + 列数据类型[列序号] + ",") >= 0)
       s1 = s1 + 关系符0 + s3;
      else
       s1 = s1 + 关系符0 + "'" + s3 + "'";
     } else {
      if (main1.数字数据类型.lastIndexOf("," + 列数据类型[列序号] + ",") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字类数据类型不能做包含查询！");
       return;
      } else if (关系符.lastIndexOf("不包含") >= 0)
       s1 = s1 + " not like '%" + s3 + "%'";
      else
       s1 = s1 + " like '%" + s3 + "%'";
     }

     s3 = aTextField2.getText().trim();
     if (关系符1.lastIndexOf("包含") < 0)
      if (main1.数字数据类型.lastIndexOf("," + 列数据类型[列序号1] + ",") >= 0)
       s1 = s1 + " and " + 列名[0][列序号1] + 关系符01 + s3;
      else
       s1 = s1 + " and " + 列名[0][列序号1] + 关系符01 + "'" + s3
         + "'";
     else if (main1.数字数据类型.lastIndexOf("," + 列数据类型[列序号1] + ",") >= 0) {
      JOptionPane.showMessageDialog(null, "数字类数据类型不能做包含查询！");
      return;
     } else if (关系符1.lastIndexOf("不包含") >= 0)
      s1 = s1 + " and " + 列名[0][列序号1] + " not like '%" + s3
        + "%'";
     else
      s1 = s1 + " and " + 列名[0][列序号1] + " like '%" + s3
        + "%'";

     ResultSet rs = sta3.executeQuery(s1);
     int rowNumber = 0; // 记录条数
     rs.last();
     rowNumber = rs.getRow();
     rsmd3 = rs.getMetaData();
     列数 = rsmd3.getColumnCount(); // 获取列数
     表格数据 = new String[rowNumber][列数];
     c = 0; // 行号
     b = 0; // 列号
     while (c < rowNumber) {
      rs.absolute(c + 1);
      while (b < 列数) {
       表格数据[c][b] = rs.getString(b + 1);
       b++;
      }
      c++;
      b = 0;
     }
     rs.close(); // 关闭查询结果集
     sta3.close(); // 关闭连接
     con.close();
     tableModel = new DefaultTableModel(表格数据, 列名[1]);
     table = new JTable(tableModel);
     table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
     scrollPane.setViewportView(table);
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "查询数据出错！" + s1);
    }
   }
  });
  selectButton.setBounds(左边距, 40, 按钮宽, 20);
  if (要求按钮号表.indexOf(",0,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(selectButton);
  }

  final JButton exitButton = new JButton(按钮集[1]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    panel.setVisible(false);
    frame.setVisible(false);
    frame.dispose();
   }
  });
  exitButton.setBounds(左边距, 40, 按钮宽, 20);
  if (要求按钮号表.indexOf(",1,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(exitButton);
  }

  frame.getContentPane().add(panel, null); // 安装面板
  frame.setVisible(true); // 安装窗口
  frame.getContentPane().add(panel, BorderLayout.SOUTH);
 }

 public static String[] getArray(String str) {
  String[] array;
  String s1 = str;
  int i = 1;
  while (s1.indexOf(",") != -1) {
   s1 = s1.substring(s1.indexOf(",") + 1, s1.length());
   i++;
  }
  array = new String[i];
  int j = 0;
  while (str.indexOf(",") != -1) {
   array[j] = str.substring(0, str.indexOf(","));
   str = str.substring(str.indexOf(",") + 1, str.length());
   array[j + 1] = str;
   j++;
  }
  return array;
 }
}

14.源码14.部件程序，给定查询条件表达式的多数据表单一条件或二条件查询程序，可求总计数据，可按格式打印报表。
/**
 * 程序文件名：dataQuery8.java
 * 作者：程学先
 * 完成时间：2013年11月27日
 * 部件功能：在参数中直接给定查询条件表达式的主题部分和输出要求多表单条件或二条件查询程序，
 * 可按格式文件组织打印。运行时程序提供单个或二个文本框供输入查询数据，之后组织查询。
 * 被调用语句：datadataQuery8.means(parameter);由主程序调用。
 * 必须提供的参数：“表名集”、“条件表达式”。
 * 条件表达式可以由一个也可以由二个条件式构成。如果二个条件，之间可以用“与”或“或者”联系。
 * 每个条件式都由一个字段名加一个关系符再加一个问号组成。其格式为[字段名][关系符]？。
 * 例如：“姓名等于?”、“简历包含?”、“学号等于?与分数大于等于？”等。
 * 关系符只能从{"大于"、 "小于"、"等于"、大于等于"、小于等于"、"不等于"、"包含"、"不包含"}中选择一个，
 * 如果输入错误会导致程序显示错误或无法进行查询。
 * 数据表表名可以是一个表，可以是多个表，可以含代码表。
 * 必须借本系统菜单生成程序应用鼠标从列表框中选择表名，不能手工填写表名。
 * 选表时，每新加一个表，都注意要和前面某个表有一个相同字段名。
 * 例如输入顺序是：数据表1、代码表1、代码表2、数据表2、代码表3等。
 * 其中代码表1、代码表2是数据表1的代码表，代码表3是数据表2的代码表。数据表1和数据表2有同名字段。
 * 问号可以用中文问号也可以用英文问号，每个条件中必须在最后有一个问号。
 * 条件表达式不得超过2个,其中最多一个“与”或一个“或者”。
 * 查询结果可以与其他部件程序一样根据所选择字段输出，如果填写了输出要求，也可以根据输出要求输出。
 * 输出要求parameter[14]中填写由字段名或简单的加减乘除表达式构成的SQL语句能识别的子句。
 * 注意如果是多表，当字段名为二表共有时，写输出要求必须在字段名前加 表名和点。
 * 例如：学生.学号 as 学号,姓名,班级,专业,分数*20 as 成绩
 * 则输出为有学号、姓名、班级、专业、成绩等列数据的表。
 * 输出要求如果有聚集函数或其他函数，必须遵循相关规则。例如如果求聚集函数值就不能同时有任何字段值，
 * 因为没有分组，只能输出一行统计数据。
 * 在输出要求中如果涉及常量，输入数据时要求能根据数据类型加英文单引号或不加引号。
 * 如果是数字量或者是字段名，不加引号，如果是字符类数据，必须加单引号。
 * 例如：sum(收入) as 总收入,avg(收入) as 平均收入
 * 如果需要打印，要求先通过桌面系统调用“printFormat1.java”程序，
 * 根据输入的格式文件名生成打印格式文件
 * 在调用本程序时必须给定参数：打印格式文件名。
 */

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;

import java.sql.*;

public class dataQuery8 extends JFrame {
 static dataQuery8 frame = new dataQuery8();
 static String 表名 = "";
 static DefaultTableModel tableModel;
 static JTable table;
 static JScrollPane scrollPane = new JScrollPane();
 static JTextField aTextField, aTextField2;
 static JButton b1, b2;
 static String s1 = "";
 static ResultSet rs;
 static int b = 0, c = 0;
 static int 列数;
 static int 表格列数;
 static String[] 列名;
 static String[][] 关系表 = { { " > ", "大于" }, { " < ", "小于" },
   { " = ", "等于" }, { " >= ", "大于等于" }, { " <= ", "小于等于" },
   { "<>", "不等于" }, { " like ", "包含" }, { " not like ", "不包含" } };
 static String[] 表格列名;
 static String[] 列标题;
 static String[] 列数据类型;
 static String[] 表列数据类型;
 static int[] 列数据宽度;
 static int[] 表列数据宽度;
 static int 记录条数, 记录条数1;
 static int 列序号, 列序号1;
 static String 关系符 = "", 关系符1 = "", 连接符 = "", 关系符0 = "", 关系符01 = "";
 static String 字段名 = "", 字段名1 = "";
 static String 字段名字串;
 static String[] 字段号表;
 static String 条件表达式, 连接条件;
 static String[][] 表格数据;// 存放表格数据的数组
 static String[] 条件;
 static String 输出要求;

 static int 左边距 = 80;
 static String 打印格式文件名;

 static Connection con; // 连接数据库
 static ResultSetMetaData rsmd3;
 static Statement sta3;
 static int 窗口宽 = 1000, 窗口高 = 700;
 static int 按钮数 = 0, 按钮宽 = 0;
 static String[] 按钮集 = null;
 static String 要求按钮号表;
 static JButton printViewButton, printButton;

 public static void means(String[] parameter) {
  frame = new dataQuery8();
  表名 = "";
  scrollPane = new JScrollPane();
  s1 = "";
  b = 0;
  c = 0;
  关系符 = "";
  关系符1 = "";
  连接符 = "";
  关系符0 = "";
  关系符01 = "";
  字段名 = "";
  字段名1 = "";
  左边距 = 80;
  窗口宽 = 1000;
  窗口高 = 700;
  关系表[0][0] = " > ";
  关系表[0][1] = "大于";
  关系表[1][0] = " < ";
  关系表[1][1] = "小于";
  关系表[2][0] = " = ";
  关系表[2][1] = "等于";
  关系表[3][0] = " >= ";
  关系表[3][1] = "大于等于";
  关系表[4][0] = " <= ";
  关系表[4][1] = "小于等于";
  关系表[5][0] = " <> ";
  关系表[5][1] = "不等于";
  关系表[6][0] = " like ";
  关系表[6][1] = "包含";
  关系表[7][0] = " not like ";
  关系表[7][1] = "不包含";

  String[] 按钮集01 = { "查询", "打印预览", "打印", "退出" };
  按钮集 = new String[按钮集01.length];
  按钮数 = 0;
  for (int i0 = 0; i0 < 按钮集01.length; i0++)
   按钮集[i0] = 按钮集01[i0];
  if (parameter[11].length() > 0) {
   要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号
   // 将中文分号、冒号、句号、英文分号统一为英文分号
   要求按钮号表 = 要求按钮号表.replaceAll("；", ";");
   要求按钮号表 = 要求按钮号表.replaceAll("。", ";");
   要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
   要求按钮号表 = 要求按钮号表.replaceAll("：", ";");
   if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求
    String s601[] = 要求按钮号表.split(",");
    要求按钮号表 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (s601[i01].indexOf(";") > 0) {
      String s602[] = s601[i01].split(";");
      按钮集[Integer.parseInt((s602[0]))] = s602[1];
      要求按钮号表 = 要求按钮号表 + "," + s602[0];// 只留号，去更名
      按钮数++;
     } else {
      要求按钮号表 = 要求按钮号表 + "," + s601[i01];// 只留号，原无更名
      按钮数++;
     }
    }
   } // 如果没有按钮更名要求，要求按钮号长度又大于0，保持原有摸样
   else {
    String s601[] = 要求按钮号表.split(",");
    要求按钮号表 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (i01 == 0)
      要求按钮号表 = s601[i01];
     else
      要求按钮号表 = 要求按钮号表 + "," + s601[i01];
     按钮数++;
    }
   }
  } else {
   要求按钮号表 = ""; // 没输入要求按钮号，定全部按钮号
   for (int i1 = 0; i1 < 按钮集.length; i1++) {
    if (i1 == 0)
     要求按钮号表 = 要求按钮号表 + i1;
    else
     要求按钮号表 = 要求按钮号表 + "," + i1;
    按钮数++;
   }
  }
  要求按钮号表 = "," + 要求按钮号表 + ",";
  窗口宽 = main1.窗口宽;
  窗口高 = main1.窗口高;
  int m1, m2;
  try {
   if (parameter[17].length() == 0) {
    m1 = 0;
    m2 = 0;
   } else {
    m1 = Integer.parseInt(parameter[17]);// 宽度参数
    m2 = Integer.parseInt(parameter[18]);
   }
   if (m1 > 0) {
    if (m2 < 80) {
     m1 = m1 * 10;
     m2 = m2 * 10;
    }
    窗口宽 = m1;
    窗口高 = m2;
   }
  } catch (Exception e2) {
  }

  表名 = parameter[4]; // 数据表名
  打印格式文件名 = parameter[15];
  条件表达式 = parameter[10];

  字段名字串 = parameter[19];
  if (字段名字串.lastIndexOf(",") == 字段名字串.length() - 1)
   字段名字串 = 字段名字串.substring(0, 字段名字串.length() - 1);
  String[] s6 = 字段名字串.split(",");
  String s2 = "";
  if (parameter[8].length() > 0) {
   字段号表 = parameter[8].split(",");
   列名 = new String[字段号表.length];
   for (int i = 0; i < 字段号表.length; i++) {
    列名[i] = s6[Integer.parseInt(字段号表[i])];
    if (s2.length() > 0)
     s2 = s2 + "," + 列名[i];
    else
     s2 = 列名[i];
   }
   字段名字串 = s2;
  } else {
   列名 = new String[s6.length];
   for (int i = 0; i < s6.length; i++) {
    列名[i] = s6[i];
    if (s2.length() > 0)
     s2 = s2 + "," + 列名[i];
    else
     s2 = 列名[i];
   }
   字段名字串 = s2;
   s2 = " * ";
  }
  连接条件 = parameter[20];
  输出要求 = parameter[14];
  // System.out.println("输出要求="+输出要求);
  String[] g2, g3;
  if (条件表达式.lastIndexOf("与") > 0) {
   条件 = 条件表达式.split("与");
   连接符 = " and ";
  } else if (条件表达式.lastIndexOf("或者") > 0) {
   条件 = 条件表达式.split("或者");
   连接符 = " or ";
  } else {
   条件 = new String[1];
   条件[0] = 条件表达式;
  }

  if (条件[0].lastIndexOf("大于等于") > 0) {
   关系符0 = ">=";
   字段名 = 条件[0].substring(0, 条件[0].lastIndexOf("大于等于"));
  } else if (条件[0].lastIndexOf("小于等于") > 0) {
   关系符0 = "<=";
   字段名 = 条件[0].substring(0, 条件[0].lastIndexOf("小于等于"));
  } else if (条件[0].lastIndexOf("不等于") > 0) {
   关系符0 = "!=";
   字段名 = 条件[0].substring(0, 条件[0].lastIndexOf("不等于"));
  } else if (条件[0].lastIndexOf("大于") > 0) {
   关系符0 = ">";
   字段名 = 条件[0].substring(0, 条件[0].lastIndexOf("大于"));
  } else if (条件[0].lastIndexOf("小于") > 0) {
   关系符0 = "<";
   字段名 = 条件[0].substring(0, 条件[0].lastIndexOf("小于"));
  } else if (条件[0].lastIndexOf("等于") > 0) {
   关系符0 = "=";
   字段名 = 条件[0].substring(0, 条件[0].lastIndexOf("等于"));
  } else if (条件[0].lastIndexOf("不包含") > 0) {
   关系符0 = "不包含";
   字段名 = 条件[0].substring(0, 条件[0].lastIndexOf("不包含"));
  } else if (条件[0].lastIndexOf("包含") > 0) {
   关系符0 = "包含";
   字段名 = 条件[0].substring(0, 条件[0].lastIndexOf("包含"));
  }

  if (连接符.length() > 0) {
   if (条件[1].lastIndexOf("大于等于") > 0) {
    关系符01 = ">=";
    字段名1 = 条件[1].substring(0, 条件[1].lastIndexOf("大于等于"));
   } else if (条件[1].lastIndexOf("小于等于") > 0) {
    关系符01 = "<=";
    字段名1 = 条件[1].substring(0, 条件[1].lastIndexOf("小于等于"));
   } else if (条件[1].lastIndexOf("不等于") > 0) {
    关系符01 = "!=";
    字段名1 = 条件[1].substring(0, 条件[1].lastIndexOf("不等于"));
   } else if (条件[1].lastIndexOf("大于") > 0) {
    关系符01 = ">";
    字段名1 = 条件[1].substring(0, 条件[1].lastIndexOf("大于"));
   } else if (条件[1].lastIndexOf("小于") > 0) {
    关系符01 = "<";
    字段名1 = 条件[1].substring(0, 条件[1].lastIndexOf("小于"));
   } else if (条件[1].lastIndexOf("等于") > 0) {
    关系符01 = "=";
    字段名1 = 条件[1].substring(0, 条件[1].lastIndexOf("等于"));
   } else if (条件[1].lastIndexOf("不包含") > 0) {
    关系符01 = "不包含";
    字段名1 = 条件[1].substring(0, 条件[1].lastIndexOf("不包含"));
   } else if (条件[1].lastIndexOf("包含") > 0) {
    关系符01 = "包含";
    字段名1 = 条件[1].substring(0, 条件[1].lastIndexOf("包含"));
   }
  }
  try {
   con = main1.getConn();// 连接数据库
   sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
     ResultSet.CONCUR_UPDATABLE);
   if (连接条件.trim().length() > 0)
    s1 = "select " + 字段名字串 + " from " + 表名 + " where " + 连接条件;
   else
    s1 = "select " + 字段名字串 + " from " + 表名;
   ResultSet rs = sta3.executeQuery(s1);
   rsmd3 = rs.getMetaData();
   列数 = rsmd3.getColumnCount(); // 获取列数
   列数据类型 = new String[列数]; // 定义列字段类型数组
   列数据宽度 = new int[列数]; // 定义列数据宽度
   for (int i = 0; i < 列数; i++) {
    if ((字段名.length() > 0) && (列名[i].trim().equals(字段名.trim())))
     列序号 = i;
    else if (列名[i]
      .substring(列名[i].lastIndexOf(".") + 1, 列名[i].length())
      .trim().equals(字段名.trim()))
     列序号 = i;
    if ((字段名.length() > 0) && (列名[i].trim().equals(字段名1.trim())))
     列序号1 = i;
    else if (列名[i]
      .substring(列名[i].lastIndexOf(".") + 1, 列名[i].length())
      .trim().equals(字段名1.trim()))
     列序号1 = i;
    列数据类型[i] = rsmd3.getColumnTypeName(i + 1);
    列数据宽度[i] = rsmd3.getColumnDisplaySize(i + 1);
    if (列数据宽度[i] < 列名[i].length())
     列数据宽度[i] = 列名[i].length();
    if (列数据宽度[i] > 50)
     列数据宽度[i] = 50;
    b++;
   }

   int rowNumber = 0; // 记录条数
   rs.last();
   rowNumber = rs.getRow();
   表格数据 = new String[rowNumber][列数];
   rs.absolute(1);
   c = 0; // 行号
   b = 0; // 列号
   while (c < rowNumber) {
    rs.absolute(c + 1);
    while (b < 列数) {
     表格数据[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close(); // 关闭查询结果集
   sta3.close(); // 关闭连接
   con.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "连接数据库出错！");
  }
  if (连接条件.trim().length() > 0)
   连接条件 = 连接条件 + " and ";

  frame.setTitle("查询部件程序                                作者：程学先"); // 窗口标题
  frame.setBounds(10, 10, 窗口宽 - 10, 窗口高 + 20); // 窗口位置大小
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
  frame.getContentPane().setLayout(null); // 关闭窗口布局管理器
  final JPanel panel = new JPanel(false); // 定义面板
  panel.setLayout(null); // 关闭面板布局管理器
  panel.setBounds(20, 20, 窗口宽 - 50, 窗口高 + 20);

  tableModel = new DefaultTableModel(表格数据, 列名); // 创建表格模型
  table = new JTable(tableModel); // 创建指定表格模型的表格
  table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);// 设置表格的选择模式为单选
  scrollPane.getViewport().add(table, null); // 表格加滚动条
  scrollPane.setBounds(30, 70, 窗口宽 - 100, 窗口高 - 150);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

  for (int i = 0; i < 列数; i++) {
   TableColumn tc = table.getColumn(列名[i]);// 返回表格的列对象
   tc.setPreferredWidth(列数据宽度[i] * 12);
  }
  panel.add(scrollPane);

  JLabel label1 = new JLabel(条件[0]);
  label1.setBounds(左边距, 10, 条件[0].length() * 15, 20);
  panel.add(label1);
  左边距 = 左边距 + 条件[0].length() * 15;

  aTextField = new JTextField("", 10); // 定义文本框，预设值
  aTextField.setBounds(左边距, 10, 150, 20);
  panel.add(aTextField);
  左边距 = 左边距 + 150;

  if (条件.length > 1) {
   JLabel label3 = new JLabel(条件[1]); // 用标签显示指定的字段名
   label3.setBounds(左边距, 10, 条件[1].length() * 15, 20);
   panel.add(label3);
   左边距 = 左边距 + 条件[1].length() * 15;

   aTextField2 = new JTextField("", 10); // 定义文本框，预设值
   aTextField2.setBounds(左边距, 10, 150, 20);
   panel.add(aTextField2);
  }

  按钮宽 = (窗口宽 - 360) / 按钮数;
  int 左边距 = 350;
  final JButton selectButton = new JButton(按钮集[0]); // 定义查询按钮
  selectButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    try {
     con = main1.getConn();
     sta3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     if (输出要求.trim().length() > 0)
      s1 = "select " + 输出要求 + " from " + 表名;
     else
      s1 = "select " + 字段名字串 + " from " + 表名;
     if (连接条件.trim().length() > 0)
      s1 = s1 + " where " + 连接条件 + 列名[列序号];
     else
      s1 = s1 + " where " + 列名[列序号];

     if (((main1.图形数据类型.lastIndexOf("," + 列数据类型[列序号] + ",")) >= 0)
       || ((main1.图形数据类型.lastIndexOf("," + 列数据类型[列序号1]
         + ",")) >= 0)) {
      JOptionPane.showMessageDialog(null,
        "不允许使用图形与二进制数据类型作为查询条件!", "提示",
        JOptionPane.INFORMATION_MESSAGE);
      return;
     }
     if (关系符0.lastIndexOf("包含") < 0) {
      if (main1.数字数据类型.lastIndexOf("," + 列数据类型[列序号] + ",") >= 0)
       s1 = s1 + 关系符0 + aTextField.getText().trim();
      else
       s1 = s1 + 关系符0 + "'" + aTextField.getText().trim()
         + "'";
     } else {
      if (main1.数字数据类型.lastIndexOf("," + 列数据类型[列序号] + ",") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字类数据类型不能做包含查询！");
       return;
      } else if (关系符0.lastIndexOf("不包含") >= 0)
       s1 = s1 + " not like '%"
         + aTextField.getText().trim() + "%'";
      else
       s1 = s1 + " like '%" + aTextField.getText().trim()
         + "%'";
     }
     if (条件.length > 1) {
      if (关系符01.lastIndexOf("包含") < 0)
       if (main1.数字数据类型.lastIndexOf("," + 列数据类型[列序号1]
         + ",") >= 0)
        s1 = s1 + " and " + 字段名1 + 关系符01
          + aTextField2.getText().trim();
       else
        s1 = s1 + " and " + 字段名1 + 关系符01 + "'"
          + aTextField2.getText().trim() + "'";
      else if (main1.数字数据类型.lastIndexOf("," + 列数据类型[列序号1]
        + ",") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字类数据类型不能做包含查询！");
       return;
      } else if (关系符01.lastIndexOf("不包含") >= 0)
       s1 = s1 + " and " + 字段名1 + " not like '%"
         + aTextField2.getText().trim() + "%'";
      else
       s1 = s1 + " and " + 字段名1 + " like '%"
         + aTextField2.getText().trim() + "%'";
     }
     ResultSet rs = sta3.executeQuery(s1);
     int rowNumber = 0; // 记录条数
     rs.last();
     rowNumber = rs.getRow();
     rsmd3 = rs.getMetaData();
     列数 = rsmd3.getColumnCount(); // 获取列数
     列数据宽度 = new int[列数]; // 定义列数据宽度
     列名 = new String[列数];
     for (int i = 0; i < 列数; i++) {
      列名[i] = rsmd3.getColumnName(i + 1); // 获取列名存到数组中
      列数据宽度[i] = rsmd3.getColumnDisplaySize(i + 1);
      if (列数据宽度[i] < 列名[i].length())
       列数据宽度[i] = 列名[i].length();
      if (列数据宽度[i] > 50)
       列数据宽度[i] = 50;
     }

     表格数据 = new String[rowNumber][列数];
     c = 0; // 行号
     b = 0; // 列号
     while (c < rowNumber) {
      rs.absolute(c + 1);
      while (b < 列数) {
       表格数据[c][b] = rs.getString(b + 1);
       b++;
      }
      c++;
      b = 0;
     }
     rs.close(); // 关闭查询结果集
     sta3.close(); // 关闭连接
     con.close();
     tableModel = new DefaultTableModel(表格数据, 列名);
     table = new JTable(tableModel);
     table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
     scrollPane.setViewportView(table);
     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
     for (int i = 0; i < 列数; i++) {
      TableColumn tc = table.getColumn(列名[i]);// 返回表格的列对象
      tc.setPreferredWidth(列数据宽度[i] * 12);
     }
     printViewButton.setEnabled(true);
     printButton.setEnabled(true);
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "查询数据出错！" + s1);
    }
   }
  });
  selectButton.setBounds(左边距, 40, 按钮宽, 20);
  if (要求按钮号表.indexOf(",0,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(selectButton);
  }

  printViewButton = new JButton(按钮集[1]);
  printViewButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    dataPreview1.printView1(表格数据, 打印格式文件名);
   }
  });
  printViewButton.setBounds(左边距, 40, 按钮宽, 20);
  if (要求按钮号表.indexOf(",1,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(printViewButton);
   printViewButton.setEnabled(false);
  }

  printButton = new JButton(按钮集[2]);
  printButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    dataPrint1.print1(表格数据, 打印格式文件名);
   }
  });
  printButton.setBounds(左边距, 40, 按钮宽, 20);
  if (要求按钮号表.indexOf(",2,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(printButton);
   printButton.setEnabled(false);
  }

  final JButton exitButton = new JButton(按钮集[3]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    panel.setVisible(false);
    frame.setVisible(false);
    frame.dispose();
   }
  });
  exitButton.setBounds(左边距, 40, 按钮宽, 20);
  if (要求按钮号表.indexOf(",3,") >= 0) {
   左边距 = 左边距 + 按钮宽;
   panel.add(exitButton);
  }
  frame.getContentPane().add(panel, null); // 安装面板
  frame.setVisible(true); // 安装窗口
  frame.getContentPane().add(panel, BorderLayout.SOUTH);
 }
}

版本2
9.源码9，公共表格数据显示程序
/*
 * 作者：程传庆 
 * 功能：共用查询结果显示程序。
 * 完成日期：2013年10月11日
 */
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;

public class tableTenance extends JFrame {
 static String[][] variabl21971;
 static String[][] variabl1753;
 static String[][] variabl1631;
 static String[][] variabl1701;
 static int variabl1853;
 static int variabl1901 = 0, variabl1691 = 0, variabl1739 = 0,
   variabl1899 = 0;
 static int variabl2113;
 static JButton sortButton1, sortButton, printButton, exitButton;
 static String[] rowValues;
 static String[] variabl25170;
 static int[] variabl24750;

 static void tableModel(int variabl1727, int variabl1783,
   String[] variabl25173, int[] variabl2475, String[][] variabl2197,
   String[] variabl1169) {
  variabl25170 = new String[variabl25173.length];
  variabl24750 = new int[variabl25173.length];
  for (int i = 0; i < variabl25173.length; i++) {
   variabl25170[i] = variabl25173[i];
   variabl24750[i] = variabl2475[i];
  }
  variabl1901 = 0;
  variabl1691 = 0;
  variabl1739 = 0;
  variabl1899 = 0;
  if (variabl1783 > 600)
   variabl1783 = 600;
  final tableTenance frame = new tableTenance();
  final JTable table;
  final DefaultTableModel model;
  frame.setTitle("表格式显示部件                          作者：程传庆");
  frame.setBounds(10, 10, variabl1727, variabl1783);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.setVisible(true);
  final JScrollPane scrollPane = new JScrollPane();
  scrollPane.setBounds(10, 10, variabl1727 - 20, variabl1783 - 100);
  frame.setLayout(null);
  frame.getContentPane().add(scrollPane);
  int j = 5;
  int variabl2339 = (variabl1727 - 50) / j;
  int variabl1423 = 5;
  variabl2113 = variabl25170.length;
  variabl1853 = variabl2197.length;
  rowValues = new String[variabl2113];
  variabl1701 = new String[variabl1853][variabl2113];
  variabl21971 = new String[variabl1853][variabl2113];
  int b = 0;
  for (int c = 0; c < variabl1853; c++)
   for (b = 0; b < variabl2113; b++) {
    variabl1701[c][b] = variabl2197[c][b];
    variabl21971[c][b] = variabl2197[c][b];
   }
  model = new DefaultTableModel(variabl21971, variabl25170);
  table = new JTable(model);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
  for (int i = 0; i < variabl25170.length; i++) {
   TableColumn tc = table.getColumn(variabl25170[i]);
   JTableHeader header = table.getTableHeader();
   if (variabl2475[i] < variabl25170[i].length())
    variabl2475[i] = variabl25170[i].length();
   tc.setPreferredWidth(variabl2475[i] * 9);
   tc.setMaxWidth(variabl2475[i] * 9);
  }
  scrollPane.setViewportView(table);
  table.addMouseListener(new MouseAdapter() {
   public void mouseClicked(MouseEvent e) {
    main1.variabl1327 = table.getSelectedRow();
   }
  });

  variabl1753 = new String[variabl1853][variabl2113 + 1];
  variabl1631 = new String[variabl1853][variabl2113 + 1];
  for (b = 0; b < variabl2113; b++) {
   for (int c = 0; c < variabl1853; c++) {
    if (variabl1701[c][b] == null)
     variabl1753[c][b] = "";
    else
     variabl1753[c][b] = variabl1701[c][b];
   }
   if (variabl1169[b].compareTo("int") == 0) {
    for (int c = 0; c < variabl1853; c++) {
     variabl1753[c][b] = "0000000000" + variabl1753[c][b];
     variabl1753[c][b] = variabl1753[c][b]
       .substring(variabl1753[c][b].length() - 10);
    }
   } else if ((variabl1169[b].compareTo("float") == 0)
     || (variabl1169[b].compareTo("numeric") == 0)) {
    for (int c = 0; c < variabl1853; c++) {
     variabl1753[c][b] = "0000000000" + variabl1753[c][b];
     int k1 = variabl1753[c][b].lastIndexOf('.');
     if (k1 == -1) {
      k1 = variabl1753[c][b].length();
      variabl1753[c][b] = variabl1753[c][b] + ".000000";
     } else
      variabl1753[c][b] = variabl1753[c][b] + "000000";
     variabl1753[c][b] = variabl1753[c][b].substring(k1 - 10,
       k1 + 1)
       + variabl1753[c][b].substring(k1 + 1, k1 + 6);
    }
   }
  }
  for (int c = 0; c < variabl1853; c++)
   variabl1753[c][variabl2113] = "" + c;
  for (int c = 0; c < variabl1853; c++)
   for (b = 0; b < variabl2113 + 1; b++)
    variabl1631[c][b] = variabl1753[c][b];
  variabl1901 = 0;
  variabl1691 = 0;
  sortButton = new JButton("排序");
  sortButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    rowValues = new String[variabl2113];
    if (sortButton.getText().trim().equals("排序")) {
     if (table.getSelectedColumn() < 0)
      JOptionPane.showMessageDialog(null,
        "请先点击要排序的某一列，再按本按钮！");
     else {
      sortButton.setText("还原");
      sortButton1.setEnabled(true);
      variabl1899 = table.getSelectedColumn();
      variabl1739 = table.getSelectedColumn();
     }
     String s;
     int i, j, k = 0;
     for (int c = 0; c < variabl1853; c++) {
      for (i = 0; i < variabl1853 - c - 1; i++) {
       if (variabl1753[i][variabl1739]
         .compareTo(variabl1753[i + 1][variabl1739]) > 0)
        for (j = 0; j <= variabl2113; j++) {
         s = variabl1753[i][j];
         variabl1753[i][j] = variabl1753[i + 1][j];
         variabl1753[i + 1][j] = s;
        }
      }
     }
     model.setRowCount(0);
     for (int c = 0; c < variabl1853; c++) {
      int n = Integer.parseInt(variabl1753[c][variabl2113]);
      for (int b = 0; b < variabl2113; b++) {
       variabl21971[c][b] = variabl1701[n][b];
       rowValues[b] = variabl1701[n][b];
      }
      model.addRow(rowValues);
     }
    } else {
     sortButton.setText("排序");
     sortButton1.setEnabled(false);
     model.setRowCount(0);
     for (int c = 0; c < variabl1853; c++) {
      for (int b = 0; b < variabl2113; b++) {
       rowValues[b] = variabl1701[c][b];
       variabl1753[c][b] = variabl1631[c][b];
      }
      model.addRow(rowValues);
      variabl1753[c][variabl2113] = variabl1631[c][variabl2113];
     }
    }
   }
  });
  sortButton.setBounds(variabl1423, variabl1783 - 80, variabl2339 - 10,
    20);
  frame.add(sortButton);
  variabl1423 = variabl1423 + variabl2339;

  sortButton1 = new JButton("接续排序");
  sortButton1.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    variabl1739 = table.getSelectedColumn();
    String s = "", s1 = variabl1753[0][variabl1899];
    int n1 = 0, n2 = 0;
    int i, j, k = 0;
    for (int c = 0; c < variabl1853; c++) {
     if ((c == variabl1853 - 1)
       || (s1.compareTo(variabl1753[c + 1][variabl1899]) != 0)) {
      if (c < variabl1853 - 1)
       s1 = variabl1753[c + 1][variabl1899];
      n2 = c;
      for (i = n1; i < n2; i++) {
       for (j = n1; j < n2 + n1 - i; j++) {
        if (variabl1753[j][variabl1739]
          .compareTo(variabl1753[j + 1][variabl1739]) > 0)
         for (k = 0; k <= variabl2113; k++) {
          s = variabl1753[j][k];
          variabl1753[j][k] = variabl1753[j + 1][k];
          variabl1753[j + 1][k] = s;
         }
       }
      }
      n1 = n2 + 1;
     }
    }
    variabl1899 = variabl1739;
    model.setRowCount(0);
    for (int c = 0; c < variabl1853; c++) {
     int n = Integer.parseInt(variabl1753[c][variabl2113]);
     for (int b = 0; b < variabl2113; b++) {
      rowValues[b] = variabl1701[n][b];
     }
     model.addRow(rowValues);
    }
   }
  });
  sortButton1.setBounds(variabl1423, variabl1783 - 80, variabl2339 - 5,
    20);
  frame.add(sortButton1);
  variabl1423 = variabl1423 + variabl2339;
  sortButton1.setEnabled(false);

  JButton printButton0 = new JButton("打印预览");
  printButton0.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    try {
     dataPreview0.printView1(variabl25170, variabl1701,
       variabl24750, "表格预览");
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "打印预览失败！");
    }
   }
  });
  printButton0.setBounds(variabl1423, variabl1783 - 80, variabl2339 - 5,
    20);
  frame.add(printButton0);

  variabl1423 = variabl1423 + variabl2339;
  printButton = new JButton("打印");
  printButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    try {
     table.print();
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "打印失败！");
    }
   }
  });
  printButton.setBounds(variabl1423, variabl1783 - 80, variabl2339 - 5,
    20);
  frame.add(printButton);
  variabl1423 = variabl1423 + variabl2339;

  exitButton = new JButton("退            出");
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    frame.setVisible(false);
    return;
   }
  });
  exitButton
    .setBounds(variabl1423, variabl1783 - 80, variabl2339 - 5, 20);
  frame.add(exitButton);
  variabl1423 = variabl1423 + variabl2339;
 }
}

10.源码10，公共程序：单数据表的表格式报表打印预览
/*
 * 作者：程传庆
 * 程序功能：单数据表的表格式报表打印预览，内容只限表格数据中数据。
 * 要求在上级程序中生成表格数据，根据所传过来字段数据与所定义的宽度以固定格式实现打印。
 */
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JComponent;
import javax.swing.JFrame;

public class dataPreview0 extends JComponent {
 private static JFrame frameView;
 private static int[] variabl1819;
 private static String variabl1685;
 private static String[][] variabl2197;
 private static String[] variabl2517;
 private static int variabl1613 = 32;
 private static int x1 = 0, y1 = 0, w1 = 0, h1 = 0;
 private static Graphics2D g3;
 private static int variabl2557 = 800;

 protected void paintComponent(Graphics g) {
  g3 = (Graphics2D) g;
  g3 = (Graphics2D) g;
  g3.setFont(new Font("宋体", Font.PLAIN, variabl1613));
  g3.drawString(variabl1685, (variabl2557 - variabl1685.length()) / 2, 30);
  int variabl2067 = 0;
  for (int i = 0; i < variabl1819.length; i++)
   variabl2067 = variabl2067 + variabl1819[i];
  int variabl1981 = (variabl2557 - 80) / variabl2067;
  x1 = 30;
  y1 = variabl1613 + 50;
  h1 = (int) (variabl1981 * 1.2);
  g3.setFont(new Font("宋体", Font.PLAIN, variabl1981));
  for (int i = 0; i < variabl2517.length; i++) {
   w1 = variabl1819[i] * variabl1981;
   g3.drawLine(x1, y1, x1 + w1, y1);
   g3.drawLine(x1, y1, x1, y1 + h1);
   g3.drawString(variabl2517[i], x1 + 4, y1 + variabl1981);
   g3.drawLine(x1, y1 + h1, x1 + w1, y1 + h1);
   g3.drawLine(x1 + w1, y1, x1 + w1, y1 + h1);
   x1 = x1 + w1;
  }
  y1 = y1 + h1;
  h1 = (int) (variabl1981 * 1.2);
  for (int i = 0; i < variabl2197.length; i++) {
   x1 = 30;
   g3.drawLine(x1, y1, x1, y1 + h1);
   for (int j = 0; j < variabl2517.length; j++) {
    w1 = variabl1819[j] * variabl1981;
    if (variabl2197[i][j] == null)
     variabl2197[i][j] = " ";
    g3.drawString(variabl2197[i][j], x1 + 4, y1 + variabl1981);
    g3.drawLine(x1, y1 + h1, x1 + w1, y1 + h1);
    g3.drawLine(x1 + w1, y1, x1 + w1, y1 + h1);
    x1 = x1 + w1;
   }
   y1 = y1 + h1;
  }
 }

 public static void printView1(String[] variabl25171,
   String[][] variabl21971, int[] variabl18191, String variabl2535) {
  variabl1685 = variabl2535;
  variabl2197 = new String[variabl21971.length][variabl25171.length];
  variabl2517 = new String[variabl25171.length];
  variabl1819 = new int[variabl25171.length];
  for (int i = 0; i < variabl21971.length; i++)
   for (int j = 0; j < variabl25171.length; j++)
    variabl2197[i][j] = variabl21971[i][j];
  for (int j = 0; j < variabl25171.length; j++) {
   variabl2517[j] = variabl25171[j];
   variabl1819[j] = variabl18191[j];
  }
  frameView = new JFrame("报表预览程序             作者：程传庆");
  frameView.setBounds(10, 10, 1000, 1000);
  frameView.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frameView.add(new dataPreview0());
  frameView.setVisible(true);
 }
}

11.源码11.部件程序，利用二个指定的字段和表达式进行单数据表二固定条件查询。
     /**
      * 程序文件名：dataQuery5.java
      * 作者：程学先
      * 完成时间：2013年11月27日
      * 部件功能：利用二个指定的字段和表达式进行单数据表二固定条件查询。
     */
     
     import java.awt.*;
     import java.awt.event.*;
     import javax.swing.*;
     import javax.swing.table.*;
     
     import java.sql.*;
     public class dataQuery5 extends JFrame {
      static dataQuery5 frame = new dataQuery5(); 
      static String variabl2603=""; 
      static DefaultTableModel tableModel; 
        static JTable table; 
        static JScrollPane scrollPane = new JScrollPane();  
        static JTextField aTextField,aTextField2;
        static JButton b1,b2;  
     static String s1="";
      static ResultSet rs;  
        static int b=0,c=0; 
        static int variabl2651; 
        static int variabl2113; 
        static String[] variabl2517;  
        static String[][] variabl2319={{" > ","大于"},{" < ","小于"},{" = ","等于"},{" >= ","大于等于"},{" <= ","小于等于"},{"<>","不等于"},{" like ","包含"},{" not like ","不包含"}};
        static String[] variabl1913; 
        static String[] variabl2411; 
        static String[] variabl1501; 
        static String[] variabl1169;
        static int[] variabl1489; 
        static int[] variabl1119; 
        static int variabl1853, variabl18531; 
        static int variabl2345, variabl23451; 
        static String variabl2259,variabl22591;
        static String[][] variabl2197;
        static String variabl1325;
        static String [] variabl1735;
        
      static int variabl2337=80;
      static String variabl1079;
         
        static Connection con;
        static ResultSetMetaData rsmd3;
        static Statement sta3;
        static int variabl2483 = 1000, variabl2503 = 700;
        static JButton printViewButton,printButton;
     static String [] variabl2405=null;
      static String variabl1187;
      static int variabl2851=0,variabl2339=0;
        
     public static void means(String [] parameter) {
      frame = new dataQuery5(); 
      variabl2603="";  
      scrollPane = new JScrollPane();  
      s1=""; b=0;c=0; 
      variabl2259="";variabl22591="";
      variabl2337=80;variabl2483 = 1000; variabl2503 = 700;
      variabl2319[0][0]=" > "; variabl2319[0][1]="大于";
      variabl2319[1][0]=" < "; variabl2319[1][1]="小于";
      variabl2319[2][0]=" = "; variabl2319[2][1]="等于";
      variabl2319[3][0]=" >= "; variabl2319[3][1]="大于等于";
      variabl2319[4][0]=" <= "; variabl2319[4][1]="小于等于";
        variabl2319[5][0]=" <> "; variabl2319[5][1]="不等于";
      variabl2319[6][0]=" like "; variabl2319[6][1]="包含";
      variabl2319[7][0]=" not like "; variabl2319[7][1]="不包含";
     
      String [] variabl240501={"查询","打印预览","打印","退出"};
        variabl2405=new String[variabl240501.length];
        variabl2851=0;
        for (int i0=0;i0<variabl240501.length;i0++)
               variabl2405[i0]= variabl240501[i0];
       if (parameter[11].length()>0){
       variabl1187=parameter[11] ;
                
       variabl1187=variabl1187.replaceAll("；",";");
       variabl1187=variabl1187.replaceAll("。",";");
       variabl1187=variabl1187.replaceAll(":",";");
       variabl1187=variabl1187.replaceAll("：",";");
       if (variabl1187.indexOf(";")>0){  
        String s601[]=variabl1187.split(",");
        variabl1187="";
        for (int i01=0;i01<s601.length;i01++){
         if (s601[i01].indexOf(";")>0){
         String s602[]=s601[i01].split(";");
         variabl2405[Integer.parseInt((s602[0]))]=s602[1];
         variabl1187=variabl1187+","+s602[0];
         variabl2851++;
         }
         else {
          variabl1187=variabl1187+","+s601[i01];
          variabl2851++;
         }
        }
       }  
       else {
        String s601[]=variabl1187.split(",");
        variabl1187="";
        for (int i01=0;i01<s601.length;i01++){
                    if (i01==0) variabl1187=s601[i01];
                    else variabl1187=variabl1187+","+s601[i01];
                    variabl2851++;
           }
       }
       }
       else {
        variabl1187=""; 
        for (int i1=0;i1<variabl2405.length;i1++){
         if (i1==0) variabl1187=variabl1187+i1;
         else variabl1187=variabl1187+","+i1;
            variabl2851++;
        }
       }
       variabl1187=","+variabl1187+",";
       variabl2483=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){}
          variabl2345=Integer.valueOf(parameter[9]);
             variabl23451=Integer.valueOf(parameter[10]);
            variabl2259=parameter[12];
             variabl22591=parameter[13];
       variabl2603=parameter[4] ;
       variabl1079=parameter[15] ;
       variabl1325=parameter[19];
           if (variabl1325.lastIndexOf(",")==variabl1325.length()-1 )
          variabl1325=variabl1325.substring(0,variabl1325.length()-1);
          String []s6=variabl1325.split(",");
          String  variabl1269=s6[variabl2345];
          String variabl12691=s6[variabl23451];
           String s2="";
       if (parameter[8].length()>0){
        variabl1735=parameter[8].split(",");
                variabl2517=new String[variabl1735.length];
                for (int i=0;i<variabl1735.length;i++){
                 variabl2517[i]=s6[Integer.parseInt(variabl1735[i])];
                 if (s2.length()>0) s2=s2+","+variabl2517[i];
                 else s2=variabl2517[i];
                }
                variabl1325=s2;
       }
       else {
                 variabl2517=new String[s6.length];
                 for (int i=0;i<s6.length;i++){
                  variabl2517[i]=s6[i];
                  if (s2.length()>0) s2=s2+","+variabl2517[i];
                  else s2=variabl2517[i];
                 }
                 variabl1325=s2;
        s2=" * ";
       }
              try { 
             con=main1.getConn();
            sta3 = con.createStatement(
                 ResultSet.TYPE_SCROLL_INSENSITIVE,   
                       ResultSet.CONCUR_UPDATABLE);  
               ResultSet rs=sta3.executeQuery("select "+s2+" from "+variabl2603);
               rsmd3 = rs.getMetaData();
               variabl2651=rsmd3.getColumnCount();  
            variabl1501 = new String[variabl2651];
            variabl1489 = new int[variabl2651];
                 variabl2345=-1;
                 variabl23451=-1;
            for (int i=0;i<variabl2651;i++) { 
         variabl1501[i] = rsmd3.getColumnTypeName(i + 1);
           variabl1489[i] = rsmd3.getColumnDisplaySize(i + 1);
           if (variabl1489[i]<variabl2517[i].length())  variabl1489[i]=variabl2517[i].length();
           if (variabl1489[i]>50)  variabl1489[i]=50;
           if ((","+variabl2517[i]+",").lastIndexOf(","+variabl1269+",")>=0)
              variabl2345=i;
           if ((","+variabl2517[i]+",").lastIndexOf("."+variabl1269+",")>=0)
              variabl2345=i;
           if ((","+variabl2517[i]+",").lastIndexOf(","+variabl12691+",")>=0)
              variabl23451=i;
           if ((","+variabl2517[i]+",").lastIndexOf("."+variabl12691+",")>=0)
              variabl23451=i;
               b++; 
             }
            if (variabl2345<0){
             JOptionPane.showMessageDialog( null, "查询要求字段未包含在所选字段号表中，没法查询！");
             return;
            }
            if (variabl23451<0){
             JOptionPane.showMessageDialog( null, "查询要求字段未包含在所选字段号表中，没法查询！");
             return;
            }
        
        int rowNumber=0;  
           rs.last(); 
           rowNumber=rs.getRow();
           variabl2197=new  String[rowNumber][variabl2651];  
           rs.absolute(1); 
           c=0;   
           b=0;       
           while(c<rowNumber) {
               rs.absolute(c+1);        
               while(b<variabl2651){
                       variabl2197[c][b]=rs.getString(b+1);
                        b++;
               }
               c++;
               b=0;
           }
           rs.close();    
           sta3.close();    
           }
          catch(SQLException e) 
          {
           JOptionPane.showMessageDialog( null, "连接数据库出错！");
          } 
          
        frame.setTitle("查询部件程序                                作者：程学先"); 
       frame.setBounds(10, 10,variabl2483-10,variabl2503+20);   
       frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
         frame.getContentPane().setLayout(null);   
         final JPanel panel = new JPanel(false);     
         panel.setLayout(null);       
         panel.setBounds(20, 20,variabl2483-50,variabl2503+20);
        tableModel = new DefaultTableModel(variabl2197,variabl2517);
         table = new JTable(tableModel);
         table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
         scrollPane.getViewport().add(table, null);
         scrollPane.setBounds(30, 70,variabl2483-100,variabl2503-150);
         table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);  
         for (int i=0;i<variabl2651;i++) { 
          TableColumn tc = table.getColumn(variabl2517[i]);
             tc.setPreferredWidth(variabl1489[i]*12);
          }
         panel.add(scrollPane);  
         JLabel label1=new JLabel(variabl2517[variabl2345]); 
         label1.setBounds(variabl2337, 10 , variabl2517[variabl2345].length()*15, 20);
         panel.add(label1);
         variabl2337=variabl2337+variabl2517[variabl2345].length()*15;
         JLabel label2=new JLabel(variabl2259);
         label2.setBounds(variabl2337, 10 ,variabl2259.length()*15, 20);
         panel.add(label2);
         variabl2337=variabl2337+variabl2259.length()*15;
         aTextField = new JTextField("", 10); 
         aTextField.setBounds(variabl2337, 10 ,150, 20);
         panel.add(aTextField); 
         variabl2337=variabl2337+150;
         
         JLabel label3=new JLabel(variabl2517[variabl23451]); 
         label3.setBounds(variabl2337, 10 , variabl2517[variabl23451].length()*15, 20);
         panel.add(label3);
         variabl2337=variabl2337+variabl2517[variabl23451].length()*15;
        
         JLabel label4=new JLabel(variabl22591);
         label4.setBounds(variabl2337, 10 ,variabl22591.length()*15, 20);
         panel.add(label4);
         variabl2337=variabl2337+variabl22591.length()*15;
         
         aTextField2 = new JTextField("    ", 10);
         aTextField2.setBounds(variabl2337, 10 ,150, 20);
         panel.add(aTextField2); 
      
      variabl2339=(variabl2483-380)/variabl2851;
      int variabl2337=350;
         final JButton selectButton = new JButton(variabl2405[0]);
         selectButton.addActionListener(new ActionListener() { 
             public void actionPerformed(ActionEvent e) {
               String variabl22590="",variabl225901="";
               try{
                con=main1.getConn();
                sta3 = con.createStatement( 
                  ResultSet.TYPE_SCROLL_INSENSITIVE,   
                           ResultSet.CONCUR_UPDATABLE); 
                for(int i=0;i<variabl2319.length;i++){
                 if(variabl2319[i][1].trim().equals(variabl2259.trim())){
                  variabl22590=variabl2319[i][0];
                  }
                 if(variabl2319[i][1].trim().equals(variabl22591.trim())){
                  variabl225901=variabl2319[i][0];
                  }
                }
                 String s1="select * from "+variabl2603+" where "+variabl2517[variabl2345];   
                   String s2=variabl1501[variabl2345];
                String s3=aTextField.getText().trim();  
                String s4=variabl22590;   
                if ((main1.variabl1539.lastIndexOf(s2))>=0){
                    JOptionPane.showMessageDialog(null,"不允许使用图形与二进制数据类型作为查询条件!","提示", JOptionPane.INFORMATION_MESSAGE);
                    return;
                     }
                   else if(main1.variabl1545.lastIndexOf(","+s2+",")>=0){
                    if(s4.indexOf("like")>=0){
                      JOptionPane.showMessageDialog(null,"数字数据类型不能进行模式匹配！","提示", JOptionPane.INFORMATION_MESSAGE);
                      return;
                     }
                    else{
                      s1=s1+s4+s3.trim();
                    }
                  }
                  else if(main1.variabl1537.lastIndexOf(s2)>=0){
                    if(s4.indexOf("like")>=0){
                        s3=" '%"+s3+"%'";
                        s1=s1+s4+s3;
                      }
                       else{
                        JOptionPane.showMessageDialog(null,"文本类大数据类型只能用包含或不包含进行查询","提示", JOptionPane.INFORMATION_MESSAGE);
                        return;
                    }
                  }
                  else { 
                       if(s4.indexOf("like")>=0) 
                          s3="%"+s3+"%";
                       else {
                       if ((s2.indexOf("datetime")>=0) && (s3.length()<10)){
                            JOptionPane.showMessageDialog(null,"日期时间类型进行查询时数据格式必须为yyyy-yy-dd","提示", JOptionPane.INFORMATION_MESSAGE);
                            return;
                       }
                       else if ((s2.equals("datetime")) && (s3.length()<11))
                            s3=s3+" 00:00:00.000";
                            else if ((s2.equals("smalldatetime")) && (s3.length()<11))
                            s3=s3+" 00:00:00.00";
                            else if ((s2.indexOf("datetimeoffset")>=0) && (s3.length()<11))
                            s3=s3+" 00:00:00.000 +08:00";
                       }
                       s1=s1+s4+"'"+s3+"'";
                    }
                       s1=s1+" and "+variabl2517[variabl23451]+" ";
                       s2=variabl1501[variabl23451];
                   s3=aTextField2.getText().trim();  
                   s4=variabl225901;   
                   if ((main1.variabl1539.lastIndexOf(s2))>=0){
                    JOptionPane.showMessageDialog(null,"不允许使用图形与二进制数据类型作为查询条件!","提示", JOptionPane.INFORMATION_MESSAGE);
                    return;
                     }
                   else if(main1.variabl1545.lastIndexOf(","+s2+",")>=0){
                    if(s4.indexOf("like")>=0){
                      JOptionPane.showMessageDialog(null,"数字数据类型不能进行模式匹配！","提示", JOptionPane.INFORMATION_MESSAGE);
                      return;
                     }
                    else{
                      s1=s1+s4+s3.trim();
                    }
                  }
                    
                  else if(main1.variabl1537.lastIndexOf(s2)>=0){
                    if(s4.indexOf("like")>=0){
                        s3=" '%"+s3+"%'";
                        s1=s1+s4+s3;
                      }
                       else{
                        JOptionPane.showMessageDialog(null,"文本类大数据类型只能用包含或不包含进行查询","提示", JOptionPane.INFORMATION_MESSAGE);
                        return;
                    }
                  }
                  else { 
                       if(s4.indexOf("like")>=0) 
                          s3="%"+s3+"%";
                       else {
                       if ((s2.indexOf("datetime")>=0) && (s3.length()<10)){
                            JOptionPane.showMessageDialog(null,"日期时间类型进行查询时数据格式必须为yyyy-yy-dd","提示", JOptionPane.INFORMATION_MESSAGE);
                            return;
                       }
                       else if ((s2.equals("datetime")) && (s3.length()<11))
                            s3=s3+" 00:00:00.000";
                            else if ((s2.equals("smalldatetime")) && (s3.length()<11))
                            s3=s3+" 00:00:00.00";
                            else if ((s2.indexOf("datetimeoffset")>=0) && (s3.length()<11))
                            s3=s3+" 00:00:00.000 +08:00";
                       }
                       s1=s1+s4+"'"+s3+"'";
                    }
     
                 ResultSet rs=sta3.executeQuery(s1);
                   int rowNumber=0;  
                   rs.last(); 
                   rowNumber=rs.getRow(); 
                   rsmd3 = rs.getMetaData();
                   variabl2651=rsmd3.getColumnCount();  
                  variabl2197=new  String[rowNumber][variabl2651];  
                 rs.absolute(1); 
                 c=0;   
                 b=0;       
                 while(c<rowNumber) {
                    rs.absolute(c+1);  
                       while(b<variabl2651){
                           variabl2197[c][b]=rs.getString(b+1);
                           b++;
                       }
                       c++;
                       b=0;
                 }
                 rs.close();    
                 sta3.close();    
                 tableModel = new DefaultTableModel(variabl2197,variabl2517); 
                 table = new JTable(tableModel); 
                 table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
                 scrollPane.setViewportView(table);
                 printViewButton.setEnabled(true);  
                 printButton.setEnabled(true); 
              }
                  catch(Exception e1) 
                  {
                  JOptionPane.showMessageDialog( null, "查询数据出错！"+s1);
                  } 
           }
          });
         selectButton.setBounds(variabl2337, 40 ,variabl2339, 20);
         if (variabl1187.indexOf(",0,")>=0) {
          variabl2337=variabl2337+variabl2339;
             panel.add(selectButton); 
         }
         printViewButton = new JButton(variabl2405[1]);
         printViewButton.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {
               dataPreview1.printView1(variabl2197,variabl1079);
              }
          });
         printViewButton.setBounds(variabl2337, 40 ,variabl2339, 20);
         if (variabl1187.indexOf(",1,")>=0) {
          variabl2337=variabl2337+variabl2339;  
             panel.add(printViewButton);
             printViewButton.setEnabled(false);
         }
         printButton = new JButton(variabl2405[2]);
         printButton.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {
               dataPrint1.print1(variabl2197,variabl1079);
              }
          });
         printButton.setBounds(variabl2337, 40 ,variabl2339, 20);
         if (variabl1187.indexOf(",2,")>=0) {
          variabl2337=variabl2337+variabl2339;   
             panel.add(printButton);
             printButton.setEnabled(false);   
         }
      
         final JButton exitButton = new JButton(variabl2405[3]);
         exitButton.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {
               panel.setVisible(false); 
               frame.setVisible(false); 
               frame.dispose();
              }
          });
         exitButton.setBounds(variabl2337, 40 ,variabl2339, 20);
         if (variabl1187.indexOf(",3,")>=0) {
          variabl2337=variabl2337+variabl2339;
             panel.add(exitButton);
         }
         frame.getContentPane().add(panel, null); 
         frame.setVisible(true);    
         frame.getContentPane().add(panel, BorderLayout.SOUTH); 
      }
     }

12.源码12.部件程序，利用二个指定的字段和表达式进行多数据表二固定条件查询。
/**
 * 程序文件名：dataQuery6.java
 * 作者：程学先
 * 完成时间：2013年12月3日
 * 部件功能：利用二个指定的字段和表达式进行多数据二固定条件查询。
 */
import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.table.*;

import java.sql.*;

public class dataQuery6 extends JFrame {
 static dataQuery6 frame = new dataQuery6();
 static String variabl2603;
 static String variabl1873;
 static String variabl2429;
 static DefaultTableModel tableModel;
 static JTable table;
 static JScrollPane scrollPane = new JScrollPane();
 static JTextField aTextField, aTextField2;
 static JButton b1, b2;
 static String s1 = "";
 static ResultSet rs;
 static int b = 0, c = 0;
 static int variabl2651;
 static int variabl2113;
 static String[][] variabl2517;
 static String variabl1269 = "", variabl1787 = "", variabl17871 = "";
 static String[][] variabl2319 = { { " > ", "大于" }, { " < ", "小于" },
   { " = ", "等于" }, { " >= ", "大于等于" }, { " <= ", "小于等于" },
   { "<>", "不等于" }, { " like ", "包含" }, { " not like ", "不包含" } };
 static String[] variabl2411;
 static String[] variabl1501;
 static String[] variabl1169;
 static int[] variabl1489;
 static int[] variabl1119;
 static int variabl1853, variabl18531;
 static String[][] variabl2197;
 static String[] variabl1735;

 static String variabl2259, variabl22590, variabl22591, variabl225901;
 static int variabl2345 = 0, variabl23451 = 0;
 static String variabl2049;
 static String variabl1325;
 static int variabl2337 = 80;

 static Connection con;
 static ResultSetMetaData rsmd3;
 static Statement sta3;
 static int variabl2483 = 1000, variabl2503 = 600;
 static int variabl2851 = 0, variabl2339 = 0;
 static String[] variabl2405 = null;
 static String variabl1187;

 public static void means(String[] parameter) {
  frame = new dataQuery6();
  variabl2603 = "";
  scrollPane = new JScrollPane();
  s1 = "";
  b = 0;
  c = 0;
  variabl2259 = "";
  variabl22591 = "";
  variabl22590 = "";
  variabl225901 = "";
  variabl2337 = 80;
  variabl2483 = 1000;
  variabl2503 = 700;
  variabl2319[0][0] = " > ";
  variabl2319[0][1] = "大于";
  variabl2319[1][0] = " < ";
  variabl2319[1][1] = "小于";
  variabl2319[2][0] = " = ";
  variabl2319[2][1] = "等于";
  variabl2319[3][0] = " >= ";
  variabl2319[3][1] = "大于等于";
  variabl2319[4][0] = " <= ";
  variabl2319[4][1] = "小于等于";
  variabl2319[5][0] = " <> ";
  variabl2319[5][1] = "不等于";
  variabl2319[6][0] = " like ";
  variabl2319[6][1] = "包含";
  variabl2319[7][0] = " not like ";
  variabl2319[7][1] = "不包含";

  String[] variabl240501 = { "查询", "退出" };
  variabl2405 = new String[variabl240501.length];
  variabl2851 = 0;
  for (int i0 = 0; i0 < variabl240501.length; i0++)
   variabl2405[i0] = variabl240501[i0];
  if (parameter[11].length() > 0) {
   variabl1187 = parameter[11];

   variabl1187 = variabl1187.replaceAll("；", ";");
   variabl1187 = variabl1187.replaceAll("。", ";");
   variabl1187 = variabl1187.replaceAll(":", ";");
   variabl1187 = variabl1187.replaceAll("：", ";");
   if (variabl1187.indexOf(";") > 0) {
    String s601[] = variabl1187.split(",");
    variabl1187 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (s601[i01].indexOf(";") > 0) {
      String s602[] = s601[i01].split(";");
      variabl2405[Integer.parseInt((s602[0]))] = s602[1];
      variabl1187 = variabl1187 + "," + s602[0];
      variabl2851++;
     } else {
      variabl1187 = variabl1187 + "," + s601[i01];
      variabl2851++;
     }
    }
   } else {
    String s601[] = variabl1187.split(",");
    variabl1187 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (i01 == 0)
      variabl1187 = s601[i01];
     else
      variabl1187 = variabl1187 + "," + s601[i01];
     variabl2851++;
    }
   }
  } else {
   variabl1187 = "";
   for (int i1 = 0; i1 < variabl2405.length; i1++) {
    if (i1 == 0)
     variabl1187 = variabl1187 + i1;
    else
     variabl1187 = variabl1187 + "," + i1;
    variabl2851++;
   }
  }
  variabl1187 = "," + variabl1187 + ",";
  variabl2483 = 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) {
  }

  variabl2259 = parameter[12];
  variabl22591 = parameter[13];
  variabl2345 = Integer.valueOf(parameter[9]);
  variabl23451 = Integer.valueOf(parameter[10]);
  variabl2603 = parameter[4];
  variabl2049 = parameter[20];
  variabl2517 = new String[2][];

  variabl1325 = parameter[19];
  if (variabl1325.lastIndexOf(",") == variabl1325.length() - 1)
   variabl1325 = variabl1325.substring(0, variabl1325.length() - 1);
  String[] s6 = variabl1325.split(",");
  String variabl1269 = s6[variabl2345];
  String variabl12691 = s6[variabl23451];

  String s2 = "";
  if (parameter[8].length() > 0) {
   variabl1735 = parameter[8].split(",");
   variabl2517 = new String[2][variabl1735.length];
   for (int i = 0; i < variabl1735.length; i++) {
    variabl2517[0][i] = s6[Integer.parseInt(variabl1735[i])];
    variabl2517[1][i] = variabl2517[0][i];
    if (s2.length() > 0)
     s2 = s2 + "," + variabl2517[0][i];
    else
     s2 = variabl2517[0][i];
   }
   variabl1325 = s2;
  } else {
   variabl2517 = new String[2][s6.length];
   for (int i = 0; i < s6.length; i++) {
    variabl2517[0][i] = s6[i];
    variabl2517[1][i] = s6[i];
    if (s2.length() > 0)
     s2 = s2 + "," + variabl2517[0][i];
    else
     s2 = variabl2517[0][i];
   }
   s2 = " * ";
  }
  String s11 = variabl2603;
  if (variabl2603.indexOf(",") > 0) {
   String[] s12 = variabl2603.split(",");
   s11 = s12[0];
  }
  variabl2429 = parameter[0];
  String[] t1;
  variabl1873 = "";
  if (variabl2429.lastIndexOf(s11 + "字典表") > 0) {
   t1 = variabl2429.split(",");
   for (int i = 0; i < t1.length; i++)
    if (t1[i].lastIndexOf(s11 + "字典表") >= 0)
     variabl1873 = t1[i];
  }
  if (variabl1873.length() > 0) {
   try {
    con = main1.getConn();
    sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select * from " + variabl1873;
    rs = sta3.executeQuery(s1);
    ResultSetMetaData rsmd = rs.getMetaData();
    int variabl26510 = rsmd.getColumnCount();
    int numberOfColumns = rsmd.getColumnCount();
    String s14 = "";
    String s15 = "";
    int b = 1;
    while (rs.absolute(b)) {
     b++;
     s14 = rs.getString(1).trim();
     s15 = rs.getString(2).trim();
     for (int j = 0; j < variabl2517[0].length; j++) {
      if (variabl2517[0][j].trim().equalsIgnoreCase(
        s14.trim())) {
       variabl2517[1][j] = s15;
       break;
      } else if ((variabl2517[0][j].trim() + ",").indexOf("."
        + s14 + ",") > 0) {
       variabl2517[1][j] = variabl2517[1][j].replace(s14,
         s15);
       break;
      }
     }
    }
    rs.close();
    con.close();
    sta3.close();
   } catch (SQLException e) {
    JOptionPane.showMessageDialog(null, "连接数据库出错！");
   }
  }
  try {
   con = main1.getConn();
   sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
     ResultSet.CONCUR_UPDATABLE);
   if (variabl2049.trim().length() > 0)
    s1 = "select " + variabl1325 + " from " + variabl2603
      + " where " + variabl2049;
   else
    s1 = "select " + variabl1325 + " from " + variabl2603;
   ResultSet rs = sta3.executeQuery(s1);
   rsmd3 = rs.getMetaData();
   variabl2651 = rsmd3.getColumnCount();
   variabl1501 = new String[variabl2651];
   variabl1489 = new int[variabl2651];
   variabl2345 = -1;
   variabl23451 = -1;
   for (int i = 0; i < variabl2651; i++) {
    variabl1501[i] = rsmd3.getColumnTypeName(i + 1);
    variabl1489[i] = rsmd3.getColumnDisplaySize(i + 1);
    if (variabl1489[i] < variabl2517[0][i].length())
     variabl1489[i] = variabl2517[0][i].length();
    if (variabl1489[i] > 50)
     variabl1489[i] = 50;
    if (variabl1489[i] < variabl2517[0][i].length())
     variabl1489[i] = variabl2517[0][i].length();
    if (variabl1489[i] > 50)
     variabl1489[i] = 50;
    if (("," + variabl2517[0][i] + ",").lastIndexOf(","
      + variabl1269 + ",") >= 0)
     variabl2345 = i;
    if (("," + variabl2517[0][i] + ",").lastIndexOf("."
      + variabl1269 + ",") >= 0)
     variabl2345 = i;
    if (("," + variabl2517[0][i] + ",").lastIndexOf(","
      + variabl12691 + ",") >= 0)
     variabl23451 = i;
    if (("," + variabl2517[0][i] + ",").lastIndexOf("."
      + variabl12691 + ",") >= 0)
     variabl23451 = i;
    b++;
   }
   if (variabl2345 < 0) {
    JOptionPane.showMessageDialog(null, "查询要求字段未包含在所选字段号表中，没法查询！");
    return;
   }
   if (variabl23451 < 0) {
    JOptionPane.showMessageDialog(null, "查询要求字段未包含在所选字段号表中，没法查询！");
    return;
   }

   int rowNumber = 0;
   rs.last();
   rowNumber = rs.getRow();
   variabl2197 = new String[rowNumber][variabl2651];
   rs.absolute(1);
   c = 0;
   b = 0;
   while (c < rowNumber) {
    rs.absolute(c + 1);
    while (b < variabl2651) {
     variabl2197[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close();
   sta3.close();
   con.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "查询数据出错！" + s1);
  }

  frame.setTitle("查询部件程序                                作者：程学先");
  frame.setBounds(10, 10, variabl2483 - 10, variabl2503 - 10);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.getContentPane().setLayout(null);
  final JPanel panel = new JPanel(false);
  panel.setLayout(null);
  panel.setBounds(20, 20, variabl2483 - 50, variabl2503 - 20);
  tableModel = new DefaultTableModel(variabl2197, variabl2517[1]);
  table = new JTable(tableModel);
  table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  scrollPane.getViewport().add(table, null);
  scrollPane.setBounds(30, 60, variabl2483 - 100, variabl2503 - 200);
  for (int i = 0; i < variabl2651; i++) {
   TableColumn tc = table.getColumn(variabl2517[1][i]);
   tc.setPreferredWidth(variabl1489[i] * 12);
  }
  panel.add(scrollPane);

  JLabel label1 = new JLabel(variabl2517[1][variabl2345]);
  label1.setBounds(variabl2337, 10,
    variabl2517[1][variabl2345].length() * 15, 20);
  panel.add(label1);
  variabl2337 = variabl2337 + variabl2517[1][variabl2345].length() * 15;

  JLabel label2 = new JLabel(variabl2259);
  label2.setBounds(variabl2337, 10, variabl2259.length() * 15, 20);
  panel.add(label2);
  variabl2337 = variabl2337 + variabl2259.length() * 15;

  aTextField = new JTextField("", 10);
  aTextField.setBounds(variabl2337, 10, 150, 20);
  panel.add(aTextField);
  variabl2337 = variabl2337 + 150;

  JLabel label3 = new JLabel(variabl2517[1][variabl23451]);
  label3.setBounds(variabl2337, 10,
    variabl2517[1][variabl23451].length() * 15, 20);
  panel.add(label3);
  variabl2337 = variabl2337 + variabl2517[1][variabl23451].length() * 15;

  JLabel label4 = new JLabel(variabl22591);
  label4.setBounds(variabl2337, 10, variabl22591.length() * 15, 20);
  panel.add(label4);
  variabl2337 = variabl2337 + variabl22591.length() * 15;

  aTextField2 = new JTextField("", 10);
  aTextField2.setBounds(variabl2337, 10, 150, 20);
  panel.add(aTextField2);

  variabl2339 = (variabl2483 - 630) / variabl2851;
  int variabl2337 = 600;
  final JButton selectButton = new JButton(variabl2405[0]);
  selectButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    try {
     con = main1.getConn();
     sta3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     for (int i = 0; i < variabl2319.length; i++) {
      if (variabl2319[i][1].trim().equalsIgnoreCase(
        variabl2259.trim())) {
       variabl22590 = variabl2319[i][0];
      }
      if (variabl2319[i][1].trim().equalsIgnoreCase(
        variabl22591.trim())) {
       variabl225901 = variabl2319[i][0];
      }
     }
     if (variabl1325.lastIndexOf(",") == variabl1325.length() - 1)
      variabl1325 = variabl1325.substring(0,
        variabl1325.length() - 1);
     s1 = "select " + variabl1325 + " from " + variabl2603;
     if (variabl2049.trim().length() > 0)
      s1 = s1 + " where " + variabl2049 + " and "
        + variabl2517[0][variabl2345];
     else
      s1 = s1 + " where " + variabl2517[0][variabl2345];

     String s2 = variabl1501[variabl2345];
     String s3 = aTextField.getText().trim();
     String s4 = variabl22590;
     if ((main1.variabl1539.lastIndexOf(s2)) >= 0) {
      JOptionPane.showMessageDialog(null,
        "不允许使用图形与二进制数据类型作为查询条件!", "提示",
        JOptionPane.INFORMATION_MESSAGE);
      return;
     } else if (main1.variabl1545.lastIndexOf("," + s2 + ",") >= 0) {
      if (s4.indexOf("like") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字数据类型不能进行模式匹配！", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      } else {
       s1 = s1 + s4 + s3.trim();
      }
     } else if (main1.variabl1537.lastIndexOf(s2) >= 0) {
      if (s4.indexOf("like") >= 0) {
       s3 = " '%" + s3 + "%'";
       s1 = s1 + s4 + s3;
      } else {
       JOptionPane.showMessageDialog(null,
         "文本类大数据类型只能用包含或不包含进行查询", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      }
     } else {
      if (s4.indexOf("like") >= 0)
       s3 = "%" + s3 + "%";
      else {
       if ((s2.indexOf("datetime") >= 0)
         && (s3.length() < 10)) {
        JOptionPane.showMessageDialog(null,
          "日期时间类型进行查询时数据格式必须为yyyy-yy-dd", "提示",
          JOptionPane.INFORMATION_MESSAGE);
        return;
       } else if ((s2.equals("datetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000";
       else if ((s2.equals("smalldatetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.00";
       else if ((s2.indexOf("datetimeoffset") >= 0)
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000 +08:00";
      }
      s1 = s1 + s4 + "'" + s3 + "'";
     }

     s1 = s1 + " and " + variabl2517[0][variabl23451] + " ";
     s2 = variabl1501[variabl23451];
     s3 = aTextField2.getText().trim();
     s4 = variabl225901;
     if ((main1.variabl1539.lastIndexOf(s2)) >= 0) {
      JOptionPane.showMessageDialog(null,
        "不允许使用图形与二进制数据类型作为查询条件!", "提示",
        JOptionPane.INFORMATION_MESSAGE);
      return;
     } else if (main1.variabl1545.lastIndexOf("," + s2 + ",") >= 0) {
      if (s4.indexOf("like") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字数据类型不能进行模式匹配！", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      } else {
       s1 = s1 + s4 + s3.trim();
      }
     }

     else if (main1.variabl1537.lastIndexOf(s2) >= 0) {
      if (s4.indexOf("like") >= 0) {
       s3 = " '%" + s3 + "%'";
       s1 = s1 + s4 + s3;
      } else {
       JOptionPane.showMessageDialog(null,
         "文本类大数据类型只能用包含或不包含进行查询", "提示",
         JOptionPane.INFORMATION_MESSAGE);
       return;
      }
     } else {
      if (s4.indexOf("like") >= 0)
       s3 = "%" + s3 + "%";
      else {
       if ((s2.indexOf("datetime") >= 0)
         && (s3.length() < 10)) {
        JOptionPane.showMessageDialog(null,
          "日期时间类型进行查询时数据格式必须为yyyy-yy-dd", "提示",
          JOptionPane.INFORMATION_MESSAGE);
        return;
       } else if ((s2.equals("datetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000";
       else if ((s2.equals("smalldatetime"))
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.00";
       else if ((s2.indexOf("datetimeoffset") >= 0)
         && (s3.length() < 11))
        s3 = s3 + " 00:00:00.000 +08:00";
      }
      s1 = s1 + s4 + "'" + s3 + "'";
     }
     System.out.println(s1);
     ResultSet rs = sta3.executeQuery(s1);
     int rowNumber = 0;
     rs.last();
     rowNumber = rs.getRow();
     rsmd3 = rs.getMetaData();
     variabl2651 = rsmd3.getColumnCount();
     variabl2197 = new String[rowNumber][variabl2651];
     c = 0;
     b = 0;
     while (c < rowNumber) {
      rs.absolute(c + 1);
      while (b < variabl2651) {
       variabl2197[c][b] = rs.getString(b + 1);
       b++;
      }
      c++;
      b = 0;
     }
     rs.close();
     sta3.close();
     con.close();
     tableModel = new DefaultTableModel(variabl2197,
       variabl2517[1]);
     table = new JTable(tableModel);
     table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
     scrollPane.setViewportView(table);
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "查询数据出错！" + s1);
    }
   }
  });
  selectButton.setBounds(variabl2337, 10, variabl2339, 20);
  if (variabl1187.indexOf(",0,") >= 0) {
   variabl2337 = variabl2337 + variabl2339;
   panel.add(selectButton);
  }

  final JButton exitButton = new JButton(variabl2405[1]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    panel.setVisible(false);
    frame.setVisible(false);
    frame.dispose();
   }
  });
  exitButton.setBounds(variabl2337, 10, variabl2339, 20);
  if (variabl1187.indexOf(",1,") >= 0) {
   variabl2337 = variabl2337 + variabl2339;
   panel.add(exitButton);
  }

  frame.getContentPane().add(panel, null);
  frame.setVisible(true);
  frame.getContentPane().add(panel, BorderLayout.SOUTH);
 }

 public static String[] getArray(String str) {
  String[] array;
  String s1 = str;
  int i = 1;
  while (s1.indexOf(",") != -1) {
   s1 = s1.substring(s1.indexOf(",") + 1, s1.length());
   i++;
  }
  array = new String[i];
  int j = 0;
  while (str.indexOf(",") != -1) {
   array[j] = str.substring(0, str.indexOf(","));
   str = str.substring(str.indexOf(",") + 1, str.length());
   array[j + 1] = str;
   j++;
  }
  return array;
 }
}

13.源码13.部件程序，多表通用二条件查询程序。
/**
 * 程序文件名：dataQuery7.java
 * 作者：程学先
 * 完成时间：2013年12月3日
 * 部件功能：多表通用二条件查询程序。
 */
import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.table.*;

import java.sql.*;

public class dataQuery7 extends JFrame {
 static dataQuery7 frame = new dataQuery7();
 static String variabl2603;
 static String variabl1873;
 static String variabl2429;
 static DefaultTableModel tableModel;
 static JTable table;
 static JScrollPane scrollPane = new JScrollPane();
 static JTextField aTextField, aTextField2;
 static JButton b1, b2;
 static Choice choice, choice1;
 static Choice choice0, choice01;
 static String s1 = "";
 static ResultSet rs;
 static int b = 0, c = 0;
 static int variabl2651;
 static int variabl2113;
 static String[][] variabl2517;
 static String variabl1269 = "", variabl1787 = "", variabl17871 = "";
 static String[][] variabl2319 = { { " > ", "大于" }, { " < ", "小于" },
   { " = ", "等于" }, { " >= ", "大于等于" }, { " <= ", "小于等于" },
   { "<>", "不等于" }, { " like ", "包含" }, { " not like ", "不包含" } };
 static String[] variabl2411;
 static String[] variabl1501;
 static String[] variabl1169;
 static int[] variabl1489;
 static int[] variabl1119;
 static int variabl1853, variabl18531;
 static String[][] variabl2197;
 static String variabl2259, variabl22590, variabl22591, variabl225901;
 static int variabl2345 = 0, variabl23451 = 0;
 static String variabl2049;
 static int variabl2337 = 80;
 static String variabl1325;
 static String[] variabl1735;
 static Connection con;
 static ResultSetMetaData rsmd3;
 static Statement sta3;
 static int variabl2483 = 1000, variabl2503 = 600;
 static int variabl2851 = 0, variabl2339 = 0;
 static String[] variabl2405 = null;
 static String variabl1187;

 public static void means(String[] parameter) {
  frame = new dataQuery7();
  variabl2603 = "";
  scrollPane = new JScrollPane();
  s1 = "";
  b = 0;
  c = 0;
  variabl2259 = "";
  variabl22591 = "";
  variabl22590 = "";
  variabl225901 = "";
  variabl2337 = 80;
  variabl2483 = 1000;
  variabl2503 = 700;
  variabl2319[0][0] = " > ";
  variabl2319[0][1] = "大于";
  variabl2319[1][0] = " < ";
  variabl2319[1][1] = "小于";
  variabl2319[2][0] = " = ";
  variabl2319[2][1] = "等于";
  variabl2319[3][0] = " >= ";
  variabl2319[3][1] = "大于等于";
  variabl2319[4][0] = " <= ";
  variabl2319[4][1] = "小于等于";
  variabl2319[5][0] = " <> ";
  variabl2319[5][1] = "不等于";
  variabl2319[6][0] = " like ";
  variabl2319[6][1] = "包含";
  variabl2319[7][0] = " not like ";
  variabl2319[7][1] = "不包含";
  String[] variabl240501 = { "查询", "退出" };
  variabl2405 = new String[variabl240501.length];
  variabl2851 = 0;
  for (int i0 = 0; i0 < variabl240501.length; i0++)
   variabl2405[i0] = variabl240501[i0];
  if (parameter[11].length() > 0) {
   variabl1187 = parameter[11];

   variabl1187 = variabl1187.replaceAll("；", ";");
   variabl1187 = variabl1187.replaceAll("。", ";");
   variabl1187 = variabl1187.replaceAll(":", ";");
   variabl1187 = variabl1187.replaceAll("：", ";");
   if (variabl1187.indexOf(";") > 0) {
    String s601[] = variabl1187.split(",");
    variabl1187 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (s601[i01].indexOf(";") > 0) {
      String s602[] = s601[i01].split(";");
      variabl2405[Integer.parseInt((s602[0]))] = s602[1];
      variabl1187 = variabl1187 + "," + s602[0];
      variabl2851++;
     } else {
      variabl1187 = variabl1187 + "," + s601[i01];
      variabl2851++;
     }
    }
   } else {
    String s601[] = variabl1187.split(",");
    variabl1187 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (i01 == 0)
      variabl1187 = s601[i01];
     else
      variabl1187 = variabl1187 + "," + s601[i01];
     variabl2851++;
    }
   }
  } else {
   variabl1187 = "";
   for (int i1 = 0; i1 < variabl2405.length; i1++) {
    if (i1 == 0)
     variabl1187 = variabl1187 + i1;
    else
     variabl1187 = variabl1187 + "," + i1;
    variabl2851++;
   }
  }
  variabl1187 = "," + variabl1187 + ",";
  variabl2483 = 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];
  variabl2049 = parameter[20];
  variabl2429 = parameter[0];
  variabl2517 = new String[2][];
  variabl1325 = parameter[19];
  if (variabl1325.lastIndexOf(",") == variabl1325.length() - 1)
   variabl1325 = variabl1325.substring(0, variabl1325.length() - 1);
  String[] s6 = variabl1325.split(",");
  String s2 = "";
  if (parameter[8].length() > 0) {
   variabl1735 = parameter[8].split(",");
   variabl2517 = new String[2][variabl1735.length];
   for (int i = 0; i < variabl1735.length; i++) {

    variabl2517[0][i] = s6[Integer.parseInt(variabl1735[i])];
    variabl2517[1][i] = variabl2517[0][i];
    if (s2.length() > 0)
     s2 = s2 + "," + variabl2517[0][i];
    else
     s2 = variabl2517[0][i];
   }
   variabl1325 = s2;
  } else {
   variabl2517 = new String[2][s6.length];
   for (int i = 0; i < s6.length; i++) {
    variabl2517[0][i] = s6[i];
    variabl2517[1][i] = variabl2517[0][i];
    if (s2.length() > 0)
     s2 = s2 + "," + variabl2517[0][i];
    else
     s2 = variabl2517[0][i];
   }
   variabl1325 = s2;
   s2 = " * ";
  }
  String s11 = variabl2603;
  if (variabl2603.indexOf(",") > 0) {
   String[] s12 = variabl2603.split(",");
   s11 = s12[0];
  }
  String[] t1;
  variabl1873 = "";
  if (variabl2429.lastIndexOf(s11 + "字典表") > 0) {
   t1 = variabl2429.split(",");
   for (int i = 0; i < t1.length; i++)
    if (t1[i].lastIndexOf(s11 + "字典表") >= 0)
     variabl1873 = t1[i];
  }
  if (variabl1873.length() > 0) {
   try {
    con = main1.getConn();
    sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select * from " + variabl1873;
    rs = sta3.executeQuery(s1);
    ResultSetMetaData rsmd = rs.getMetaData();
    int variabl26510 = rsmd.getColumnCount();
    int numberOfColumns = rsmd.getColumnCount();
    String s14 = "";
    String s15 = "";
    int b = 1;
    while (rs.absolute(b)) {
     b++;
     s14 = rs.getString(1).trim();
     s15 = rs.getString(2).trim();
     for (int j = 0; j < variabl2517[0].length; j++) {
      if (variabl2517[0][j].trim().equalsIgnoreCase(
        s14.trim())) {
       variabl2517[1][j] = s15;
       break;
      } else if ((variabl2517[0][j].trim() + ",").indexOf("."
        + s14 + ",") > 0) {
       variabl2517[1][j] = variabl2517[1][j].replace(s14,
         s15);
       break;
      }
     }
    }
    rs.close();
    con.close();
    sta3.close();
   } catch (SQLException e) {
    JOptionPane.showMessageDialog(null, "连接数据库出错！");
   }
  }
  try {
   con = main1.getConn();
   sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
     ResultSet.CONCUR_UPDATABLE);
   if (variabl2049.trim().length() > 0)
    s1 = "select " + variabl1325 + " from " + variabl2603
      + " where " + variabl2049;
   else
    s1 = "select " + variabl1325 + " from " + variabl2603;
   ResultSet rs = sta3.executeQuery(s1);
   rsmd3 = rs.getMetaData();
   variabl2651 = rsmd3.getColumnCount();
   variabl1501 = new String[variabl2651];
   variabl1489 = new int[variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl1501[i] = rsmd3.getColumnTypeName(i + 1);
    variabl1489[i] = rsmd3.getColumnDisplaySize(i + 1);
    if (variabl1489[i] < variabl2517[0][i].length())
     variabl1489[i] = variabl2517[0][i].length();
    if (variabl1489[i] > 50)
     variabl1489[i] = 50;
    b++;
   }

   int rowNumber = 0;
   rs.last();
   rowNumber = rs.getRow();
   rsmd3 = rs.getMetaData();
   variabl2651 = rsmd3.getColumnCount();
   variabl2197 = new String[rowNumber][variabl2651];
   rs.absolute(1);
   c = 0;
   b = 0;
   while (c < rowNumber) {
    rs.absolute(c + 1);
    while (b < variabl2651) {
     variabl2197[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close();
   sta3.close();
   con.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "查询数据出错！" + s1);
  }
  frame.setTitle("查询部件程序                                作者：程学先");
  frame.setBounds(10, 10, variabl2483 - 10, variabl2503);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.getContentPane().setLayout(null);
  final JPanel panel = new JPanel(false);
  panel.setLayout(null);
  panel.setBounds(20, 20, variabl2483 - 50, variabl2503 - 10);
  tableModel = new DefaultTableModel(variabl2197, variabl2517[1]);
  table = new JTable(tableModel);
  table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  scrollPane.getViewport().add(table, null);
  scrollPane.setBounds(30, 70, variabl2483 - 100, variabl2503 - 200);
  for (int i = 0; i < variabl2651; i++) {
   TableColumn tc = table.getColumn(variabl2517[1][i]);
   tc.setPreferredWidth(variabl1489[i] * 12);
  }
  panel.add(scrollPane);
  variabl2337 = 30;
  JLabel label1 = new JLabel("请选字段名：");
  label1.setBounds(variabl2337 + 20, 10, 80, 20);
  panel.add(label1);
  variabl2337 = variabl2337 + 100;
  choice = new Choice();
  for (int i = 0; i < variabl2651; i++) {
   choice.add(variabl2517[1][i]);
  }
  choice.setBounds(variabl2337, 10, 100, 60);
  panel.add(choice);
  variabl2337 = variabl2337 + 100;
  choice1 = new Choice();
  for (int i = 0; i < 8; i++) {
   choice1.add(variabl2319[i][1]);
  }
  choice1.setBounds(variabl2337, 10, 80, 60);
  panel.add(choice1);
  variabl2337 = variabl2337 + 100;
  aTextField = new JTextField("", 10);
  aTextField.setBounds(variabl2337, 10, 150, 20);
  panel.add(aTextField);
  variabl2337 = variabl2337 + 150;

  JLabel label01 = new JLabel("请选字段名：");
  label01.setBounds(variabl2337 + 20, 10, 80, 20);
  panel.add(label01);
  variabl2337 = variabl2337 + 100;
  choice0 = new Choice();
  for (int i = 0; i < variabl2651; i++) {
   choice0.add(variabl2517[1][i]);
  }
  choice0.setBounds(variabl2337, 10, 100, 60);
  panel.add(choice0);
  variabl2337 = variabl2337 + 100;

  choice01 = new Choice();
  for (int i = 0; i < 8; i++) {
   choice01.add(variabl2319[i][1]);
  }
  choice01.setBounds(variabl2337, 10, 80, 60);
  panel.add(choice01);
  variabl2337 = variabl2337 + 80;

  aTextField2 = new JTextField("", 10);
  aTextField2.setBounds(variabl2337, 10, 150, 20);
  panel.add(aTextField2);

  variabl2339 = (variabl2483 - 630) / variabl2851;
  int variabl2337 = 600;
  final JButton selectButton = new JButton(variabl2405[0]);
  selectButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    variabl2345 = choice.getSelectedIndex();
    variabl2259 = choice1.getSelectedItem();
    variabl23451 = choice0.getSelectedIndex();
    variabl22591 = choice01.getSelectedItem();
    try {
     con = main1.getConn();
     sta3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     for (int i = 0; i < variabl2319.length; i++) {
      if (variabl2319[i][1].trim().equalsIgnoreCase(
        variabl2259.trim())) {
       variabl22590 = variabl2319[i][0];
      }
      if (variabl2319[i][1].trim().equalsIgnoreCase(
        variabl22591.trim())) {
       variabl225901 = variabl2319[i][0];
      }
     }
     if (variabl1325.lastIndexOf(",") == variabl1325.length() - 1)
      variabl1325 = variabl1325.substring(0,
        variabl1325.length() - 1);
     s1 = "select " + variabl1325 + " from " + variabl2603;
     if (variabl2049.trim().length() > 0)
      s1 = s1 + " where " + variabl2049 + " and "
        + variabl2517[0][variabl2345];
     else
      s1 = s1 + " where " + variabl2517[0][variabl2345];

     String s3 = aTextField.getText().trim();
     if (((main1.variabl1539.lastIndexOf(","
       + variabl1501[variabl2345] + ",")) >= 0)
       || ((main1.variabl1539.lastIndexOf(","
         + variabl1501[variabl23451] + ",")) >= 0)) {
      JOptionPane.showMessageDialog(null,
        "不允许使用图形与二进制数据类型作为查询条件!", "提示",
        JOptionPane.INFORMATION_MESSAGE);
      return;
     }
     if (variabl2259.lastIndexOf("包含") < 0) {
      if (main1.variabl1545.lastIndexOf(","
        + variabl1501[variabl2345] + ",") >= 0)
       s1 = s1 + variabl22590 + s3;
      else
       s1 = s1 + variabl22590 + "'" + s3 + "'";
     } else {
      if (main1.variabl1545.lastIndexOf(","
        + variabl1501[variabl2345] + ",") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字类数据类型不能做包含查询！");
       return;
      } else if (variabl2259.lastIndexOf("不包含") >= 0)
       s1 = s1 + " not like '%" + s3 + "%'";
      else
       s1 = s1 + " like '%" + s3 + "%'";
     }

     s3 = aTextField2.getText().trim();
     if (variabl22591.lastIndexOf("包含") < 0)
      if (main1.variabl1545.lastIndexOf(","
        + variabl1501[variabl23451] + ",") >= 0)
       s1 = s1 + " and " + variabl2517[0][variabl23451]
         + variabl225901 + s3;
      else
       s1 = s1 + " and " + variabl2517[0][variabl23451]
         + variabl225901 + "'" + s3 + "'";
     else if (main1.variabl1545.lastIndexOf(","
       + variabl1501[variabl23451] + ",") >= 0) {
      JOptionPane.showMessageDialog(null, "数字类数据类型不能做包含查询！");
      return;
     } else if (variabl22591.lastIndexOf("不包含") >= 0)
      s1 = s1 + " and " + variabl2517[0][variabl23451]
        + " not like '%" + s3 + "%'";
     else
      s1 = s1 + " and " + variabl2517[0][variabl23451]
        + " like '%" + s3 + "%'";

     ResultSet rs = sta3.executeQuery(s1);
     int rowNumber = 0;
     rs.last();
     rowNumber = rs.getRow();
     rsmd3 = rs.getMetaData();
     variabl2651 = rsmd3.getColumnCount();
     variabl2197 = new String[rowNumber][variabl2651];
     c = 0;
     b = 0;
     while (c < rowNumber) {
      rs.absolute(c + 1);
      while (b < variabl2651) {
       variabl2197[c][b] = rs.getString(b + 1);
       b++;
      }
      c++;
      b = 0;
     }
     rs.close();
     sta3.close();
     con.close();
     tableModel = new DefaultTableModel(variabl2197,
       variabl2517[1]);
     table = new JTable(tableModel);
     table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
     scrollPane.setViewportView(table);
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "查询数据出错！" + s1);
    }
   }
  });
  selectButton.setBounds(variabl2337, 40, variabl2339, 20);
  if (variabl1187.indexOf(",0,") >= 0) {
   variabl2337 = variabl2337 + variabl2339;
   panel.add(selectButton);
  }

  final JButton exitButton = new JButton(variabl2405[1]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    panel.setVisible(false);
    frame.setVisible(false);
    frame.dispose();
   }
  });
  exitButton.setBounds(variabl2337, 40, variabl2339, 20);
  if (variabl1187.indexOf(",1,") >= 0) {
   variabl2337 = variabl2337 + variabl2339;
   panel.add(exitButton);
  }

  frame.getContentPane().add(panel, null);
  frame.setVisible(true);
  frame.getContentPane().add(panel, BorderLayout.SOUTH);
 }

 public static String[] getArray(String str) {
  String[] array;
  String s1 = str;
  int i = 1;
  while (s1.indexOf(",") != -1) {
   s1 = s1.substring(s1.indexOf(",") + 1, s1.length());
   i++;
  }
  array = new String[i];
  int j = 0;
  while (str.indexOf(",") != -1) {
   array[j] = str.substring(0, str.indexOf(","));
   str = str.substring(str.indexOf(",") + 1, str.length());
   array[j + 1] = str;
   j++;
  }
  return array;
 }
}

14.源码14.部件程序，给定查询条件表达式的多数据表单一条件或二条件查询程序。可求总计数据，可按格式打印报表。
/**
 * 程序文件名：dataQuery8.java
 * 作者：程学先
 * 完成时间：2013年11月27日
 * 部件功能：在参数中直接给定查询条件表达式的主题部分和输出要求多表单条件或二条件查询程序，
 */

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;

import java.sql.*;

public class dataQuery8 extends JFrame {
 static dataQuery8 frame = new dataQuery8();
 static String variabl2603 = "";
 static DefaultTableModel tableModel;
 static JTable table;
 static JScrollPane scrollPane = new JScrollPane();
 static JTextField aTextField, aTextField2;
 static JButton b1, b2;
 static String s1 = "";
 static ResultSet rs;
 static int b = 0, c = 0;
 static int variabl2651;
 static int variabl2113;
 static String[] variabl2517;
 static String[][] variabl2319 = { { " > ", "大于" }, { " < ", "小于" },
   { " = ", "等于" }, { " >= ", "大于等于" }, { " <= ", "小于等于" },
   { "<>", "不等于" }, { " like ", "包含" }, { " not like ", "不包含" } };
 static String[] variabl1913;
 static String[] variabl2411;
 static String[] variabl1501;
 static String[] variabl1169;
 static int[] variabl1489;
 static int[] variabl1119;
 static int variabl1853, variabl18531;
 static int variabl2345, variabl23451;
 static String variabl2259 = "", variabl22591 = "", variabl2485 = "",
   variabl22590 = "", variabl225901 = "";
 static String variabl2385 = "", variabl23851 = "";
 static String variabl1325;
 static String[] variabl1735;
 static String variabl1413, variabl2049;
 static String[][] variabl2197;
 static String[] variabl2669;
 static String variabl2101;

 static int variabl2337 = 80;
 static String variabl1079;

 static Connection con;
 static ResultSetMetaData rsmd3;
 static Statement sta3;
 static int variabl2483 = 1000, variabl2503 = 700;
 static int variabl2851 = 0, variabl2339 = 0;
 static String[] variabl2405 = null;
 static String variabl1187;
 static JButton printViewButton, printButton;

 public static void means(String[] parameter) {
  frame = new dataQuery8();
  variabl2603 = "";
  scrollPane = new JScrollPane();
  s1 = "";
  b = 0;
  c = 0;
  variabl2259 = "";
  variabl22591 = "";
  variabl2485 = "";
  variabl22590 = "";
  variabl225901 = "";
  variabl2385 = "";
  variabl23851 = "";
  variabl2337 = 80;
  variabl2483 = 1000;
  variabl2503 = 700;
  variabl2319[0][0] = " > ";
  variabl2319[0][1] = "大于";
  variabl2319[1][0] = " < ";
  variabl2319[1][1] = "小于";
  variabl2319[2][0] = " = ";
  variabl2319[2][1] = "等于";
  variabl2319[3][0] = " >= ";
  variabl2319[3][1] = "大于等于";
  variabl2319[4][0] = " <= ";
  variabl2319[4][1] = "小于等于";
  variabl2319[5][0] = " <> ";
  variabl2319[5][1] = "不等于";
  variabl2319[6][0] = " like ";
  variabl2319[6][1] = "包含";
  variabl2319[7][0] = " not like ";
  variabl2319[7][1] = "不包含";

  String[] variabl240501 = { "查询", "打印预览", "打印", "退出" };
  variabl2405 = new String[variabl240501.length];
  variabl2851 = 0;
  for (int i0 = 0; i0 < variabl240501.length; i0++)
   variabl2405[i0] = variabl240501[i0];
  if (parameter[11].length() > 0) {
   variabl1187 = parameter[11];

   variabl1187 = variabl1187.replaceAll("；", ";");
   variabl1187 = variabl1187.replaceAll("。", ";");
   variabl1187 = variabl1187.replaceAll(":", ";");
   variabl1187 = variabl1187.replaceAll("：", ";");
   if (variabl1187.indexOf(";") > 0) {
    String s601[] = variabl1187.split(",");
    variabl1187 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (s601[i01].indexOf(";") > 0) {
      String s602[] = s601[i01].split(";");
      variabl2405[Integer.parseInt((s602[0]))] = s602[1];
      variabl1187 = variabl1187 + "," + s602[0];
      variabl2851++;
     } else {
      variabl1187 = variabl1187 + "," + s601[i01];
      variabl2851++;
     }
    }
   } else {
    String s601[] = variabl1187.split(",");
    variabl1187 = "";
    for (int i01 = 0; i01 < s601.length; i01++) {
     if (i01 == 0)
      variabl1187 = s601[i01];
     else
      variabl1187 = variabl1187 + "," + s601[i01];
     variabl2851++;
    }
   }
  } else {
   variabl1187 = "";
   for (int i1 = 0; i1 < variabl2405.length; i1++) {
    if (i1 == 0)
     variabl1187 = variabl1187 + i1;
    else
     variabl1187 = variabl1187 + "," + i1;
    variabl2851++;
   }
  }
  variabl1187 = "," + variabl1187 + ",";
  variabl2483 = 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];
  variabl1079 = parameter[15];
  variabl1413 = parameter[10];

  variabl1325 = parameter[19];
  if (variabl1325.lastIndexOf(",") == variabl1325.length() - 1)
   variabl1325 = variabl1325.substring(0, variabl1325.length() - 1);
  String[] s6 = variabl1325.split(",");
  String s2 = "";
  if (parameter[8].length() > 0) {
   variabl1735 = parameter[8].split(",");
   variabl2517 = new String[variabl1735.length];
   for (int i = 0; i < variabl1735.length; i++) {
    variabl2517[i] = s6[Integer.parseInt(variabl1735[i])];
    if (s2.length() > 0)
     s2 = s2 + "," + variabl2517[i];
    else
     s2 = variabl2517[i];
   }
   variabl1325 = s2;
  } else {
   variabl2517 = new String[s6.length];
   for (int i = 0; i < s6.length; i++) {
    variabl2517[i] = s6[i];
    if (s2.length() > 0)
     s2 = s2 + "," + variabl2517[i];
    else
     s2 = variabl2517[i];
   }
   variabl1325 = s2;
   s2 = " * ";
  }
  variabl2049 = parameter[20];
  variabl2101 = parameter[14];

  String[] g2, g3;
  if (variabl1413.lastIndexOf("与") > 0) {
   variabl2669 = variabl1413.split("与");
   variabl2485 = " and ";
  } else if (variabl1413.lastIndexOf("或者") > 0) {
   variabl2669 = variabl1413.split("或者");
   variabl2485 = " or ";
  } else {
   variabl2669 = new String[1];
   variabl2669[0] = variabl1413;
  }

  if (variabl2669[0].lastIndexOf("大于等于") > 0) {
   variabl22590 = ">=";
   variabl2385 = variabl2669[0].substring(0,
     variabl2669[0].lastIndexOf("大于等于"));
  } else if (variabl2669[0].lastIndexOf("小于等于") > 0) {
   variabl22590 = "<=";
   variabl2385 = variabl2669[0].substring(0,
     variabl2669[0].lastIndexOf("小于等于"));
  } else if (variabl2669[0].lastIndexOf("不等于") > 0) {
   variabl22590 = "!=";
   variabl2385 = variabl2669[0].substring(0,
     variabl2669[0].lastIndexOf("不等于"));
  } else if (variabl2669[0].lastIndexOf("大于") > 0) {
   variabl22590 = ">";
   variabl2385 = variabl2669[0].substring(0,
     variabl2669[0].lastIndexOf("大于"));
  } else if (variabl2669[0].lastIndexOf("小于") > 0) {
   variabl22590 = "<";
   variabl2385 = variabl2669[0].substring(0,
     variabl2669[0].lastIndexOf("小于"));
  } else if (variabl2669[0].lastIndexOf("等于") > 0) {
   variabl22590 = "=";
   variabl2385 = variabl2669[0].substring(0,
     variabl2669[0].lastIndexOf("等于"));
  } else if (variabl2669[0].lastIndexOf("不包含") > 0) {
   variabl22590 = "不包含";
   variabl2385 = variabl2669[0].substring(0,
     variabl2669[0].lastIndexOf("不包含"));
  } else if (variabl2669[0].lastIndexOf("包含") > 0) {
   variabl22590 = "包含";
   variabl2385 = variabl2669[0].substring(0,
     variabl2669[0].lastIndexOf("包含"));
  }

  if (variabl2485.length() > 0) {
   if (variabl2669[1].lastIndexOf("大于等于") > 0) {
    variabl225901 = ">=";
    variabl23851 = variabl2669[1].substring(0,
      variabl2669[1].lastIndexOf("大于等于"));
   } else if (variabl2669[1].lastIndexOf("小于等于") > 0) {
    variabl225901 = "<=";
    variabl23851 = variabl2669[1].substring(0,
      variabl2669[1].lastIndexOf("小于等于"));
   } else if (variabl2669[1].lastIndexOf("不等于") > 0) {
    variabl225901 = "!=";
    variabl23851 = variabl2669[1].substring(0,
      variabl2669[1].lastIndexOf("不等于"));
   } else if (variabl2669[1].lastIndexOf("大于") > 0) {
    variabl225901 = ">";
    variabl23851 = variabl2669[1].substring(0,
      variabl2669[1].lastIndexOf("大于"));
   } else if (variabl2669[1].lastIndexOf("小于") > 0) {
    variabl225901 = "<";
    variabl23851 = variabl2669[1].substring(0,
      variabl2669[1].lastIndexOf("小于"));
   } else if (variabl2669[1].lastIndexOf("等于") > 0) {
    variabl225901 = "=";
    variabl23851 = variabl2669[1].substring(0,
      variabl2669[1].lastIndexOf("等于"));
   } else if (variabl2669[1].lastIndexOf("不包含") > 0) {
    variabl225901 = "不包含";
    variabl23851 = variabl2669[1].substring(0,
      variabl2669[1].lastIndexOf("不包含"));
   } else if (variabl2669[1].lastIndexOf("包含") > 0) {
    variabl225901 = "包含";
    variabl23851 = variabl2669[1].substring(0,
      variabl2669[1].lastIndexOf("包含"));
   }
  }
  try {
   con = main1.getConn();
   sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
     ResultSet.CONCUR_UPDATABLE);
   if (variabl2049.trim().length() > 0)
    s1 = "select " + variabl1325 + " from " + variabl2603
      + " where " + variabl2049;
   else
    s1 = "select " + variabl1325 + " from " + variabl2603;
   ResultSet rs = sta3.executeQuery(s1);
   rsmd3 = rs.getMetaData();
   variabl2651 = rsmd3.getColumnCount();
   variabl1501 = new String[variabl2651];
   variabl1489 = new int[variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    if ((variabl2385.length() > 0)
      && (variabl2517[i].trim().equals(variabl2385.trim())))
     variabl2345 = i;
    else if (variabl2517[i]
      .substring(variabl2517[i].lastIndexOf(".") + 1,
        variabl2517[i].length()).trim()
      .equals(variabl2385.trim()))
     variabl2345 = i;
    if ((variabl2385.length() > 0)
      && (variabl2517[i].trim().equals(variabl23851.trim())))
     variabl23451 = i;
    else if (variabl2517[i]
      .substring(variabl2517[i].lastIndexOf(".") + 1,
        variabl2517[i].length()).trim()
      .equals(variabl23851.trim()))
     variabl23451 = i;
    variabl1501[i] = rsmd3.getColumnTypeName(i + 1);
    variabl1489[i] = rsmd3.getColumnDisplaySize(i + 1);
    if (variabl1489[i] < variabl2517[i].length())
     variabl1489[i] = variabl2517[i].length();
    if (variabl1489[i] > 50)
     variabl1489[i] = 50;
    b++;
   }

   int rowNumber = 0;
   rs.last();
   rowNumber = rs.getRow();
   variabl2197 = new String[rowNumber][variabl2651];
   rs.absolute(1);
   c = 0;
   b = 0;
   while (c < rowNumber) {
    rs.absolute(c + 1);
    while (b < variabl2651) {
     variabl2197[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close();
   sta3.close();
   con.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "连接数据库出错！");
  }
  if (variabl2049.trim().length() > 0)
   variabl2049 = variabl2049 + " and ";

  frame.setTitle("查询部件程序                                作者：程学先");
  frame.setBounds(10, 10, variabl2483 - 10, variabl2503 + 20);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.getContentPane().setLayout(null);
  final JPanel panel = new JPanel(false);
  panel.setLayout(null);
  panel.setBounds(20, 20, variabl2483 - 50, variabl2503 + 20);

  tableModel = new DefaultTableModel(variabl2197, variabl2517);
  table = new JTable(tableModel);
  table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  scrollPane.getViewport().add(table, null);
  scrollPane.setBounds(30, 70, variabl2483 - 100, variabl2503 - 150);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

  for (int i = 0; i < variabl2651; i++) {
   TableColumn tc = table.getColumn(variabl2517[i]);
   tc.setPreferredWidth(variabl1489[i] * 12);
  }
  panel.add(scrollPane);

  JLabel label1 = new JLabel(variabl2669[0]);
  label1.setBounds(variabl2337, 10, variabl2669[0].length() * 15, 20);
  panel.add(label1);
  variabl2337 = variabl2337 + variabl2669[0].length() * 15;

  aTextField = new JTextField("", 10);
  aTextField.setBounds(variabl2337, 10, 150, 20);
  panel.add(aTextField);
  variabl2337 = variabl2337 + 150;

  if (variabl2669.length > 1) {
   JLabel label3 = new JLabel(variabl2669[1]);
   label3.setBounds(variabl2337, 10, variabl2669[1].length() * 15, 20);
   panel.add(label3);
   variabl2337 = variabl2337 + variabl2669[1].length() * 15;

   aTextField2 = new JTextField("", 10);
   aTextField2.setBounds(variabl2337, 10, 150, 20);
   panel.add(aTextField2);
  }

  variabl2339 = (variabl2483 - 360) / variabl2851;
  int variabl2337 = 350;
  final JButton selectButton = new JButton(variabl2405[0]);
  selectButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    try {
     con = main1.getConn();
     sta3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     if (variabl2101.trim().length() > 0)
      s1 = "select " + variabl2101 + " from " + variabl2603;
     else
      s1 = "select " + variabl1325 + " from " + variabl2603;
     if (variabl2049.trim().length() > 0)
      s1 = s1 + " where " + variabl2049
        + variabl2517[variabl2345];
     else
      s1 = s1 + " where " + variabl2517[variabl2345];

     if (((main1.variabl1539.lastIndexOf(","
       + variabl1501[variabl2345] + ",")) >= 0)
       || ((main1.variabl1539.lastIndexOf(","
         + variabl1501[variabl23451] + ",")) >= 0)) {
      JOptionPane.showMessageDialog(null,
        "不允许使用图形与二进制数据类型作为查询条件!", "提示",
        JOptionPane.INFORMATION_MESSAGE);
      return;
     }
     if (variabl22590.lastIndexOf("包含") < 0) {
      if (main1.variabl1545.lastIndexOf(","
        + variabl1501[variabl2345] + ",") >= 0)
       s1 = s1 + variabl22590
         + aTextField.getText().trim();
      else
       s1 = s1 + variabl22590 + "'"
         + aTextField.getText().trim() + "'";
     } else {
      if (main1.variabl1545.lastIndexOf(","
        + variabl1501[variabl2345] + ",") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字类数据类型不能做包含查询！");
       return;
      } else if (variabl22590.lastIndexOf("不包含") >= 0)
       s1 = s1 + " not like '%"
         + aTextField.getText().trim() + "%'";
      else
       s1 = s1 + " like '%" + aTextField.getText().trim()
         + "%'";
     }
     if (variabl2669.length > 1) {
      if (variabl225901.lastIndexOf("包含") < 0)
       if (main1.variabl1545.lastIndexOf(","
         + variabl1501[variabl23451] + ",") >= 0)
        s1 = s1 + " and " + variabl23851
          + variabl225901
          + aTextField2.getText().trim();
       else
        s1 = s1 + " and " + variabl23851
          + variabl225901 + "'"
          + aTextField2.getText().trim() + "'";
      else if (main1.variabl1545.lastIndexOf(","
        + variabl1501[variabl23451] + ",") >= 0) {
       JOptionPane.showMessageDialog(null,
         "数字类数据类型不能做包含查询！");
       return;
      } else if (variabl225901.lastIndexOf("不包含") >= 0)
       s1 = s1 + " and " + variabl23851 + " not like '%"
         + aTextField2.getText().trim() + "%'";
      else
       s1 = s1 + " and " + variabl23851 + " like '%"
         + aTextField2.getText().trim() + "%'";
     }
     ResultSet rs = sta3.executeQuery(s1);
     int rowNumber = 0;
     rs.last();
     rowNumber = rs.getRow();
     rsmd3 = rs.getMetaData();
     variabl2651 = rsmd3.getColumnCount();
     variabl1489 = new int[variabl2651];
     variabl2517 = new String[variabl2651];
     for (int i = 0; i < variabl2651; i++) {
      variabl2517[i] = rsmd3.getColumnName(i + 1);
      variabl1489[i] = rsmd3.getColumnDisplaySize(i + 1);
      if (variabl1489[i] < variabl2517[i].length())
       variabl1489[i] = variabl2517[i].length();
      if (variabl1489[i] > 50)
       variabl1489[i] = 50;
     }

     variabl2197 = new String[rowNumber][variabl2651];
     c = 0;
     b = 0;
     while (c < rowNumber) {
      rs.absolute(c + 1);
      while (b < variabl2651) {
       variabl2197[c][b] = rs.getString(b + 1);
       b++;
      }
      c++;
      b = 0;
     }
     rs.close();
     sta3.close();
     con.close();
     tableModel = new DefaultTableModel(variabl2197, variabl2517);
     table = new JTable(tableModel);
     table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
     scrollPane.setViewportView(table);
     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
     for (int i = 0; i < variabl2651; i++) {
      TableColumn tc = table.getColumn(variabl2517[i]);
      tc.setPreferredWidth(variabl1489[i] * 12);
     }
     printViewButton.setEnabled(true);
     printButton.setEnabled(true);
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "查询数据出错！" + s1);
    }
   }
  });
  selectButton.setBounds(variabl2337, 40, variabl2339, 20);
  if (variabl1187.indexOf(",0,") >= 0) {
   variabl2337 = variabl2337 + variabl2339;
   panel.add(selectButton);
  }

  printViewButton = new JButton(variabl2405[1]);
  printViewButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    dataPreview1.printView1(variabl2197, variabl1079);
   }
  });
  printViewButton.setBounds(variabl2337, 40, variabl2339, 20);
  if (variabl1187.indexOf(",1,") >= 0) {
   variabl2337 = variabl2337 + variabl2339;
   panel.add(printViewButton);
   printViewButton.setEnabled(false);
  }

  printButton = new JButton(variabl2405[2]);
  printButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    dataPrint1.print1(variabl2197, variabl1079);
   }
  });
  printButton.setBounds(variabl2337, 40, variabl2339, 20);
  if (variabl1187.indexOf(",2,") >= 0) {
   variabl2337 = variabl2337 + variabl2339;
   panel.add(printButton);
   printButton.setEnabled(false);
  }

  final JButton exitButton = new JButton(variabl2405[3]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    panel.setVisible(false);
    frame.setVisible(false);
    frame.dispose();
   }
  });
  exitButton.setBounds(variabl2337, 40, variabl2339, 20);
  if (variabl1187.indexOf(",3,") >= 0) {
   variabl2337 = variabl2337 + variabl2339;
   panel.add(exitButton);
  }
  frame.getContentPane().add(panel, null);
  frame.setVisible(true);
  frame.getContentPane().add(panel, BorderLayout.SOUTH);
 }
}