博文

管理信息系统软件生产线源码46-50

已有 1770 次阅读 2018-6-9 23:33 |个人分类:生活点滴|系统分类:科研笔记| 软件生产线, 软部件, 数据库, 管理信息系统, JAVA

版本1
46.源码46，部件程序，修改式导出到office文件，包括word、excel、pdf文件数据导出部件。
/**
* 程序文件名：dataTransfer6.java
* 作者：程学先
* 功能：修改式导出到office文件，包括word、excel、pdf文件。
* 原目的文件内容保留，当前表数据导出到指定文件中，如果关键字值和已有数据相同则更改已有数据
* 否则添加到原文件尾部，如果原文件不存在将抛出异常。
* 目的表与源表数据类型、数据宽度应当对应相容，符合本程序中“类型对照表"设置的对应关系。
* 完成日期：2013年1月22日
* 被调用语句：dataTransfer6.means(parameter)
* 必须提供的参数：数据“表名”、“导出文件名”。
* 可选择参数：“字段号表”、“要求按钮号表”、
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共4个，序号及按钮名：1修改式导出到word文件、2修改式导出到excel文件、
* 3修改式导出到PDF文件、4退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导出到Office文件要求下载以下文件并设置构建路径：
* iText-5.0.5.jar、jacob.jar、poi-3.8-20120326.jar、PDFBox-0.7.3.jar
* 如果导出到PDF文件。不支持大数据类型，每字段宽度不超过50字符。
* 导入部件只能对由dataTransfer4.java生成的PDF文件进行修改式导入。
* 如果导出到WORD文件，文件名必须带路径全称，否则会存放到我的文档中。
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Font;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfWriter;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hwpf.extractor.WordExtractor;
import org.apache.poi.ss.usermodel.Sheet;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;
import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;

public class dataTransfer6 extends JFrame {
static dataTransfer6 frame = new dataTransfer6(); // 创建窗体
private static JTable table;    //创建表格
static Connection con1;
static String url;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta4;
static ResultSet rs;
static int 窗口宽=800,窗口高=600;//窗口宽、窗口高
    static int 列数; //数据表列数
    static int 列数1;
    static String [][] 列名; //数据表列名
    static String [] 列名1;
    static int[] 对应目的表序号;   //存放当前记录各字段数据宽度的数组
    static String [] 表格列名;
    static String[] 列数据类型; //存放当前记录各字段数据类型的数组
    static String[] 表列数据类型;
    static int[] 列数据宽度,列小数位数;   //存放当前记录各字段数据宽度的数组
  static int 记录条数=0,记录条数1=0;   //记录条数
static String[][] 表格数据;//存放表格数据的数组
static String[] 表格数据1;
static DefaultTableModel model;
static String 表名;      //数据表名
static String 字典表名;
static String 导出表名,导出文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String 字段号表;
static String 关键字;
static String[] 关键字名,关键字名1;
static int[] 关键字序号,关键字序号1;
  private static Connection cont4; // 连接数据库
private static Statement stat4;
private static ResultSetMetaData rsmdt4;
private static String[] 列名0; // 数据表列名
    private static String 列名表="";   //包括全部列名的字符串
    private static int 列数0;
    private static String 连接条件;
static String s1="",s2="",s3="";
static String s4="                                                  ";
static char x1=10,x2=13,x3='"',x4=',';
private static String[][] 类型对照表={
  {"java"      ,"string","string","string"   ,"int"    ,"int"      ,"string","string" ,"string","string","boolean","byte"   ,"short"   ,"long"   ,"float"    ,"int"    ,"double","float" ,"float" ,"byte[]"},
  {"sqlserver","char" ,"nchar" ,"nvarchar" ,"int"    ,"float"    ,"datetime" ,"datetime","text","ntext" ,"bit"    ,"tinyint","smallint","bigint" ,"numeric" ,"integer","double","money" ,"real" ,"image"},
  {"vfp"       ,"c"     ,"c"     ,"c"        ,"i"      ,"n"        ,"d"     ,"t"       ,"m"     ,"m"     ,"l"      ,"i"      ,"i"       ,"i"      ,"n"        ,"i"      ,"n"      ,"b"     ,"y"     ,"g"    },
  {"access"    ,"text" ,"text" ,"text"     ,"integer","integer" ,"date" ,"date"    ,"memo" ,"memo" ,"logical","integer","integer" ,"integer","float"    ,"integer","float" ,"float" ,"float" ,"general"},
  {"oracle"    ,"char" ,"char" ,"char"     ,"number" ,"number"   ,"date" ,"date"    ,"long" ,"long" ,"char"   ,"raw"    ,"number" ,"number" ,"number"   ,"number" ,"number" ,"number","number","blob"},
  {"mysql"     ,"char" ,"char" ,"varchar" ,"int"    ,"float"    ,"date" ,"datetime","text" ,"text" ,"tinyint","tinyint","smallint","bigint" ,"float"    ,"integer","double" ,"float" ,"float" ,"blob"}
};
static int 按钮数=0,按钮宽=0;

public static void means(String [] parameter) {
frame = new dataTransfer6(); // 创建窗体
窗口宽=800;窗口高=600;//窗口宽、窗口高
记录条数=0;记录条数1=0;   //记录条数
s1="";s2="";s3="";
x1=10;x2=13;x3='"';x4=',';
    类型对照表[0][0]="java";类型对照表[0][1]="string";
    类型对照表[0][2]="string";类型对照表[0][3]="string";
    类型对照表[0][4]="int";类型对照表[0][5]="int";
    类型对照表[0][6]="string";类型对照表[0][7]="string";
    类型对照表[0][8]="string";类型对照表[0][9]="string";
    类型对照表[0][10]="boolean";类型对照表[0][11]="byte";
    类型对照表[0][12]="short";类型对照表[0][13]="long";
    类型对照表[0][14]="float";类型对照表[0][15]="int";
    类型对照表[0][16]="double";类型对照表[0][17]="float";
    类型对照表[0][18]="float";类型对照表[0][19]="byte[]";
    类型对照表[1][0]="sqlserver";类型对照表[1][1]="char";
     类型对照表[1][2]="nchar";类型对照表[1][3]="nvarchar";
     类型对照表[1][4]="int";类型对照表[1][5]="float";
     类型对照表[1][6]="datetime";类型对照表[1][7]="datetime";
     类型对照表[1][8]="text";类型对照表[1][9]="ntext";
     类型对照表[1][10]="bit";类型对照表[1][11]="tinyint";
     类型对照表[1][12]="smallint";类型对照表[1][13]="bigint";
     类型对照表[1][14]="numeric";类型对照表[1][15]="integer";
     类型对照表[1][16]="double";类型对照表[1][17]="money";
     类型对照表[1][18]="real";类型对照表[1][19]="image";
     类型对照表[2][0]="vfp";类型对照表[2][1]="c";
     类型对照表[2][2]="c";类型对照表[2][3]="c";
     类型对照表[2][4]="i";类型对照表[2][5]="n";
     类型对照表[2][6]="d";类型对照表[2][7]="t";
     类型对照表[2][8]="m";类型对照表[2][9]="m";
     类型对照表[2][10]="l";类型对照表[2][11]="i";
     类型对照表[2][12]="i";类型对照表[2][13]="i";
     类型对照表[2][14]="n";类型对照表[2][15]="i";
     类型对照表[2][16]="n";类型对照表[2][17]="b";
     类型对照表[2][18]="y";类型对照表[2][19]="g";
     类型对照表[3][0]="access";类型对照表[3][1]="text";
     类型对照表[3][2]="text";类型对照表[3][3]="text";
     类型对照表[3][4]="integer";类型对照表[3][5]="integer";
     类型对照表[3][6]="date";类型对照表[3][7]="date";
     类型对照表[3][8]="memo";类型对照表[3][9]="memo";
     类型对照表[3][10]="logical";类型对照表[3][11]="integer";
     类型对照表[3][12]="integer";类型对照表[3][13]="integer";
     类型对照表[3][14]="float";类型对照表[3][15]="integer";
     类型对照表[3][16]="float";类型对照表[3][17]="float";
     类型对照表[3][18]="float";类型对照表[3][19]="general";
     类型对照表[4][0]="oracle";类型对照表[4][1]="char";
     类型对照表[4][2]="char";类型对照表[4][3]="char";
     类型对照表[4][4]="number";类型对照表[4][5]="number";
     类型对照表[4][6]="date";类型对照表[4][7]="date";
     类型对照表[4][8]="long";类型对照表[4][9]="long";
     类型对照表[4][10]="char";类型对照表[4][11]="raw";
     类型对照表[4][12]="number";类型对照表[4][13]="number";
     类型对照表[4][14]="number";类型对照表[4][15]="number";
     类型对照表[4][16]="number";类型对照表[4][17]="number";
     类型对照表[4][18]="number";类型对照表[4][19]="blob";
     类型对照表[5][0]="mysql";类型对照表[5][1]="char";
     类型对照表[5][2]="char";类型对照表[5][3]="varchar";
     类型对照表[5][4]="int";类型对照表[5][5]="float";
     类型对照表[5][6]="date";类型对照表[5][7]="datetime";
     类型对照表[5][8]="text";类型对照表[5][9]="text";
     类型对照表[5][10]="tinyint";类型对照表[5][11]="tinyint";
     类型对照表[5][12]="smallint";类型对照表[5][13]="bigint";
     类型对照表[5][14]="float";类型对照表[5][15]="integer";
     类型对照表[5][16]="double";类型对照表[5][17]="float";
     类型对照表[5][18]="float";类型对照表[5][19]="blob";
连接条件="";
    File file = new File(".\\com\\iText-5.0.5.jar");
    if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中！"); return;}
    file = new File(".\\com\\jacob.jar");
    if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中！"); return;}
    file = new File(".\\com\\poi-3.8-20120326.jar");
    if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中！"); return;}
    file = new File(".\\com\\PDFBox-0.7.3.jar");
    if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中！"); return;}
  表名=parameter[4] ; // 数据表名
  字段号表=parameter[8];
  导出文件名=parameter[18];
  导出表名=parameter[2];
  String [] 按钮集01={"导出到word","导出到excel","导出到PDF","退出"};
        按钮集=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[6];
  String 字段名表=parameter[19].trim();
  if ((字段名表.length()>0)&&(字段名表.substring(字段名表.length()-1).equals(",")))
   字段名表=字段名表.substring(0,字段名表.length()-1);
  String 表名表=parameter[0];
  String [] l3=字段名表.split(",");
        字典表名="";
        String []t1;
        int b=0,c=0;
        if (表名表.lastIndexOf(表名+"字典表")>=0){
        t1=表名表.split(",");
        for (int i=0;i<t1.length;i++)
          if (t1[i].lastIndexOf(表名+"字典表")>=0) 字典表名=t1[i];
         }
        String[] l1;
  if (字段号表.length()>0){
      l1=字段号表.split(",");
      int [] l2=new int[l1.length];
      for (int i=0;i<l1.length;i++){
        l2[i]=Integer.valueOf(l1[i]);
      }
      列数=l1.length;
            列名=new String[2][列数];
            for (int i=0;i<列数;i++){
          列名[0][i]=l3[l2[i]];
          列名[1][i]=列名[0][i];
      }
   }
  else {
   列数=l3.length;
   列名=new String[2][列数];
            for (int i=0;i<列数;i++){
          列名[0][i]=l3[i];
          列名[1][i]=列名[0][i];
            }
  }
  s1="";
   for (int i=0;i<列数;i++)
        s1=s1+列名[0][i]+",";
   s1=s1.substring(0,s1.length()-1);
      try
        {
       con1=main1.getConn();// 连接数据库
      sta4 = con1.createStatement(
                ResultSet.TYPE_SCROLL_INSENSITIVE,
                  ResultSet.CONCUR_UPDATABLE);

       s1="select "+s1+" from "+表名;
       数据表查询结构002();
          if (连接条件.length()>0) s1=s1+" where "+连接条件;
          ResultSet rs=sta4.executeQuery(s1);
          rsmd4 = rs.getMetaData();
   列数 = rsmd4.getColumnCount(); // 获取列数
   列名 = new String[2][列数];
   列数据类型 = new String[列数]; // 定义列字段类型数组
   列数据宽度 = new int[列数];
   for (int i=0;i<列数;i++) {
  列名[0][i] = rsmd4.getColumnName(i + 1); // 获取列名存到数组中
  列名[1][i]=列名[0][i];
  列数据类型[i] = rsmd4.getColumnTypeName(i + 1);
     列数据宽度[i] = rsmd4.getColumnDisplaySize(i + 1);
     if (列数据宽度[i]<列名[0][i].length()) 列数据宽度[i]=列名[0][i].length();
     if (列数据宽度[i]<列名[1][i].length()) 列数据宽度[i]=列名[1][i].length();
     if (列数据宽度[i]>50) 列数据宽度[i]=50;
         }
   关键字名=关键字.split(",");
   关键字名1=new String[关键字名.length];
   关键字序号=new int[关键字名.length];
   关键字序号1=new int[关键字名.length];
       表格列名=new String[列数];
        表列数据类型=new String[列数];
          for (b=0;b<列数;b++){
        表格列名[b]=列名[1][b];
            }
      记录条数=0;   //记录条数
      rs.last();
      记录条数=rs.getRow();
       表格数据=new String[记录条数][列数];
      rs.absolute(1);
      c=0;    //行号
      b=0;        //列号
     while(c<记录条数) {
          rs.absolute(c+1);
           while(b<列数){
           表格数据[c][b]=rs.getString(b+1);
                   b++;
          }
          c++;
          b=0;
    }
      rs.close();     //关闭查询结果集
      sta4.close();     //关闭连接
      con1.close();
      }
     catch(SQLException e)
     {
    JOptionPane.showMessageDialog( null, "读取数据出错！");
     }
        if (字典表名.length()>0){
            try
            {
         con1=main1.getConn();// 连接数据库
       sta4 = con1.createStatement(
             ResultSet.TYPE_SCROLL_INSENSITIVE,
                   ResultSet.CONCUR_UPDATABLE);
         s1 = "select * from " + 字典表名; // 查取全表数据
         rs = sta4.executeQuery(s1);
                   String s4="";
                   String s5="";
                   b=1;
                   while (rs.absolute(b)) {
                    b++;
                        s4=rs.getString(1).trim();    //字段名
                       s5=rs.getString(2).trim();
                       for (int j=0;j<列数;j++){
                         if (列名[0][j].trim().equalsIgnoreCase(s4.trim())){
                         列名[1][j]=s5;
                         break;
                        }
                       }
                    }
                 rs.close();     //关闭查询结果集
                 con1.close();
                 sta4.close();
  } catch (SQLException e)
  {
   JOptionPane.showMessageDialog( null, "连接数据库出错！");
  }
   }
   for (int i=0;i<列数;i++) {
     for (int j=0;j<关键字名.length;j++)
      if (关键字名[j].trim().equalsIgnoreCase(列名[0][i].trim())){
       关键字名1[j]=列名[1][i];
       关键字序号[j]=i;
      }
    }
     frame.setTitle("数据修改式导出到office文件部件。根据关键字查出关键字相同记录用当前表中数据替代。作者：程学先");
    frame.setBounds(10, 10, 窗口宽, 窗口高);
    frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.setLayout(null);
        final JPanel panel = new JPanel(false);      //定义面板
        panel.setLayout(null);        //关闭面板布局管理器
        panel.setBounds(10, 10,窗口宽,窗口高);
    final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
     scrollPane.setBounds(0,0,窗口宽-20,窗口高-100); //定义滚动面板大小位置
     panel.add(scrollPane);
    model = new DefaultTableModel(表格数据,列名[1]);   // 创建表格模型
         table = new JTable(model);
        table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
         table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
        for(int i=0;i<列数;i++) {
            TableColumn tc = table.getColumn(列名[1][i]);
            tc.setPreferredWidth(列数据宽度[i]*14);
            tc.setMaxWidth(列数据宽度[i]*14);
            tc.sizeWidthToFit();
        }
        scrollPane.setViewportView(table);
  按钮宽=(窗口宽-60)/按钮数;
  int 按钮左边距=30;

  JButton 到word = new JButton(按钮集[0]);
         到word.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
         if (导出文件名.length()==0){
         导出文件名=JOptionPane.showInputDialog("请输入导出文件完整路径例如：F:\\java.doc","");
         return;
       }
         int p1=0,p2=0;
        if (导出文件名.lastIndexOf(".doc")<0){
         p1=导出文件名.lastIndexOf(".");
         p2=导出文件名.lastIndexOf("\\\\");
         if (p2>p1){
        导出文件名=导出文件名+".doc";
        导出文件名=导出文件名.replace("\\.","\\.\\.");
        }
         else {
         导出文件名=导出文件名.substring(0,p1)+".doc";
         }
        }
     try {
     FileInputStream in=new FileInputStream(new File(导出文件名));
     WordExtractor extractor=null;
     extractor=new WordExtractor(in);
     String 内容=extractor.getText();
     int m1=0;;
     String[] 记录=new String[列数];
     int k=0;
int k2=0,k5=0;
              记录[k]="";
     for (int i=0;i<内容.length();i++){
if (内容.charAt(i)=='\r'){    //找到一个回车
     s3="";
     for (int k3=0;k3<关键字名.length;k3++)
      s3=s3+记录[关键字序号[k3]].trim();
         k2=0;
     for (int j1=0;j1<model.getRowCount();j1++){ //表中所有记录
      s2="";
      for (int k4=0;k4<关键字名.length;k4++){
       s2=s2+model.getValueAt(j1,关键字序号[k4]).toString().trim();
      }
      if (s3.trim().equalsIgnoreCase(s2.trim())) { //找到关键字相同记录
       k2=j1;
       k5=1;
       break;
      }
     }
         if (k5==0){
             model.addRow(记录);
             记录条数++;
         }
         k5=0;
                              记录[0]="";
     k=0;
     m1=1;
     if ((i<内容.length()-2)&&(内容.charAt(i+2)=='\r')) break;
}
else if (内容.charAt(i)=='\n'){}
else if ((byte)(内容.charAt(i))==9){
  k++;
  m1=0;
  if (k<列数) 记录[k]="";
}
else if (k<列数){
  记录[k]=记录[k]+内容.charAt(i);   //记录[k]+
}
     }
     } catch (Exception e1) {
            JOptionPane.showMessageDialog(null, "读取数据出错，可能是原文件中数据结构与数据表不同，不能作修改式导出！");
       }
     try{
     ActiveXComponent word = new ActiveXComponent("Word.Application");
     Dispatch documents = word.getProperty("Documents").toDispatch();
     try {    //用覆盖方式或添加方式加入表格
Dispatch doc = Dispatch.call(documents, "Add").toDispatch();
Dispatch selection = Dispatch.get(word,"Selection").toDispatch();
       Dispatch.call(selection, "HomeKey");
       Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
      Dispatch range = Dispatch.get(selection, "Range").toDispatch();
      Dispatch newTable = Dispatch.call(tables, "Add", range,
        new Variant(记录条数), new Variant(列数)).toDispatch();
for(int i1=0;i1<model.getRowCount();i1++){
       for(int j=0;j<列数;j++){
       Dispatch table = Dispatch.call(tables, "Item", new Variant(1))
                        .toDispatch();
       Dispatch cell = Dispatch.call(table, "Cell", new Variant(i1+1),
                        new Variant(j+1)).toDispatch();
       Dispatch.call(cell, "Select");
           s1=""+model.getValueAt(i1,j);
       Dispatch.put(selection, "Text",s1);
            }
        }
      Dispatch.call((Dispatch) Dispatch.call(word, "WordBasic").getDispatch(),
       "FileSaveAs",导出文件名);
     } catch (Exception e1) {e1.printStackTrace();
     } finally {Dispatch.call(word, "Quit");
     }
     } catch (Exception e1) {
       e1.printStackTrace();
     }
     return;
     }
     });
     if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",0,")>=0)){
          到word.setBounds(按钮左边距,窗口高-80,按钮宽,20);
          panel.add(到word);
          按钮左边距=按钮左边距+按钮宽;
     }

     JButton 到excel = new JButton(按钮集[1]);
             到excel.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
         if (导出文件名.length()==0){
         导出文件名=JOptionPane.showInputDialog("请输入导出文件完整路径例如：F:\\java.xls","");
         return;
       }
      int p1=0,p2=0;
   if (导出文件名.lastIndexOf(".xls")<0){
    p1=导出文件名.lastIndexOf(".");
    p2=导出文件名.lastIndexOf("\\\\");
    if (p2>p1){
     导出文件名=导出文件名+".xls";
     导出文件名=导出文件名.replace("\\.","\\.\\.");
     }
    else {
    导出文件名=导出文件名.substring(0,p1)+".xls";
    }
   }
          InputStream is = null;
          HSSFWorkbook wbWorkbook = null;
     try {
is = new FileInputStream(导出文件名);
wbWorkbook = new HSSFWorkbook(is);
     } catch (FileNotFoundException e1) {
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "读取文件失败，请检查路径是否正确！", "错误",
          JOptionPane.INFORMATION_MESSAGE);
     } catch (IOException e2) {
e2.printStackTrace();
     }
     HSSFSheet sheet = wbWorkbook.getSheetAt(0);
     int lastRowNum = sheet.getLastRowNum();
     int 导入表格行数 = sheet.getPhysicalNumberOfRows();
     HSSFRow row = sheet.getRow(1);
     int 导入表格列数=row.getPhysicalNumberOfCells();
     if (导入表格列数!=列数)
      JOptionPane.showMessageDialog(null, "原文件中数据结构与数据表不同，不能作修改式导出！");
     String[] val;
     int k2=0,k5=0;
     String value = "";
     for (int i = 0; i < 导入表格行数; i++) {
         row = sheet.getRow(i);
         if (row != null) {
              for (int j = 0; j < 导入表格列数; j++) {
                   HSSFCell cell = row.getCell(j);
                   if (cell != null) {
                    switch (cell.getCellType()){
                     case HSSFCell.CELL_TYPE_FORMULA:
                     break;
                     case HSSFCell.CELL_TYPE_NUMERIC:
                        value += cell.getNumericCellValue() + ",";
                        break;
                     case HSSFCell.CELL_TYPE_STRING:
                        value += cell.getStringCellValue() + ",";
                        break;
                     default:
                        value += "0";
                        break;
                    }
               }
          }
         val = value.split(",");
      s3="";
     for (int k3=0;k3<关键字名.length;k3++)
      s3=s3+val[关键字序号[k3]].trim();
         k2=0;
     for (int j1=0;j1<model.getRowCount();j1++){
      s2="";
      for (int k4=0;k4<关键字名.length;k4++)
       s2=s2+model.getValueAt(j1,关键字序号[k4]).toString().trim();
      if (s3.trim().equalsIgnoreCase(s2.trim())) {
       k2=j1;
       k5=1;
       break;
      }
     }
         if (k5==0){
             model.addRow(val);
         记录条数++;
         }
         k5=0;
            value = "";
          }
     }
     HSSFWorkbook book = new HSSFWorkbook();
     sheet = book.createSheet(表名);
     HSSFRow header = sheet.createRow(0);
     int colCount = 列数;
     for (int i = 0; i < 列数; i++) {
        HSSFCell cell = header.createCell(i);
        cell.setCellValue(new HSSFRichTextString(表格列名[i]));
     }
     for (int j=0;j<model.getRowCount();j++){
        row = sheet.createRow(j);
        for (int i = 0; i < colCount; i++) {
            HSSFCell cell = row.createCell(i);
            s1=""+model.getValueAt(j,i);
            cell.setCellValue(new HSSFRichTextString(s1));
        }
     }
     try {
        FileOutputStream fileO = new FileOutputStream(导出文件名);
        book.write(fileO);
        fileO.close();
     } catch (Exception e1) {
        e1.printStackTrace();
     }
     }
     });
     if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",1,")>=0)){
          到excel.setBounds(按钮左边距,窗口高-80,按钮宽,20);
          panel.add(到excel);
          按钮左边距=按钮左边距+按钮宽;
     }

     JButton 到pdf = new JButton(按钮集[2]);
       到pdf.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
         if (导出文件名.length()==0){
        导出文件名=JOptionPane.showInputDialog("请输入导出文件完整路径例如：F:\\java.pdf","");
        return;
      }
       int p1=0,p2=0;
      if (导出文件名.lastIndexOf(".pdf")<0){
       p1=导出文件名.lastIndexOf(".");
       p2=导出文件名.lastIndexOf("\\\\");
       if (p2>p1){
    导出文件名=导出文件名+".pdf";
    导出文件名=导出文件名.replace("\\.","\\.\\.");
    }
       else {
       导出文件名=导出文件名.substring(0,p1)+".pdf";
       }
      }
     try {
     FileInputStream in = new FileInputStream(导出文件名);
     PDFParser parser = new PDFParser(in);
     parser.parse();
     PDDocument pdfdocument = parser.getPDDocument();
     PDFTextStripper stripper = new PDFTextStripper();
     s1 = stripper.getText(pdfdocument);
     in.close();
     } catch (Exception e1) {
          e1.printStackTrace();
     }
     String[] 记录=new String[列数];
     String s4="";
     int k=0,m1=0,k2=0,k5=0;
              记录[0]="";
     int l1=s1.length();
     for (int i1=0;i1<l1;i1++){
          s2=s1.substring(i1,i1+1);
          if (s1.charAt(i1)=='\r') {}
          else if (s1.charAt(i1)=='\n') {}
          else if ((s2.trim().equals("│"))&&(m1==1)) {
          if (k==列数-1) {
         s3="";
         for (int k3=0;k3<关键字名.length;k3++)
          s3=s3+记录[关键字序号[k3]].trim();
             k2=0;
         for (int j1=0;j1<model.getRowCount();j1++){
          s4="";
          for (int k4=0;k4<关键字名.length;k4++)
           s4=s4+model.getValueAt(j1,关键字序号[k4]).toString().trim();
          if (s3.trim().equalsIgnoreCase(s4.trim())) {
           k2=j1;
           k5=1;
           break;
          }
         }
             if (k5==0){
                   model.addRow(记录);
            记录条数++;
             }
             k5=0;
               k=0;
               m1=0;
                记录[k]="";
          }
          else {
          k++;
if (k<列数) 记录[k]="";
     }
     }
     else if (s2.trim().equals("│")) {
m1=1;
k=0;
记录[0]="";
     }
     else if ((k<列数)&&(m1==1)){
          try{
          记录[k]=记录[k]+s2;
      } catch (Exception e1) {
      }
     }
     }
         File file = new File(导出文件名);
         if (file.exists()) {
         file.delete();
         }
     Document document = new Document();
     try {
       PdfWriter.getInstance(document, new FileOutputStream(导出文件名));
     document.open();
      BaseFont bfComic = BaseFont.createFont("c:\\windows\\fonts\\SIMFANG.TTF", BaseFont.IDENTITY_H, BaseFont.NOT_EMBEDDED);
     Font font = new Font(bfComic, 9);
     s1="┌";
     for (int j=0;j<列数;j++){
     for (int k0=0;k0<列数据宽度[j];k0++)
s1=s1+"─";
     if (j!=列数-1) s1=s1+"┬";
     }
     s1=s1+"┐";
     document.add(new Paragraph(s1, font));
     int 记录条数2=model.getRowCount();
     s4="";
     String s5="";
     float lengtg1=0;
     for (int i=0;i<记录条数2;i++){
     s1="│";
     for (int j=0;j<表格数据[0].length;j++){
if (model.getValueAt(i,j)==null) s4=" ";
else s4=model.getValueAt(i,j).toString().trim();
        s3="";
        lengtg1=0;
        for (int j1=0;j1<s4.length();j1++){
        s5=s4.substring(j1,j1+1);
        s1=s1+s5;
       if (s5.compareTo("z")<0){
        if (s5.compareTo("0")<0)
         lengtg1=lengtg1+0.51f;
   else lengtg1=lengtg1+0.51f;
  }
  else lengtg1=lengtg1+1;
        }
while (lengtg1<列数据宽度[j]) {
  s1=s1+" ";
  lengtg1=lengtg1+0.51f;
}
        s1=s1+"│";
        lengtg1=0;
     }
     document.add(new Paragraph(s1, font));
     if (i<记录条数2-1){
s1="├";
        for (int j=0;j<列数;j++){
   for (int k0=0;k0<列数据宽度[j];k0++)
     s1=s1+"─";
   if (j!=列数-1) s1=s1+"┼";
        }
        s1=s1+"┤";
        document.add(new Paragraph(s1, font));
     }
     else {
s1="└";
        for (int j=0;j<列数;j++){
   for (int k0=0;k0<列数据宽度[j];k0++)
     s1=s1+"─";
   if (j!=列数-1) s1=s1+"┴";
        }
        s1=s1+"┘";
        document.add(new Paragraph(s1, font));
     }
     }
     }
     catch(DocumentException de) {
     System.err.println(de.getMessage());
     }
     catch(IOException ioe) {
     System.err.println(ioe.getMessage());
     }
          document.close();
     }
     });
     if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",2,")>=0)){
                          到pdf.setBounds(按钮左边距,窗口高-80,按钮宽,20);
          panel.add(到pdf);
           按钮左边距=按钮左边距+按钮宽;
     }

     JButton exitButton = new JButton(按钮集[3]);
     exitButton.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
frame.setVisible(false);
frame.dispose();
}
     });
     if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",3,")>=0)){
          exitButton.setBounds(按钮左边距,窗口高-80,按钮宽,20);
          panel.add(exitButton);
          按钮左边距=按钮左边距+按钮宽;
     }
     frame.add(panel);
     frame.setVisible(true); // 显示窗体
}
static void 数据表查询结构001(String 数据表名001) {
try
{
   cont4=main1.getConn();
   stat4 = cont4.createStatement(
     ResultSet.TYPE_SCROLL_INSENSITIVE,
     ResultSet.CONCUR_UPDATABLE);
  String s1= "select * from "+数据表名001;
  rs = stat4.executeQuery(s1);
   rsmdt4 = rs.getMetaData();
   列数0 = rsmdt4.getColumnCount();
   列名0 = new String[列数0];
   for (int i=0;i<列数0;i++) {
        列名0[i] = rsmdt4.getColumnName(i + 1);
   }
        rs.close();
         stat4.close();
         cont4.close();
  } catch(SQLException e1){
   JOptionPane.showMessageDialog( null, "读取数据表结构出错！");
  }
列名表="";
int b0=0;
while (b0 < 列名.length){
  if (b0==0) 列名表=列名0[b0];
  else 列名表=列名表+","+列名0[b0];
  b0++;
}
}

static void 数据表查询结构002() {
  String[] t11 = 表名.split(",");
  String 列名表0 = "";
  连接条件 = "";
  if (t11.length > 1) {
   for (int i = 0; i < t11.length; i++) {
    数据表查询结构001(t11[i]);
    for (int j = 0; j < 列名0.length; j++)
     if (("," + 列名表0 + ",").indexOf("," + 列名0[j] + ",") >= 0) {
      if (连接条件.length() == 0)
       连接条件 = t11[i - 1] + "." + 列名0[j] + "=" + t11[i]
         + "." + 列名0[j];
      else
       连接条件 = 连接条件 + " and " + t11[i - 1] + "." + 列名0[j]
         + "=" + t11[i] + "." + 列名0[j];
     }
    if (列名表0.length() == 0)
     列名表0 = 列名表;
    else
     列名表0 = 列名表0 + "," + 列名表;
   }
  }
}
    }

47.源码47，部件程序，从纯文本文件、XML文件或其他数据表覆盖式导入数据到当前表数据导入部件。
/**
* 程序文件名：dataTransfer6.java
* 作者：程学先
* 功能：修改式导出到office文件，包括word、excel、pdf文件。
* 原目的文件内容保留，当前表数据导出到指定文件中，如果关键字值和已有数据相同则更改已有数据
* 否则添加到原文件尾部，如果原文件不存在将抛出异常。
* 目的表与源表数据类型、数据宽度应当对应相容，符合本程序中“类型对照表"设置的对应关系。
* 完成日期：2013年1月22日
* 被调用语句：dataTransfer6.means(parameter)
* 必须提供的参数：数据“表名”、“导出文件名”。
* 可选择参数：“字段号表”、“要求按钮号表”、
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共4个，序号及按钮名：1修改式导出到word文件、2修改式导出到excel文件、
* 3修改式导出到PDF文件、4退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导出到Office文件要求下载以下文件并设置构建路径：
* iText-5.0.5.jar、jacob.jar、poi-3.8-20120326.jar、PDFBox-0.7.3.jar
* 如果导出到PDF文件。不支持大数据类型，每字段宽度不超过50字符。
* 导入部件只能对由dataTransfer4.java生成的PDF文件进行修改式导入。
* 如果导出到WORD文件，文件名必须带路径全称，否则会存放到我的文档中。
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Font;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfWriter;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hwpf.extractor.WordExtractor;
import org.apache.poi.ss.usermodel.Sheet;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;
import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;

48.源码48，部件程序，从纯文本文件、XML文件或其他数据表添加式导入数据到当前表数据导入部件。
/**
* 程序文件名：dataTransfer8.java
* 作者：程学先
* 功能：从纯文本文件、XML文件或其他数据表添加式导入数据到当前表。
* 原有标数据全部保留，导入数据添加到尾部。
* 特别注意，本程序未检查实体完整性，需要关注关键字重复记录问题。
* 如果从数据表导入，当前表作为目的表必须存在且必须与源表数据类型、数据宽度对应相容，
* 符合本程序中“类型对照表"设置的对应关系。
* 完成日期：2013年1月22日
* 被调用语句：dataTransfer8.means(parameter)
* 必须提供的参数：目的数据“表名”。
* 应当提供的参数：“导入文件名”、“源表名”。二选一。
* 可选参数：“字段号表”、“要求按钮号表”、源数据库“DBMS名称”、源数据库“ODBC数据源名称”。
* 要求字段号表：所操作数据可以是源表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共6个，序号及按钮名：1添加式导入到数据库表、2从纯文本文按标准格式添加式导入、
* 3从纯文本文以紧缩格式添加式导入、4从纯文本文一自定义格式添加式导入、5从XML文件以添加方式导入、6退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 以标准格式导入时将会首先读入数据，并根据当前数据库中各列宽度对之切割，不支持大数据类型，
* 每字段宽度不超过50字符。
* 因此要求目的文件中数据格式（特别是每个数据宽度与数据类型）应当与当前数据库表中数据一致，否则出错。
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class dataTransfer8 extends JFrame {
static dataTransfer8 frame = new dataTransfer8(); // 创建窗体
private static JTable table;    //创建表格
static Connection con;    //连接数据库
static Connection con1;
static String url;
static String ODBC数据源1;
static ResultSetMetaData rsmd3;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta3;
static Statement sta4;
static ResultSet rs;   //数据库数据集，存放查询的结果
static int 窗口宽=800,窗口高=600;//窗口宽、窗口高
    static int 列数; //数据表列数
    static int 列数1;
    static String [][] 列名; //数据表列名
    static String [] 列名1;
    static int[] 对应目的表序号;   //存放当前记录各字段数据宽度的数组
    static String [] 表格列名;
    static String[] 列数据类型; //存放当前记录各字段数据类型的数组
    static String[] 表列数据类型;
    static int[] 列数据宽度,列小数位数;   //存放当前记录各字段数据宽度的数组
    static int[] 表列数据宽度,表列小数位数;
  static int 记录条数=0,记录条数1=0;   //记录条数
static String[][] 表格数据;//存放表格数据的数组
static String[][] 表格数据1;
static DefaultTableModel model;
static String 表名;      //数据表名
static String 表名表;
static String 字典表名;
static String 导入表名,导入文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String DBMS名称1;
static String 字段号表;
static String s1="",s2="",s3="";
static String s6="                                                  ";
static char x1=10,x2=13,x3='"',x4=',';
private static String[][] 类型对照表={
  {"java"      ,"string","string","string"   ,"int"    ,"int"      ,"string","string" ,"string","string","boolean","byte"   ,"short"   ,"long"   ,"float"    ,"int"    ,"double","float" ,"float" ,"byte[]"},
  {"sqlserver","char" ,"nchar" ,"nvarchar" ,"int"    ,"float"    ,"datetime" ,"datetime","text","ntext" ,"bit"    ,"tinyint","smallint","bigint" ,"numeric" ,"integer","double","money" ,"real" ,"image"},
  {"vfp"       ,"c"     ,"c"     ,"c"        ,"i"      ,"n"        ,"d"     ,"t"       ,"m"     ,"m"     ,"l"      ,"i"      ,"i"       ,"i"      ,"n"        ,"i"      ,"n"      ,"b"     ,"y"     ,"g"    },
  {"access"    ,"text" ,"text" ,"text"     ,"integer","integer" ,"date" ,"date"    ,"memo" ,"memo" ,"logical","integer","integer" ,"integer","float"    ,"integer","float" ,"float" ,"float" ,"general"},
  {"oracle"    ,"char" ,"char" ,"char"     ,"number" ,"number"   ,"date" ,"date"    ,"long" ,"long" ,"char"   ,"raw"    ,"number" ,"number" ,"number"   ,"number" ,"number" ,"number","number","blob"},
  {"mysql"     ,"char" ,"char" ,"varchar" ,"int"    ,"float"    ,"date" ,"datetime","text" ,"text" ,"tinyint","tinyint","smallint","bigint" ,"float"    ,"integer","double" ,"float" ,"float" ,"blob"}
};
static String 类型1=main1.类型1;
static int 按钮数=0,按钮宽=0;

public static void means(String[] parameter) {
  frame = new dataTransfer8(); // 创建窗体
  窗口宽 = 800;
  窗口高 = 600;// 窗口宽、窗口高
  记录条数 = 0;
  记录条数1 = 0; // 记录条数
  s1 = "";
  s2 = "";
  s3 = "";
  s6 = "                                                  ";
  x1 = 10;
  x2 = 13;
  x3 = '"';
  x4 = ',';
  类型1 = main1.类型1;
  类型对照表[0][0] = "java";
  类型对照表[0][1] = "string";
  类型对照表[0][2] = "string";
  类型对照表[0][3] = "string";
  类型对照表[0][4] = "int";
  类型对照表[0][5] = "int";
  类型对照表[0][6] = "string";
  类型对照表[0][7] = "string";
  类型对照表[0][8] = "string";
  类型对照表[0][9] = "string";
  类型对照表[0][10] = "boolean";
  类型对照表[0][11] = "byte";
  类型对照表[0][12] = "short";
  类型对照表[0][13] = "long";
  类型对照表[0][14] = "float";
  类型对照表[0][15] = "int";
  类型对照表[0][16] = "double";
  类型对照表[0][17] = "float";
  类型对照表[0][18] = "float";
  类型对照表[0][19] = "byte[]";
  类型对照表[1][0] = "sqlserver";
  类型对照表[1][1] = "char";
  类型对照表[1][2] = "nchar";
  类型对照表[1][3] = "nvarchar";
  类型对照表[1][4] = "int";
  类型对照表[1][5] = "float";
  类型对照表[1][6] = "datetime";
  类型对照表[1][7] = "datetime";
  类型对照表[1][8] = "text";
  类型对照表[1][9] = "ntext";
  类型对照表[1][10] = "bit";
  类型对照表[1][11] = "tinyint";
  类型对照表[1][12] = "smallint";
  类型对照表[1][13] = "bigint";
  类型对照表[1][14] = "numeric";
  类型对照表[1][15] = "integer";
  类型对照表[1][16] = "double";
  类型对照表[1][17] = "money";
  类型对照表[1][18] = "real";
  类型对照表[1][19] = "image";
  类型对照表[2][0] = "vfp";
  类型对照表[2][1] = "c";
  类型对照表[2][2] = "c";
  类型对照表[2][3] = "c";
  类型对照表[2][4] = "i";
  类型对照表[2][5] = "n";
  类型对照表[2][6] = "d";
  类型对照表[2][7] = "t";
  类型对照表[2][8] = "m";
  类型对照表[2][9] = "m";
  类型对照表[2][10] = "l";
  类型对照表[2][11] = "i";
  类型对照表[2][12] = "i";
  类型对照表[2][13] = "i";
  类型对照表[2][14] = "n";
  类型对照表[2][15] = "i";
  类型对照表[2][16] = "n";
  类型对照表[2][17] = "b";
  类型对照表[2][18] = "y";
  类型对照表[2][19] = "g";
  类型对照表[3][0] = "access";
  类型对照表[3][1] = "text";
  类型对照表[3][2] = "text";
  类型对照表[3][3] = "text";
  类型对照表[3][4] = "integer";
  类型对照表[3][5] = "integer";
  类型对照表[3][6] = "date";
  类型对照表[3][7] = "date";
  类型对照表[3][8] = "memo";
  类型对照表[3][9] = "memo";
  类型对照表[3][10] = "logical";
  类型对照表[3][11] = "integer";
  类型对照表[3][12] = "integer";
  类型对照表[3][13] = "integer";
  类型对照表[3][14] = "float";
  类型对照表[3][15] = "integer";
  类型对照表[3][16] = "float";
  类型对照表[3][17] = "float";
  类型对照表[3][18] = "float";
  类型对照表[3][19] = "general";
  类型对照表[4][0] = "oracle";
  类型对照表[4][1] = "char";
  类型对照表[4][2] = "char";
  类型对照表[4][3] = "char";
  类型对照表[4][4] = "number";
  类型对照表[4][5] = "number";
  类型对照表[4][6] = "date";
  类型对照表[4][7] = "date";
  类型对照表[4][8] = "long";
  类型对照表[4][9] = "long";
  类型对照表[4][10] = "char";
  类型对照表[4][11] = "raw";
  类型对照表[4][12] = "number";
  类型对照表[4][13] = "number";
  类型对照表[4][14] = "number";
  类型对照表[4][15] = "number";
  类型对照表[4][16] = "number";
  类型对照表[4][17] = "number";
  类型对照表[4][18] = "number";
  类型对照表[4][19] = "blob";
  类型对照表[5][0] = "mysql";
  类型对照表[5][1] = "char";
  类型对照表[5][2] = "char";
  类型对照表[5][3] = "varchar";
  类型对照表[5][4] = "int";
  类型对照表[5][5] = "float";
  类型对照表[5][6] = "date";
  类型对照表[5][7] = "datetime";
  类型对照表[5][8] = "text";
  类型对照表[5][9] = "text";
  类型对照表[5][10] = "tinyint";
  类型对照表[5][11] = "tinyint";
  类型对照表[5][12] = "smallint";
  类型对照表[5][13] = "bigint";
  类型对照表[5][14] = "float";
  类型对照表[5][15] = "integer";
  类型对照表[5][16] = "double";
  类型对照表[5][17] = "float";
  类型对照表[5][18] = "float";
  类型对照表[5][19] = "blob";
  表名 = parameter[4];
  字段号表 = parameter[8];
  导入文件名 = parameter[18];
  导入表名 = parameter[2];
  String[] 按钮集01 = { "从数据表导入", "标准格式导入", "紧缩格式导入", "自定义格式导入", "从XML文件导入",
    "退出" };
  按钮集 = 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) {
  }
  DBMS名称1 = parameter[1];
  ODBC数据源1 = parameter[3];
  if ((DBMS名称1 == null) || (DBMS名称1.length() == 0))
   DBMS名称1 = main1.DBMS系统;
  if ((ODBC数据源1 == null) || (ODBC数据源1.length() == 0))
   ODBC数据源1 = main1.ODBC数据源;
  String 字段名表 = parameter[19].trim();
  if ((字段名表.length() > 0)
    && (字段名表.substring(字段名表.length() - 1).equals(",")))
   字段名表 = 字段名表.substring(0, 字段名表.length() - 1);
  表名表 = parameter[0];
  String[] l3 = 字段名表.split(",");
  字典表名 = "";
  String[] t1;
  int b = 0, c = 0;
  if (表名表.lastIndexOf(表名 + "字典表") >= 0) {
   t1 = 表名表.split(",");
   for (int i = 0; i < t1.length; i++)
    if (t1[i].lastIndexOf(表名 + "字典表") >= 0)
     字典表名 = t1[i];
  }
  String[] l1;
  if (字段号表.length() > 0) {
   l1 = 字段号表.split(",");
   int[] l2 = new int[l1.length];
   for (int i = 0; i < l1.length; i++) {
    l2[i] = Integer.valueOf(l1[i]);
   }
   列数 = l1.length;
   列名 = new String[2][列数];
   for (int i = 0; i < 列数; i++) {
    列名[0][i] = l3[l2[i]];
    列名[1][i] = 列名[0][i];
   }
  } else {
   列数 = l3.length;
   列名 = new String[2][列数];
   for (int i = 0; i < 列数; i++) {
    列名[0][i] = l3[i];
    列名[1][i] = 列名[0][i];
   }
  }
  s1 = "";
  for (int i = 0; i < 列数; i++) {
   s1 = s1 + 列名[0][i] + ",";
  }
  s1 = s1.substring(0, s1.length() - 1);
  try {
   if (("," + 表名表).lastIndexOf("," + 表名 + ",") >= 0) {
    main1.driver1();
    con1 = main1.getConn();// 连接数据库
    sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select " + s1 + " from " + 表名;
   } else {
    JOptionPane.showMessageDialog(null, "目的数据表不存在，不能导入！");
    return;
   }
   ResultSet rs = sta4.executeQuery(s1);
   rsmd4 = rs.getMetaData();
   列数 = rsmd4.getColumnCount(); // 获取列数
   列名 = new String[2][列数]; // 定义列名数组
   列数据类型 = new String[列数]; // 定义列字段类型数组
   列数据宽度 = new int[列数]; // 定义列数据宽度
   表格列名 = new String[列数];
   表列数据宽度 = new int[列数];
   表列数据类型 = new String[列数];
   for (int i = 0; i < 列数; i++) {
    列名[0][i] = rsmd4.getColumnName(i + 1); // 获取列名存到数组中
    列名[1][i] = 列名[0][i];
    列数据类型[i] = rsmd4.getColumnTypeName(i + 1);
    列数据宽度[i] = rsmd4.getColumnDisplaySize(i + 1);
    if (列数据宽度[i] < 列名[0][i].length())
     列数据宽度[i] = 列名[0][i].length();
    if (列数据宽度[i] < 列名[1][i].length())
     列数据宽度[i] = 列名[1][i].length();
    if (列数据宽度[i] > 50)
     列数据宽度[i] = 50;
   }
   if (((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",0,") >= 0))
     && (DBMS名称1.trim().length() > 0)) {
    int 类型序号 = 0, 类型序号1 = 0;
    for (int i = 0; i < 类型对照表.length; i++) {
     if (DBMS名称1.trim().equals(类型对照表[i][0]))
      类型序号1 = i;
     if (main1.DBMS系统.equals(类型对照表[i][0]))
      类型序号 = i;
    }
    for (b = 0; b < 列数; b++) {
     表格列名[b] = 列名[1][b];
     表列数据宽度[b] = 列数据宽度[b];
     for (int i = 1; i < 类型对照表[0].length; i++) {
      if (列数据类型[b].toLowerCase().trim()
        .equals(类型对照表[类型序号][i])) {
       表列数据类型[b] = 类型对照表[类型序号1][i];
       break;
      }
     }
    }
   }
   记录条数 = 0; // 记录条数
   rs.last();
   记录条数 = rs.getRow();
   表格数据 = new String[记录条数][列数];
   rs.absolute(1);
   c = 0; // 行号
   b = 0; // 列号
   while (c < 记录条数) {
    rs.absolute(c + 1);
    while (b < 列数) {
     表格数据[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close(); // 关闭查询结果集
   sta4.close(); // 关闭连接
   con1.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "读取数据出错！");
  }
  if (字典表名.length() > 0) {
   try {
    main1.driver1();
    con = main1.getConn();// 连接数据库
    sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select * from " + 字典表名;
    rs = sta3.executeQuery(s1);
    String s4 = "";
    String s5 = "";
    b = 1;
    while (rs.absolute(b)) {
     b++;
     s4 = rs.getString(1); // 字段名
     s5 = rs.getString(2);
     for (int j = 0; j < 列数; j++) {
      if (列名[0][j].trim().equals(s4.trim())) {
       列名[1][j] = s5;
       表格列名[j] = s5;
       break;
      }
     }
    }
    rs.close(); // 关闭查询结果集
    con.close();
    sta3.close();
   } catch (SQLException e) {
    JOptionPane.showMessageDialog(null, "连接数据库出错！");
   }
  }
  s2 = "";
  for (int i = 0; i < 列数; i++) {
   s2 = s2 + 列名[1][i] + ",";
  }
  s2 = s2.substring(0, s2.length() - 1);
  frame.setTitle("从文本文件、XML文件或数据库表导入数据库到本地部件。特别注意数据类型、宽度的对应。作者：程学先"); // 设置窗体标题
  frame.setBounds(10, 10, 窗口宽, 窗口高);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
  frame.setLayout(null);
  final JPanel panel = new JPanel(false); // 定义面板
  panel.setLayout(null); // 关闭面板布局管理器
  panel.setBounds(10, 10, 窗口宽, 窗口高);
  final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
  scrollPane.setBounds(0, 0, 窗口宽 - 20, 窗口高 - 100); // 定义滚动面板大小位置
  panel.add(scrollPane);
  // 创建表格列名数组
  model = new DefaultTableModel(表格数据, 列名[1]);
  table = new JTable(model);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
  for (int i = 0; i < 列数; i++) {
   TableColumn tc = table.getColumn(列名[1][i]);
   tc.setPreferredWidth(列数据宽度[i] * 14);
   tc.setMaxWidth(列数据宽度[i] * 14);
   tc.sizeWidthToFit();
  }
  scrollPane.setViewportView(table);
  按钮宽 = (窗口宽 - 60) / 按钮数;
  int 按钮左边距 = 30;
  for (int i = 0; i < 100; i++)
   s3 = s3 + " ";
  JButton 到数据库 = new JButton(按钮集[0]);
  到数据库.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat4;
    Statement stat3;
    try {
     if (("," + 表名表).lastIndexOf("," + 表名 + ",") >= 0) {
      main1.driver1();
      con1 = main1.getConn();
      stat4 = con1.createStatement(
        ResultSet.TYPE_SCROLL_INSENSITIVE,
        ResultSet.CONCUR_UPDATABLE);
      s1 = "select " + s2 + " from " + 导入表名;
      ResultSet rs1 = stat4.executeQuery(s1);
      rs1.last();
      记录条数1 = rs1.getRow();
      列名1 = s2.split(",");
      列数1 = 列名1.length;
      表格数据1 = new String[记录条数1][列数1];
      rs1.absolute(1);
      int c = 0; // 行号
      int b = 0; // 列号
      while (c < 记录条数1) {
       rs1.absolute(c + 1);
       while (b < 列数) {
        表格数据1[c][b] = rs1.getString(b + 1);
        b++;
       }
       c++;
       b = 0;
      }
      rs1.close(); // 关闭查询结果集
      stat4.close();
      con1.close();
     }
    } catch (SQLException e1) {
    }
    try {
     main1.driver1();
     con = main1.getConn();
     stat3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     for (int i = 0; i < 表格数据1.length; i++) {
      s1 = "insert into " + 表名 + " (";
      for (int k1 = 0; k1 < 列名[1].length; k1++)
       s1 = s1 + 列名[1][k1] + ",";
      s1 = s1.substring(0, s1.length() - 1) + " ) values (";
      for (int j = 0; j < 列名[1].length; j++) {
       if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
        if (表格数据1[i][j] == null)
         表格数据1[i][j] = "0";
        s1 = s1 + 表格数据1[i][j];
       } else {
        if (表格数据1[i][j] == null)
         表格数据1[i][j] = " ";
        s1 = s1 + "'" + 表格数据1[i][j] + "'";
       }
       if (j != 列名[1].length - 1)
        s1 = s1 + ",";
      }
      s1 = s1 + ")";
      stat3.executeUpdate(s1);
     }
     stat3.close(); // 关闭连接
     con.close();
    } catch (SQLException e1) {
     JOptionPane.showMessageDialog(null,
       "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
    }
   }
  });
  if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",0,") >= 0)) {
   到数据库.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
   panel.add(到数据库);
   按钮左边距 = 按钮左边距 + 按钮宽;
  }

  JButton 标准格式 = new JButton(按钮集[1]);
  标准格式.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     FileReader fs = new FileReader(导入文件名);
     BufferedReader br = new BufferedReader(fs);
     String tempStr = null;
     String[] 空记录1 = new String[列数];
     int k1 = 0, k2 = 0, k5 = 0;
     for (int i1 = 0; (tempStr = br.readLine()) != null; i1++) {
      for (int j = 0; j < 列数; j++) {
       空记录1[j] = tempStr.substring(k1, k1 + 列数据宽度[j]);
       k1 = k1 + 列数据宽度[j];
      }
      try {
       main1.driver1();
       con = main1.getConn();
       stat3 = con.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
       s1 = "insert into " + 表名 + " (";
       for (int k3 = 0; k3 < 列名[1].length; k3++)
        s1 = s1 + 列名[1][k3] + ",";
       s1 = s1.substring(0, s1.length() - 1)
         + " ) values (";
       for (int j = 0; j < 列名[1].length; j++) {
        if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
         if (空记录1[j] == null)
          空记录1[j] = "0";
         s1 = s1 + 空记录1[j].trim();
        } else {
         if (空记录1[j] == null)
          空记录1[j] = " ";
         s1 = s1 + "'" + 空记录1[j].trim() + "'";
        }
        if (j != 列名[1].length - 1)
         s1 = s1 + ",";
       }
       s1 = s1 + ")";
       stat3.executeUpdate(s1);
       stat3.close(); // 关闭连接
       con.close();
      } catch (SQLException e1) {
       JOptionPane.showMessageDialog(null,
         "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
      }
      k1 = 0;
     }
     fs.close();
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
    } catch (IOException e2) {
     e2.printStackTrace();
    }
   }
  });
  if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",1,") >= 0)) {
   标准格式.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
   panel.add(标准格式);
   按钮左边距 = 按钮左边距 + 按钮宽;
  }

  JButton exitButton = new JButton(按钮集[5]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    frame.setVisible(false);
    frame.dispose();
   }
  });
  if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",5,") >= 0)) {
   exitButton.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
   panel.add(exitButton);
   按钮左边距 = 按钮左边距 + 按钮宽;
  }
  main1.driver1();
  frame.add(panel);
  frame.setVisible(true); // 显示窗体
}
}

49.源码49，部件程序，从纯文本文件、XML文件或其他数据表修改式导入数据到当前表数据导入部件。
/**
* 程序文件名：dataTransfer9.java
* 作者：程学先
* 功能：从纯文本文件、XML文件或其他数据表修改式导入数据到当前表。
* 关键字子相同记录按导入表更新，关键字不在原表中的记录作为新记录添加在尾部。
* 如果目的表已经存在，必须与源表数据类型、数据宽度对应相容，符合本程序中“类型对照表"设置的对应关系。
* 从数据表导入，本地表经字典表变换后的字段名也必须和源表相同，数量和次序可以随意。
* 如果从文本文件或XML文件导入，当前表必须存在。
* 完成日期：2013年1月22日
* 被调用语句：dataTransfer9.means(parameter)
* 必须提供的参数：目的数据“表名”、“关键字”。
* 应当提供的参数：“导入文件名”、“源表名”。二选一。
* 可选参数：“字段号表”、“要求按钮号表”、源数据库“DBMS名称”、源数据库“ODBC数据源名称”。
* 要求字段号表：所操作数据可以是源表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共6个，序号及按钮名：1修改式导入到数据库表、2从纯文本文按标准格式修改式导入、
* 3从纯文本文以紧缩格式修改式导入、4从纯文本文一自定义格式修改式导入、5从XML文件以修改方式导入、6退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 以标准格式导入时将会首先读入数据，并根据当前数据库中各列宽度对之切割，不支持大数据类型，
* 每字段宽度不超过50字符。
* 因此要求目的文件中数据格式（特别是每个数据宽度与数据类型）应当与当前数据库表中数据一致，否则出错。
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;

import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class dataTransfer9 extends JFrame {
static dataTransfer9 frame = new dataTransfer9(); // 创建窗体
private static JTable table;    //创建表格
static Connection con;
static Connection con1;
static String url;
static String ODBC数据源1;
static ResultSetMetaData rsmd3;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta3;
static Statement sta4;
static ResultSet rs;
static int 窗口宽=800,窗口高=600;//窗口宽、窗口高
    static int 列数; //数据表列数
    static int 列数1;
    static String [][] 列名; //数据表列名
    static String [] 列名1;
    static int[] 对应目的表序号;   //存放当前记录各字段数据宽度的数组
    static String [] 表格列名;
    static String[] 列数据类型; //存放当前记录各字段数据类型的数组
    static String[] 表列数据类型;
    static int[] 列数据宽度,列小数位数;   //存放当前记录各字段数据宽度的数组
    static int[] 表列数据宽度,表列小数位数;
  static int 记录条数=0,记录条数1=0;   //记录条数
static String[][] 表格数据;//存放表格数据的数组
static String[][] 表格数据1;
static DefaultTableModel model;
static String 表名;      //数据表名
static String 表名表;
static String 字典表名;
static String 导入表名,导入文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String DBMS名称1;
static String 字段号表;
static String 关键字;
static String [] 关键字数据1;
static String[] 关键字名,关键字名1;
static int[] 关键字序号,关键字序号1;
static String s1="",s2="",s3="";
static String s6="                                                  ";
static char x1=10,x2=13,x3='"',x4=',';
private static String[][] 类型对照表={
  {"java"      ,"string","string","string"   ,"int"    ,"int"      ,"string","string" ,"string","string","boolean","byte"   ,"short"   ,"long"   ,"float"    ,"int"    ,"double","float" ,"float" ,"byte[]"},
  {"sqlserver","char" ,"nchar" ,"nvarchar" ,"int"    ,"float"    ,"datetime" ,"datetime","text","ntext" ,"bit"    ,"tinyint","smallint","bigint" ,"numeric" ,"integer","double","money" ,"real" ,"image"},
  {"vfp"       ,"c"     ,"c"     ,"c"        ,"i"      ,"n"        ,"d"     ,"t"       ,"m"     ,"m"     ,"l"      ,"i"      ,"i"       ,"i"      ,"n"        ,"i"      ,"n"      ,"b"     ,"y"     ,"g"    },
  {"access"    ,"text" ,"text" ,"text"     ,"integer","integer" ,"date" ,"date"    ,"memo" ,"memo" ,"logical","integer","integer" ,"integer","float"    ,"integer","float" ,"float" ,"float" ,"general"},
  {"oracle"    ,"char" ,"char" ,"char"     ,"number" ,"number"   ,"date" ,"date"    ,"long" ,"long" ,"char"   ,"raw"    ,"number" ,"number" ,"number"   ,"number" ,"number" ,"number","number","blob"},
  {"mysql"     ,"char" ,"char" ,"varchar" ,"int"    ,"float"    ,"date" ,"datetime","text" ,"text" ,"tinyint","tinyint","smallint","bigint" ,"float"    ,"integer","double" ,"float" ,"float" ,"blob"}
};
static String 类型1=main1.类型1;
static int 按钮数=0,按钮宽=0;

public static void means(String[] parameter) {
  frame = new dataTransfer9(); // 创建窗体
  窗口宽 = 800;
  窗口高 = 600;// 窗口宽、窗口高
  记录条数 = 0;
  记录条数1 = 0; // 记录条数
  s1 = "";
  s2 = "";
  s3 = "";
  s6 = "                                                  ";
  x1 = 10;
  x2 = 13;
  x3 = '"';
  x4 = ',';
  类型1 = main1.类型1;
  类型对照表[0][0] = "java";
  类型对照表[0][1] = "string";
  类型对照表[0][2] = "string";
  类型对照表[0][3] = "string";
  类型对照表[0][4] = "int";
  类型对照表[0][5] = "int";
  类型对照表[0][6] = "string";
  类型对照表[0][7] = "string";
  类型对照表[0][8] = "string";
  类型对照表[0][9] = "string";
  类型对照表[0][10] = "boolean";
  类型对照表[0][11] = "byte";
  类型对照表[0][12] = "short";
  类型对照表[0][13] = "long";
  类型对照表[0][14] = "float";
  类型对照表[0][15] = "int";
  类型对照表[0][16] = "double";
  类型对照表[0][17] = "float";
  类型对照表[0][18] = "float";
  类型对照表[0][19] = "byte[]";
  类型对照表[1][0] = "sqlserver";
  类型对照表[1][1] = "char";
  类型对照表[1][2] = "nchar";
  类型对照表[1][3] = "nvarchar";
  类型对照表[1][4] = "int";
  类型对照表[1][5] = "float";
  类型对照表[1][6] = "datetime";
  类型对照表[1][7] = "datetime";
  类型对照表[1][8] = "text";
  类型对照表[1][9] = "ntext";
  类型对照表[1][10] = "bit";
  类型对照表[1][11] = "tinyint";
  类型对照表[1][12] = "smallint";
  类型对照表[1][13] = "bigint";
  类型对照表[1][14] = "numeric";
  类型对照表[1][15] = "integer";
  类型对照表[1][16] = "double";
  类型对照表[1][17] = "money";
  类型对照表[1][18] = "real";
  类型对照表[1][19] = "image";
  类型对照表[2][0] = "vfp";
  类型对照表[2][1] = "c";
  类型对照表[2][2] = "c";
  类型对照表[2][3] = "c";
  类型对照表[2][4] = "i";
  类型对照表[2][5] = "n";
  类型对照表[2][6] = "d";
  类型对照表[2][7] = "t";
  类型对照表[2][8] = "m";
  类型对照表[2][9] = "m";
  类型对照表[2][10] = "l";
  类型对照表[2][11] = "i";
  类型对照表[2][12] = "i";
  类型对照表[2][13] = "i";
  类型对照表[2][14] = "n";
  类型对照表[2][15] = "i";
  类型对照表[2][16] = "n";
  类型对照表[2][17] = "b";
  类型对照表[2][18] = "y";
  类型对照表[2][19] = "g";
  类型对照表[3][0] = "access";
  类型对照表[3][1] = "text";
  类型对照表[3][2] = "text";
  类型对照表[3][3] = "text";
  类型对照表[3][4] = "integer";
  类型对照表[3][5] = "integer";
  类型对照表[3][6] = "date";
  类型对照表[3][7] = "date";
  类型对照表[3][8] = "memo";
  类型对照表[3][9] = "memo";
  类型对照表[3][10] = "logical";
  类型对照表[3][11] = "integer";
  类型对照表[3][12] = "integer";
  类型对照表[3][13] = "integer";
  类型对照表[3][14] = "float";
  类型对照表[3][15] = "integer";
  类型对照表[3][16] = "float";
  类型对照表[3][17] = "float";
  类型对照表[3][18] = "float";
  类型对照表[3][19] = "general";
  类型对照表[4][0] = "oracle";
  类型对照表[4][1] = "char";
  类型对照表[4][2] = "char";
  类型对照表[4][3] = "char";
  类型对照表[4][4] = "number";
  类型对照表[4][5] = "number";
  类型对照表[4][6] = "date";
  类型对照表[4][7] = "date";
  类型对照表[4][8] = "long";
  类型对照表[4][9] = "long";
  类型对照表[4][10] = "char";
  类型对照表[4][11] = "raw";
  类型对照表[4][12] = "number";
  类型对照表[4][13] = "number";
  类型对照表[4][14] = "number";
  类型对照表[4][15] = "number";
  类型对照表[4][16] = "number";
  类型对照表[4][17] = "number";
  类型对照表[4][18] = "number";
  类型对照表[4][19] = "blob";
  类型对照表[5][0] = "mysql";
  类型对照表[5][1] = "char";
  类型对照表[5][2] = "char";
  类型对照表[5][3] = "varchar";
  类型对照表[5][4] = "int";
  类型对照表[5][5] = "float";
  类型对照表[5][6] = "date";
  类型对照表[5][7] = "datetime";
  类型对照表[5][8] = "text";
  类型对照表[5][9] = "text";
  类型对照表[5][10] = "tinyint";
  类型对照表[5][11] = "tinyint";
  类型对照表[5][12] = "smallint";
  类型对照表[5][13] = "bigint";
  类型对照表[5][14] = "float";
  类型对照表[5][15] = "integer";
  类型对照表[5][16] = "double";
  类型对照表[5][17] = "float";
  类型对照表[5][18] = "float";
  类型对照表[5][19] = "blob";
  表名 = parameter[4]; // 数据表名
  字段号表 = parameter[8];
  导入文件名 = parameter[18];
  导入表名 = parameter[2];
  String[] 按钮集01 = { "从数据表导入", "标准格式导入", "紧缩格式导入", "自定义格式导入", "从XML文件导入",
    "退出" };
  按钮集 = 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) {
  }
  DBMS名称1 = parameter[1];
  ODBC数据源1 = parameter[3];
  if ((DBMS名称1 == null) || (DBMS名称1.length() == 0))
   DBMS名称1 = main1.DBMS系统;
  if ((ODBC数据源1 == null) || (ODBC数据源1.length() == 0))
   ODBC数据源1 = main1.ODBC数据源;
  关键字 = parameter[6];
  String 字段名表 = parameter[19].trim();
  if ((字段名表.length() > 0)
    && (字段名表.substring(字段名表.length() - 1).equals(",")))
   字段名表 = 字段名表.substring(0, 字段名表.length() - 1);
  表名表 = parameter[0];
  String[] l3 = 字段名表.split(",");
  字典表名 = "";
  String[] t1;
  int b = 0, c = 0;
  if (表名表.lastIndexOf(表名 + "字典表") >= 0) {
   t1 = 表名表.split(",");
   for (int i = 0; i < t1.length; i++)
    if (t1[i].lastIndexOf(表名 + "字典表") > 00)
     字典表名 = t1[i];
  }
  String[] l1;
  if (字段号表.length() > 0) {
   l1 = 字段号表.split(",");
   int[] l2 = new int[l1.length];
   for (int i = 0; i < l1.length; i++) {
    l2[i] = Integer.valueOf(l1[i]);
   }
   列数 = l1.length;
   列名 = new String[2][列数];
   for (int i = 0; i < 列数; i++) {
    列名[0][i] = l3[l2[i]];
    列名[1][i] = 列名[0][i];
   }
  } else {
   列数 = l3.length;
   列名 = new String[2][列数];
   for (int i = 0; i < 列数; i++) {
    列名[0][i] = l3[i];
    列名[1][i] = 列名[0][i];
   }
  }
  s1 = "";
  for (int i = 0; i < 列数; i++) {
   s1 = s1 + 列名[0][i] + ",";
  }
  s1 = s1.substring(0, s1.length() - 1);
  try {
   if (("," + 表名表).lastIndexOf("," + 表名 + ",") >= 0) {
    main1.driver1();
    con1 = main1.getConn();// 连接数据库
    sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select " + s1 + " from " + 表名;
   }
   ResultSet rs = sta4.executeQuery(s1);
   rsmd4 = rs.getMetaData();
   列数 = rsmd4.getColumnCount(); // 获取列数
   列名 = new String[2][列数]; // 定义列名数组
   列数据类型 = new String[列数]; // 定义列字段类型数组
   列数据宽度 = new int[列数]; // 定义列数据宽度
   for (int i = 0; i < 列数; i++) {
    列名[0][i] = rsmd4.getColumnName(i + 1); // 获取列名存到数组中
    列名[1][i] = 列名[0][i];
    列数据类型[i] = rsmd4.getColumnTypeName(i + 1);
    列数据宽度[i] = rsmd4.getColumnDisplaySize(i + 1);
    if (列数据宽度[i] < 列名[0][i].length())
     列数据宽度[i] = 列名[0][i].length();
    if (列数据宽度[i] < 列名[1][i].length())
     列数据宽度[i] = 列名[1][i].length();
    if (列数据宽度[i] > 50)
     列数据宽度[i] = 50;
   }
   关键字名 = 关键字.split(",");
   关键字名1 = new String[关键字名.length];
   关键字序号 = new int[关键字名.length];
   关键字序号1 = new int[关键字名.length];
   if (((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",0,") >= 0))
     && (DBMS名称1.trim().length() > 0)) {
    int 类型序号 = 0, 类型序号1 = 0;
    for (int i = 0; i < 类型对照表.length; i++) {
     if (DBMS名称1.trim().equals(类型对照表[i][0]))
      类型序号1 = i;
     if (main1.DBMS系统.equals(类型对照表[i][0]))
      类型序号 = i;
    }
    表格列名 = new String[列数];
    表列数据类型 = new String[列数];
    表列数据宽度 = new int[列数];
    for (b = 0; b < 列数; b++) {
     表格列名[b] = 列名[1][b];
     表列数据宽度[b] = 列数据宽度[b];
     for (int i = 1; i < 类型对照表[0].length; i++) {
      if (列数据类型[b].toLowerCase().trim()
        .equals(类型对照表[类型序号][i])) {
       表列数据类型[b] = 类型对照表[类型序号1][i];
       break;
      }
     }
    }
   }
   记录条数 = 0; // 记录条数
   rs.last();
   记录条数 = rs.getRow();
   表格数据 = new String[记录条数][列数];
   rs.absolute(1);
   c = 0; // 行号
   b = 0; // 列号
   while (c < 记录条数) {
    rs.absolute(c + 1);
    while (b < 列数) {
     表格数据[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close(); // 关闭查询结果集
   sta4.close(); // 关闭连接
   con1.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "读取数据出错！");
  }
  for (int i = 0; i < 列数; i++) {
   for (int j = 0; j < 关键字名.length; j++)
    if (关键字名[j].trim().equals(列名[0][i].trim())) {
     关键字名1[j] = 列名[1][i];
     关键字序号[j] = i;
    }
  }
  if (字典表名.length() > 0) {
   try {
    main1.driver1();
    con = main1.getConn();// 连接数据库
    sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select * from " + 字典表名;
    rs = sta3.executeQuery(s1);
    String s4 = "";
    String s5 = "";
    b = 1;
    while (rs.absolute(b)) {
     b++;
     s4 = rs.getString(1); // 字段名
     s5 = rs.getString(2);
     for (int j = 0; j < 列数; j++) {
      if (列名[0][j].trim().equals(s4.trim())) {
       列名[1][j] = s5;
       表格列名[j] = s5;
       break;
      }
     }
    }
    rs.close(); // 关闭查询结果集
    con.close();
    sta3.close();
   } catch (SQLException e) {
    JOptionPane.showMessageDialog(null, "连接数据库出错！");
   }
  }
  s2 = "";
  for (int i = 0; i < 列数; i++) {
   s2 = s2 + 列名[1][i] + ",";
  }
  s2 = s2.substring(0, s2.length() - 1);
  frame.setTitle("从文本文件、XML文件或数据库表导入数据库到本地部件。特别注意数据类型、宽度的对应。作者：程学先"); // 设置窗体标题
  frame.setBounds(10, 10, 窗口宽, 窗口高); // 设置窗体的位置和大小
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
  frame.setLayout(null);
  final JPanel panel = new JPanel(false); // 定义面板
  panel.setLayout(null); // 关闭面板布局管理器
  panel.setBounds(10, 10, 窗口宽, 窗口高);
  final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
  scrollPane.setBounds(0, 0, 窗口宽 - 20, 窗口高 - 100); // 定义滚动面板大小位置
  panel.add(scrollPane);
  // 创建表格列名数组
  model = new DefaultTableModel(表格数据, 列名[1]); // 创建表格模型
  table = new JTable(model);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
  for (int i = 0; i < 列数; i++) {
   TableColumn tc = table.getColumn(列名[1][i]);
   tc.setPreferredWidth(列数据宽度[i] * 14);
   tc.setMaxWidth(列数据宽度[i] * 14);
   tc.sizeWidthToFit();
  }
  scrollPane.setViewportView(table);
  按钮宽 = (窗口宽 - 60) / 按钮数;
  int 按钮左边距 = 30;
  for (int i = 0; i < 100; i++)
   s3 = s3 + " ";

  JButton 到数据库 = new JButton(按钮集[0]);
  到数据库.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat4;
    Statement stat3;
    try {
     if (("," + 表名表).lastIndexOf("," + 表名 + ",") >= 0) {
      main1.driver1();
      con1 = main1.getConn();
      stat4 = con1.createStatement(
        ResultSet.TYPE_SCROLL_INSENSITIVE,
        ResultSet.CONCUR_UPDATABLE);
      s1 = "select " + s2 + " from " + 导入表名;
      ResultSet rs1 = stat4.executeQuery(s1);
      rs1.last();
      记录条数1 = rs1.getRow();
      关键字数据1 = new String[记录条数1];
      列名1 = s2.split(",");
      列数1 = 列名1.length;
      for (int k = 0; k < 关键字名.length; k++) {
       for (int j = 0; j < 列数1; j++) {
        if (关键字名1[k].trim().equals(列名1[j].trim())) {
         关键字序号1[k] = j;
         break;
        }
       }
      }
      表格数据1 = new String[记录条数1][列数1];
      rs1.absolute(1);
      int c = 0; // 行号
      int b = 0; // 列号
      s2 = "";
      while (c < 记录条数1) {
       rs1.absolute(c + 1);
       while (b < 列数) {
        表格数据1[c][b] = rs1.getString(b + 1);
        b++;
       }
       c++;
       b = 0;
      }
      for (int i = 0; i < 记录条数1; i++) {
       关键字数据1[i] = "";
       for (int k = 0; k < 关键字名.length; k++) {
        关键字数据1[i] = 关键字数据1[i]
          + 表格数据1[i][关键字序号1[k]].trim();
       }
      }
      rs1.close(); // 关闭查询结果集
      stat4.close();
      con1.close();
     }
    } catch (SQLException e1) {
    }
    try { // 以下导入
     main1.driver1();
     con = main1.getConn();
     stat4 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     int f0 = 0;
     for (int i = 0; i < 记录条数; i++) {
      s3 = "";
      for (int j = 0; j < 关键字名.length; j++)
       s3 = s3 + 表格数据[i][关键字序号[j]].trim();
      f0 = 0;
      for (int i1 = 0; i1 < 记录条数1; i1++) {
       if (关键字数据1[i1].trim().equals(s3.trim()))
        f0 = 1;
      }
      if (f0 == 0) {
       s1 = "insert into " + 表名 + " (";
       for (int k1 = 0; k1 < 列名[1].length; k1++)
        s1 = s1 + 列名[1][k1] + ",";
       s1 = s1.substring(0, s1.length() - 1)
         + " ) values (";
       for (int j = 0; j < 列名[1].length; j++) {
        if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
         if (表格数据1[i][j] == null)
          表格数据1[i][j] = "0";
         s1 = s1 + 表格数据1[i][j];
        } else {
         if (表格数据1[i][j] == null)
          表格数据1[i][j] = " ";
         s1 = s1 + "'" + 表格数据1[i][j] + "'";
        }
        if (j != 列名[1].length - 1)
         s1 = s1 + ",";
       }
       s1 = s1 + ")";
       stat4.executeUpdate(s1);
      } else {
       s1 = "update " + 表名 + " set ";
       for (int k1 = 0; k1 < 列名[1].length; k1++) {
        s1 = s1 + 列名[1][k1] + "=";
        if (类型1.lastIndexOf("," + 列数据类型[k1] + ",") >= 0) {
         if (表格数据1[i][k1] == null)
          表格数据1[i][k1] = "0";
         s1 = s1 + 表格数据1[i][k1];
        } else {
         if (表格数据1[i][k1] == null)
          表格数据1[i][k1] = " ";
         s1 = s1 + "'" + 表格数据1[i][k1] + "'";
        }
        if (k1 != 列名[1].length - 1)
         s1 = s1 + ",";
       }
       s2 = " where ";
       for (int k = 0; k < 关键字名.length; k++) {
        s2 = s2 + 关键字名1[k] + "='" + 表格数据1[i][关键字序号1[k]]
          + "'";
        if (k < 关键字名.length - 1)
         s2 = s2 + " and ";
       }
       s1 = s1 + s2;
       stat4.executeUpdate(s1);
      }
     }
     stat4.close(); // 关闭连接
     con.close();
    } catch (SQLException e1) {
     JOptionPane.showMessageDialog(null,
       "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
    }

   }
  });
  if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",0,") >= 0)) {
   到数据库.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
   panel.add(到数据库);
   按钮左边距 = 按钮左边距 + 按钮宽;
  }

  JButton 标准格式 = new JButton(按钮集[1]);
  标准格式.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     FileReader fs = new FileReader(导入文件名);
     BufferedReader br = new BufferedReader(fs);
     String tempStr = null;
     String[] 空记录1 = new String[列数];
     int k1 = 0, k2 = 0, k5 = 0;
     for (int i1 = 0; (tempStr = br.readLine()) != null; i1++) {
      k5 = 0;
      for (int j = 0; j < 列数; j++) {
       空记录1[j] = tempStr.substring(k1, k1 + 列数据宽度[j]);
       k1 = k1 + 列数据宽度[j];
      }
      s3 = "";
      for (int k3 = 0; k3 < 关键字名.length; k3++)
       s3 = s3 + 空记录1[关键字序号[k3]].trim();
      k2 = 0;
      for (int j1 = 0; j1 < 记录条数; j1++) {
       s2 = "";
       for (int k4 = 0; k4 < 关键字名.length; k4++)
        s2 = s2 + 表格数据[j1][关键字序号[k4]].trim();
       if (s3.trim().equals(s2.trim())) {
        k2 = j1;
        k5 = 1;
       }
      }
      try {
       main1.driver1();
       con = main1.getConn();
       stat3 = con.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
       if (k5 == 0) { // 添加
        s1 = "insert into " + 表名 + " (";
        for (int k6 = 0; k6 < 列名[1].length; k6++)
         s1 = s1 + 列名[1][k6] + ",";
        s1 = s1.substring(0, s1.length() - 1)
          + " ) values (";
        for (int j = 0; j < 列名[1].length; j++) {
         if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
          if (空记录1[j] == null)
           空记录1[j] = "0";
          s1 = s1 + 空记录1[j];
         } else {
          if (空记录1[j] == null)
           空记录1[j] = " ";
          s1 = s1 + "'" + 空记录1[j] + "'";
         }
         if (j != 列名[1].length - 1)
          s1 = s1 + ",";
        }
        s1 = s1 + ")";
        stat3.executeUpdate(s1);
       } else {
        s1 = "update " + 表名 + " set ";
        for (int k6 = 0; k6 < 列名[1].length; k6++) {
         s1 = s1 + 列名[1][k6] + "=";
         if (类型1.lastIndexOf("," + 列数据类型[k6] + ",") >= 0) {
          if (空记录1[k6] == null)
           空记录1[k6] = "0";
          s1 = s1 + 空记录1[k6];
         } else {
          if (空记录1[k6] == null)
           空记录1[k6] = " ";
          s1 = s1 + "'" + 空记录1[k6] + "'";
         }
         if (k6 != 列名[1].length - 1)
          s1 = s1 + ",";
        }
        s2 = " where ";
        for (int k = 0; k < 关键字名.length; k++) {
         s2 = s2 + 关键字名1[k] + "='" + 空记录1[关键字序号1[k]]
           + "'";
         if (k < 关键字名.length - 1)
          s2 = s2 + " and ";
        }
        s1 = s1 + s2;
        stat3.executeUpdate(s1);

        stat3.close(); // 关闭连接
        con.close();
       }
      } catch (SQLException e1) {
       JOptionPane.showMessageDialog(null,
         "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
      }
      k1 = 0;
     }
     fs.close();// 释放资源
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
    } catch (IOException e2) {
     e2.printStackTrace();
    }
   }
  });
  if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",1,") >= 0)) {
   标准格式.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
   panel.add(标准格式);
   按钮左边距 = 按钮左边距 + 按钮宽;
  }

  JButton 紧缩格式 = new JButton(按钮集[2]);
  紧缩格式.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     FileReader fs = new FileReader(导入文件名);
     BufferedReader br = new BufferedReader(fs);
     String tempStr = null;
     String[] 空记录1 = new String[列数];
     int k2 = 0, k5 = 0;
     char x6 = '"';
     for (int i = 0; (tempStr = br.readLine()) != null; i++) {
      k5 = 0;
      空记录1 = tempStr.split(",");
      for (int j = 0; j < 列数; j++) {
       if (空记录1[j].lastIndexOf("" + x6) >= 0)
        空记录1[j] = 空记录1[j].substring(1,
          空记录1[j].length() - 1);
      }
      s3 = "";
      for (int k3 = 0; k3 < 关键字名.length; k3++)
       s3 = s3 + 空记录1[关键字序号[k3]].trim();
      k2 = 0;
      for (int j1 = 0; j1 < 记录条数; j1++) {
       s2 = "";
       for (int k4 = 0; k4 < 关键字名.length; k4++)
        s2 = s2 + 表格数据[j1][关键字序号[k4]].trim();
       if (s3.trim().equals(s2.trim())) {
        k2 = j1;
        k5 = 1;
       }
      }
      try {
       main1.driver1();
       con = main1.getConn();
       stat3 = con.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
       if (k5 == 0) {
        s1 = "insert into " + 表名 + " (";
        for (int k6 = 0; k6 < 列名[1].length; k6++)
         s1 = s1 + 列名[1][k6] + ",";
        s1 = s1.substring(0, s1.length() - 1)
          + " ) values (";
        for (int j = 0; j < 列名[1].length; j++) {
         if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
          if (空记录1[j] == null)
           空记录1[j] = "0";
          s1 = s1 + 空记录1[j];
         } else {
          if (空记录1[j] == null)
           空记录1[j] = " ";
          s1 = s1 + "'" + 空记录1[j] + "'";
         }
         if (j != 列名[1].length - 1)
          s1 = s1 + ",";
        }
        s1 = s1 + ")";
        stat3.executeUpdate(s1);
       } else {
        s1 = "update " + 表名 + " set ";
        for (int k6 = 0; k6 < 列名[1].length; k6++) {
         s1 = s1 + 列名[1][k6] + "=";
         if (类型1.lastIndexOf("," + 列数据类型[k6] + ",") >= 0) {
          if (空记录1[k6] == null)
           空记录1[k6] = "0";
          s1 = s1 + 空记录1[k6];
         } else {
          if (空记录1[k6] == null)
           空记录1[k6] = " ";
          s1 = s1 + "'" + 空记录1[k6] + "'";
         }
         if (k6 != 列名[1].length - 1)
          s1 = s1 + ",";
        }
        s2 = " where ";
        for (int k = 0; k < 关键字名.length; k++) {
         s2 = s2 + 关键字名1[k] + "='" + 空记录1[关键字序号1[k]]
           + "'";
         if (k < 关键字名.length - 1)
          s2 = s2 + " and ";
        }
        s1 = s1 + s2;
        stat3.executeUpdate(s1);
        stat3.close();
        con.close();
       }
      } catch (SQLException e1) {
       JOptionPane.showMessageDialog(null,
         "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
      }
     }
     fs.close();// 释放资源
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
    } catch (IOException e2) {
     e2.printStackTrace();
    }
   }
  });
  if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",2,") >= 0)) {
   紧缩格式.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
   panel.add(紧缩格式);
   按钮左边距 = 按钮左边距 + 按钮宽;
  }

  JButton 自定义格式 = new JButton(按钮集[3]);
  自定义格式.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符", "");
     FileReader fs = new FileReader(导入文件名);
     BufferedReader br = new BufferedReader(fs);
     String tempStr = null;
     String[] 空记录1 = new String[列数];
     int k2 = 0, k5 = 0;
     String s5 = "";
     String x6 = "", x7 = null;
     char x1 = 13;
     for (int i = 0; (tempStr = br.readLine()) != null; i++) {
      k5 = 0;
      x6 = tempStr;
      while (x6.indexOf("】【") < 0) {
       if ((tempStr = br.readLine()) != null) {
        x6 = x6 + x1 + tempStr;
        i++;
       }
      }
      x6 = x6.substring(0, x6.length() - 2);
      空记录1 = x6.split(x5);
      s3 = "";
      for (int k3 = 0; k3 < 关键字名.length; k3++)
       s3 = s3 + 空记录1[关键字序号[k3]].trim();
      k2 = 0;
      for (int j1 = 0; j1 < 记录条数; j1++) {
       s2 = "";
       for (int k4 = 0; k4 < 关键字名.length; k4++)
        s2 = s2 + 表格数据[j1][关键字序号[k4]].trim();
       if (s3.trim().equals(s2.trim())) {
        k2 = j1;
        k5 = 1;
       }
      }
      try {
       main1.driver1();
       con = main1.getConn();
       stat3 = con.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
       if (k5 == 0) {
        s1 = "insert into " + 表名 + " (";
        for (int k6 = 0; k6 < 列名[1].length; k6++)
         s1 = s1 + 列名[1][k6] + ",";
        s1 = s1.substring(0, s1.length() - 1)
          + " ) values (";
        for (int j = 0; j < 列名[1].length; j++) {
         if (类型1.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {
          if (空记录1[j] == null)
           空记录1[j] = "0";
          s1 = s1 + 空记录1[j];
         } else {
          if (空记录1[j] == null)
           空记录1[j] = " ";
          s1 = s1 + "'" + 空记录1[j] + "'";
         }
         if (j != 列名[1].length - 1)
          s1 = s1 + ",";
        }
        s1 = s1 + ")";
        stat3.executeUpdate(s1);
       } else {
        s1 = "update " + 表名 + " set ";
        for (int k6 = 0; k6 < 列名[1].length; k6++) {
         s1 = s1 + 列名[1][k6] + "=";
         if (类型1.lastIndexOf("," + 列数据类型[k6] + ",") >= 0) {
          if (空记录1[k6] == null)
           空记录1[k6] = "0";
          s1 = s1 + 空记录1[k6];
         } else {
          if (空记录1[k6] == null)
           空记录1[k6] = " ";
          s1 = s1 + "'" + 空记录1[k6] + "'";
         }
         if (k6 != 列名[1].length - 1)
          s1 = s1 + ",";
        }
        s2 = " where ";
        for (int k = 0; k < 关键字名.length; k++) {
         s2 = s2 + 关键字名1[k] + "='" + 空记录1[关键字序号1[k]]
           + "'";
         if (k < 关键字名.length - 1)
          s2 = s2 + " and ";
        }
        s1 = s1 + s2;
        stat3.executeUpdate(s1);
        stat3.close();
        con.close();
       }
      } catch (SQLException e1) {
       JOptionPane.showMessageDialog(null,
         "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
      }
     }
     fs.close();// 释放资源
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
    } catch (IOException e2) {
     e2.printStackTrace();
    }
   }
  });
  if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",3,") >= 0)) {
   自定义格式.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
   panel.add(自定义格式);
   按钮左边距 = 按钮左边距 + 按钮宽;
  }

  JButton 到XML文件 = new JButton(按钮集[4]);
  到XML文件.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     DocumentBuilderFactory factory = DocumentBuilderFactory
       .newInstance();
     DocumentBuilder db = factory.newDocumentBuilder();
     Document doc = db.parse(new File(导入文件名));
     Element elmtInfo = doc.getDocumentElement();
     NodeList nodes = elmtInfo.getChildNodes();
     String[] 列名0 = new String[列数];
     String[] 空记录 = new String[列数];
     String[] 空记录1 = new String[列数];
     int k = 0, k1 = 0, k2 = 0, k5 = 0;
     for (int i = 0; i < nodes.getLength(); i++) {
      k5 = 0;
      NodeList ns = nodes.item(i).getChildNodes();
      k = 0;
      for (int j2 = 0; j2 < 列数; j2++)
       空记录1[j2] = "";
      k1 = 0;
      for (int j = 0; j < ns.getLength(); j++) {
       Node record = ns.item(j);
       if (record.toString().lastIndexOf("null") > 0) {
        列名0[k] = ns
          .item(j)
          .toString()
          .substring(
            1,
            record.toString().lastIndexOf(
              ":"));
        空记录[k] = record.getTextContent();
        for (int j2 = 0; j2 < 列数; j2++) {
         if (列名[1][j2].lastIndexOf(列名0[k]) >= 0) {
          空记录1[j2] = 空记录[k];
          break;
         }
        }
        k++;
        k1 = 1;
       }
      }
      if (k1 > 0) {
       s3 = "";
       for (int k3 = 0; k3 < 关键字名.length; k3++)
        s3 = s3 + 空记录1[关键字序号[k3]].trim();
       k2 = 0;
       for (int j1 = 0; j1 < 记录条数; j1++) {
        s2 = "";
        for (int k4 = 0; k4 < 关键字名.length; k4++)
         s2 = s2 + 表格数据[j1][关键字序号[k4]].trim();
        if (s3.trim().equals(s2.trim())) {
         k2 = j1;
         k5 = 1;
        }
       }
       try {
        main1.driver1();
        con = main1.getConn();
        stat3 = con.createStatement(
          ResultSet.TYPE_SCROLL_INSENSITIVE,
          ResultSet.CONCUR_UPDATABLE);
        if (k5 == 0) {
         s1 = "insert into " + 表名 + " (";
         for (int k6 = 0; k6 < 列名[1].length; k6++)
          s1 = s1 + 列名[1][k6] + ",";
         s1 = s1.substring(0, s1.length() - 1)
           + " ) values (";
         for (int j = 0; j < 列名[1].length; j++) {
          if (类型1.lastIndexOf("," + 列数据类型[j]
            + ",") >= 0) {
           if (空记录1[j] == null)
            空记录1[j] = "0";
           s1 = s1 + 空记录1[j].trim();
          } else {
           if (空记录1[j] == null)
            空记录1[j] = " ";
           s1 = s1 + "'" + 空记录1[j].trim()
             + "'";
          }
          if (j != 列名[1].length - 1)
           s1 = s1 + ",";
         }
         s1 = s1 + ")";
         stat3.executeUpdate(s1);
        } else {
         s1 = "update " + 表名 + " set ";
         for (int k6 = 0; k6 < 列名[1].length; k6++) {
          s1 = s1 + 列名[1][k6] + "=";
          if (类型1.lastIndexOf("," + 列数据类型[k6]
            + ",") >= 0) {
           if (空记录1[k6] == null)
            空记录1[k6] = "0";
           s1 = s1 + 空记录1[k6].trim();
          } else {
           if (空记录1[k6] == null)
            空记录1[k6] = " ";
           s1 = s1 + "'" + 空记录1[k6].trim()
             + "'";
          }
          if (k6 != 列名[1].length - 1)
           s1 = s1 + ",";
         }
         s2 = " where ";
         for (int k7 = 0; k7 < 关键字名.length; k7++) {
          s2 = s2 + 关键字名1[k7] + "='"
            + 空记录1[关键字序号1[k7]].trim() + "'";
          if (k7 < 关键字名.length - 1)
           s2 = s2 + " and ";
         }
         s1 = s1 + s2;
         stat3.executeUpdate(s1);
         stat3.close();
         con.close();
        }
       } catch (SQLException e1) {
        JOptionPane.showMessageDialog(null,
          "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
       }
      }
     }
    } catch (ParserConfigurationException e1) {
     e1.printStackTrace();
    } catch (SAXException e2) {
     e2.printStackTrace();
    } catch (IOException e3) {
     e3.printStackTrace();
    }
   }
  });
  if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",4,") >= 0)) {
   到XML文件.setBounds(按钮左边距, 窗口高 - 80, 按钮宽, 20);
   panel.add(到XML文件);
   按钮左边距 = 按钮左边距 + 按钮宽;
  }

50.源码50，部件程序，覆盖式从office文件，包括word、excel、pdf文件导入数据导入部件。
/**
* 程序文件名：dataTransfer10.java
* 作者：程学先
* 功能：覆盖式从office文件，包括word、excel、pdf文件导入。
* 原目的表内容将删除。
* 目的表与源表数据类型、数据宽度应当对应相容。
* 完成日期：2013年1月22日
* 被调用语句：dataTransfer10.means(parameter)
* 必须提供的参数：数据“表名”、“导入文件名”。
* 可选择参数：“字段号表”、“要求按钮号表”、
* 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；
* 否则写入所有将涉及的字段在表中的顺序号，号与号之间以英文逗号分隔。
* 本部件预设的按钮控件共4个，序号及按钮名：1覆盖式从word文件导入、2覆盖式从excel文件导入、
* 3覆盖式从PDF文件导入、4退出
* 通过“要求按钮号表”可以选择按钮以满足功能需求。
* 导入到Office文件要求下载以下文件并设置构建路径：
* iText-5.0.5.jar、jacob.jar、poi-3.8-20120326.jar、PDFBox-0.7.3.jar
* 如果从PDF文件导入。不支持大数据类型，每字段宽度不超过50字符。只能从由dataTransfer4.java生成的PDF文件导入。
*/

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hwpf.extractor.WordExtractor;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Font;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfWriter;

public class dataTransfer10 extends JFrame {
static dataTransfer10 frame = new dataTransfer10(); // 创建窗体
private static JTable table;    //创建表格
static Connection con1;
static String url;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta4;
static ResultSet rs;   //数据库数据集，存放查询的结果
static int 窗口宽=800,窗口高=600;//窗口宽、窗口高
    static int 列数; //数据表列数
    static int 列数1;
    static String [][] 列名; //数据表列名
    static String [] 列名1;
    static int[] 对应目的表序号;   //存放当前记录各字段数据宽度的数组
    static String [] 表格列名;
    static String[] 列数据类型; //存放当前记录各字段数据类型的数组
    static String[] 表列数据类型;
    static int[] 列数据宽度,列小数位数;   //存放当前记录各字段数据宽度的数组
  static int 记录条数=0,记录条数1=0;   //记录条数
    static int[] 表列数据宽度,表列小数位数;
    static int 当前记录号;
static String[][] 表格数据;
static DefaultTableModel model;
static String 表名;      //数据表名
static String 字典表名;
static String 导入文件名;
static String [] 按钮集=null;
static String 要求按钮号表;
static String 字段号表;
    public static String [] sw=new String[11];
static String s1="",s2="",s3="";
static String s4="                                                  ";
static char x1=10,x2=13,x3='"',x4=',';
static String 类型1=main1.类型1;
static int 按钮数=0,按钮宽=0;

public static void means(String [] parameter) {
frame = new dataTransfer10();
窗口宽=800;窗口高=600;
记录条数=0;记录条数1=0;
s1="";s2="";s3="";
s4="                                                  ";
x1=10;x2=13;x3='"';x4=',';
类型1=main1.类型1;
File file = new File(".\\com\\iText-5.0.5.jar");
    if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中！"); return;}
    file = new File(".\\com\\jacob.jar");
    if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中！"); return;}
    file = new File(".\\com\\poi-3.8-20120326.jar");
    if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中！"); return;}
    file = new File(".\\com\\PDFBox-0.7.3.jar");
    if (!file.exists()) {JOptionPane.showMessageDialog( null, "请将有关jar文件包下载到com文件夹中！"); return;}
sw=new String [11];
    sw[1]=main1.sw1+"";sw[2]=main1.sw2;sw[3]=main1.sw3; //为了不出现0影响判断，在树程序中将工序号统加1
    sw[4]=main1.sw4;sw[5]=main1.sw5;sw[6]=main1.sw6;
    sw[7]=main1.sw7;sw[8]=main1.sw8;sw[9]=main1.sw9;
    sw[10]=main1.sw10;
    main1.sw1=0;main1.sw2="";main1.sw3="";
    main1.sw4="";main1.sw5="";main1.sw6="";
    main1.sw7="";main1.sw8="";main1.sw9="";main1.sw10="";
    表名=parameter[4] ; // 数据表名
  字段号表=parameter[8];
  导入文件名=parameter[18];
  String [] 按钮集01={"从word导入","从excel导入","从PDF文件导入","退出"};
        按钮集=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){}
  String 字段名表=parameter[19].trim();
  if ((字段名表.length()>0)&&(字段名表.substring(字段名表.length()-1).equals(",")))
   字段名表=字段名表.substring(0,字段名表.length()-1);
  String 表名表=parameter[0];
  String [] l3=字段名表.split(",");
        字典表名="";
        String []t1;
        int b=0,c=0;
        if (表名表.lastIndexOf(表名+"字典表")>=0){
        t1=表名表.split(",");
        for (int i=0;i<t1.length;i++)
          if (t1[i].lastIndexOf(表名+"字典表")>=0) 字典表名=t1[i];
        }
        String[] l1;
  if (字段号表.length()>0){
      l1=字段号表.split(",");
      int [] l2=new int[l1.length];
      for (int i=0;i<l1.length;i++){
        l2[i]=Integer.valueOf(l1[i]);
      }
      列数=l1.length;
            列名=new String[2][列数];
            for (int i=0;i<列数;i++){
          列名[0][i]=l3[l2[i]];
          列名[1][i]=列名[0][i];
      }
   }
  else {
   列数=l3.length;
   列名=new String[2][列数];
            for (int i=0;i<列数;i++){
          列名[0][i]=l3[i];
          列名[1][i]=列名[0][i];
            }
  }
  s1="";
   for (int i=0;i<列数;i++)
        s1=s1+列名[0][i]+",";
   s1=s1.substring(0,s1.length()-1);
      try {
      if ((","+表名表).lastIndexOf(","+表名+",")>=0){
      con1=main1.getConn();// 连接数据库
      sta4 = con1.createStatement(
        ResultSet.TYPE_SCROLL_INSENSITIVE,
                  ResultSet.CONCUR_UPDATABLE);
       s1="select "+s1+" from "+表名;
   if ((sw[3].length()>0)&&(sw[4].length()>0))
    s1=s1+" where "+sw[4]+" = '"+sw[5]+"'";
      }
      else {
      JOptionPane.showMessageDialog( null, "目的数据表不存在，不能导入！");
      return;
      }
          ResultSet rs=sta4.executeQuery(s1);
          rsmd4 = rs.getMetaData();
    列数 = rsmd4.getColumnCount(); // 获取列数
   列名 = new String[2][列数]; // 定义列名数组
   列数据类型 = new String[列数]; // 定义列字段类型数组
   列数据宽度 = new int[列数]; // 定义列数据宽度
   for (int i=0;i<列数;i++) {
  列名[0][i] = rsmd4.getColumnName(i + 1); // 获取列名存到数组中
  列名[1][i]=列名[0][i];
  列数据类型[i] = rsmd4.getColumnTypeName(i + 1);
     列数据宽度[i] = rsmd4.getColumnDisplaySize(i + 1);
     if (列数据宽度[i]<列名[0][i].length()) 列数据宽度[i]=列名[0][i].length();
     if (列数据宽度[i]<列名[1][i].length()) 列数据宽度[i]=列名[1][i].length();
     if (列数据宽度[i]>50) 列数据宽度[i]=50;
         }
       表格列名=new String[列数];
        表列数据类型=new String[列数];
        表列数据宽度=new int[列数];
          for (b=0;b<列数;b++){
        表格列名[b]=列名[1][b];
        表列数据宽度[b]=列数据宽度[b];
            }
      记录条数=0;
      rs.last();
      记录条数=rs.getRow();
       表格数据=new String[记录条数][列数];
      rs.absolute(1);
      c=0;    //行号
      b=0;        //列号
     while(c<记录条数) {
          rs.absolute(c+1);
           while(b<列数){
           表格数据[c][b]=rs.getString(b+1);
                   b++;
          }
          c++;
          b=0;
    }
      rs.close();     //关闭查询结果集
      sta4.close();     //关闭连接
      con1.close();
      }
     catch(SQLException e)
     {
    JOptionPane.showMessageDialog( null, "读取数据出错！");
     }
        if (字典表名.length()>0){
            try
            {
         con1=main1.getConn();// 连接数据库
       sta4 = con1.createStatement(
             ResultSet.TYPE_SCROLL_INSENSITIVE,
                   ResultSet.CONCUR_UPDATABLE);
         s1 = "select * from " + 字典表名;
         rs = sta4.executeQuery(s1);
                   String s4="";
                   String s5="";
                   b=1;
                   while (rs.absolute(b)) {
                    b++;
                        s4=rs.getString(1);    //字段名
                       s5=rs.getString(2);
                       for (int j=0;j<列数;j++){
                         if (列名[0][j].trim().equals(s4.trim())){
                         列名[1][j]=s5;
                         表格列名[j]=s5;
                        break;
                        }
                       }
                    }
                 rs.close();     //关闭查询结果集
                 con1.close();
                 sta4.close();
  } catch (SQLException e)
  {
   JOptionPane.showMessageDialog( null, "连接数据库出错！");
  }
   }
     frame.setTitle("数据覆盖式从office文件导入部件。                           作者：程学先"); // 设置窗体标题
    frame.setBounds(10, 10, 窗口宽, 窗口高); // 设置窗体的位置和大小
    frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式
        frame.setLayout(null);
        final JPanel panel = new JPanel(false);      //定义面板
        panel.setLayout(null);        //关闭面板布局管理器
        panel.setBounds(10, 10,窗口宽,窗口高);
    final JScrollPane scrollPane = new JScrollPane(); // 创建滚动面板
     scrollPane.setBounds(0,0,窗口宽-20,窗口高-100); //定义滚动面板大小位置
     panel.add(scrollPane);
    model = new DefaultTableModel(表格数据,列名[1]);   // 创建表格模型
         table = new JTable(model);// 创建指定表格模型的表格
        table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
        table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
        for(int i=0;i<列数;i++) {
            TableColumn tc = table.getColumn(列名[1][i]);
            tc.setPreferredWidth(列数据宽度[i]*14);
            tc.setMaxWidth(列数据宽度[i]*14);
            tc.sizeWidthToFit();
        }
        scrollPane.setViewportView(table);
  按钮宽=(窗口宽-60)/按钮数;
  int 按钮左边距=30;

     JButton 从word = new JButton(按钮集[0]);
         从word.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
    int k0=model.getRowCount();
       for (int i1=0;i1<k0;i1++){
              model.removeRow(0);
       }
    当前记录号= model.getRowCount();
        if (导入文件名.length()==0){
        导入文件名=JOptionPane.showInputDialog("请输入导入文件完整路径例如：F:\\java.doc","");
        return;
      }
        int p1=0,p2=0;
        if (导入文件名.lastIndexOf(".doc")<0){
         p1=导入文件名.lastIndexOf(".");
         p2=导入文件名.lastIndexOf("\\\\");
         if (p2>p1){
        导入文件名=导入文件名+".doc";
        导入文件名=导入文件名.replace("\\.","\\.\\.");
        }
         else {
         导入文件名=导入文件名.substring(0,p1)+".doc";
         }
        }
     try {
     FileInputStream in=new FileInputStream(new File(导入文件名));
     WordExtractor extractor=null;
     extractor=new WordExtractor(in);
     String 内容=extractor.getText();
     int m1=0;;
     String[] 记录=new String[列数];
     int k=0;
int k2=0,k5=0;
              记录[k]="";
     for (int i=0;i<内容.length();i++){
if (内容.charAt(i)=='\r'){
         k5=0;
            model.addRow(记录);    记录条数++;
            记录[0]="";
           k=0;
           m1=1;
           if ((i<内容.length()-2)&&(内容.charAt(i+2)=='\r')) break;
}
else if (内容.charAt(i)=='\n'){}
else if ((byte)(内容.charAt(i))==9){
  k++;
  m1=0;
  if (k<列数) 记录[k]="";
}
else if (k<列数){
  记录[k]=记录[k]+内容.charAt(i);
}
     }
     } catch (Exception e1) {
            JOptionPane.showMessageDialog(null, "读取数据出错！");
       }
try {
       main1.driver1();
         con1=main1.getConn();
           sta4 = con1.createStatement(
                   ResultSet.TYPE_SCROLL_INSENSITIVE,
                         ResultSet.CONCUR_UPDATABLE);
             s1="delete from "+表名;
             sta4.executeUpdate(s1);
         sta4.close();
         con1.close();
        }catch(SQLException e1){
        }
    try{
         main1.driver1();
          con1=main1.getConn();
          sta4 = con1.createStatement(
                  ResultSet.TYPE_SCROLL_INSENSITIVE,
                        ResultSet.CONCUR_UPDATABLE);
            for (int i=0;i<model.getRowCount();i++){
                s1="insert into "+表名+" (";
                for (int k1=0;k1<列名[1].length;k1++)
                s1=s1+列名[1][k1]+",";
                s1=s1.substring(0,s1.length()-1)+" ) values (";
            for (int j=0;j<列名[1].length;j++){
             if (类型1.lastIndexOf(","+列数据类型[j]+",")>=0){
              if (model.getValueAt(i,j)==null) s1=s1+"0";
              else s1=s1+model.getValueAt(i,j).toString().trim();
            }
             else{
              if (model.getValueAt(i,j)==null) s1=s1+" ";
             else s1=s1+"'"+model.getValueAt(i,j).toString().trim()+"'";
                }
              if (j!=列名[1].length-1) s1=s1+",";
            }
             s1=s1+")";
              sta4.executeUpdate(s1);
            }
            sta4.close();     //关闭连接
            con1.close();
       }
          catch(SQLException e1)
          {
         JOptionPane.showMessageDialog( null, "操作出错，请检查数据表名是否重复，录入语句是否正确！"+s1);
          }
     }
     });
     if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",0,")>=0)){
          从word.setBounds(按钮左边距,窗口高-80,按钮宽,20);
          panel.add(从word);
          按钮左边距=按钮左边距+按钮宽;
     }

     JButton 从excel = new JButton(按钮集[1]);
             从excel.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
    int k0=model.getRowCount();
      for (int i1=0;i1<k0;i1++){
             model.removeRow(0);
      }
   当前记录号= model.getRowCount();
    当前记录号= model.getRowCount();
         if (导入文件名.length()==0){
         导入文件名=JOptionPane.showInputDialog("请输入导入文件完整路径例如：F:\\java.xls","");
         return;
       }
      int p1=0,p2=0;
   if (导入文件名.lastIndexOf(".xls")<0){
    p1=导入文件名.lastIndexOf(".");
    p2=导入文件名.lastIndexOf("\\\\");
    if (p2>p1){
     导入文件名=导入文件名+".xls";
     导入文件名=导入文件名.replace("\\.","\\.\\.");
     }
    else {
    导入文件名=导入文件名.substring(0,p1)+".xls";
    }
   }
          InputStream is = null;
          HSSFWorkbook wbWorkbook = null;
     try {
is = new FileInputStream(导入文件名);
wbWorkbook = new HSSFWorkbook(is);
     } catch (FileNotFoundException e1) {
e1.printStackTrace();
JOptionPane.showMessageDialog(null, "读取文件失败，请检查路径是否正确！", "错误",
          JOptionPane.INFORMATION_MESSAGE);
     } catch (IOException e2) {
e2.printStackTrace();
     }
     HSSFSheet sheet = wbWorkbook.getSheetAt(0);
     int lastRowNum = sheet.getLastRowNum();
     int 导入表格行数 = sheet.getPhysicalNumberOfRows();
     HSSFRow row = sheet.getRow(1);
     int 导入表格列数=row.getPhysicalNumberOfCells();
     if (导入表格列数!=列数)
      JOptionPane.showMessageDialog(null, "原文件中数据结构与数据表不同！");
     String[] val;
     int k2=0,k5=0;
     String value = "";
     for (int i = 0; i < 导入表格行数; i++) {
         row = sheet.getRow(i);
         if (row != null) {
              for (int j = 0; j < 导入表格列数; j++) {
                   HSSFCell cell = row.getCell(j);
                    if (cell != null) {
                    switch (cell.getCellType()){
                     case HSSFCell.CELL_TYPE_FORMULA:
                     break;
                     case HSSFCell.CELL_TYPE_NUMERIC:
                        value += cell.getNumericCellValue() + ",";
                        break;
                     case HSSFCell.CELL_TYPE_STRING:
                        value += cell.getStringCellValue() + ",";
                        break;
                     default:
                        value += "0";
                        break;
                    }
               }
          }
         val = value.split(",");
         k5=0;
            model.addRow(val);
            value = "";
          }
     }
try {
  main1.driver1();
         con1=main1.getConn();
           sta4 = con1.createStatement(
                   ResultSet.TYPE_SCROLL_INSENSITIVE,
                         ResultSet.CONCUR_UPDATABLE);
          s1="delete from "+表名;
          sta4.executeUpdate(s1);
         sta4.close();
         con1.close();
     }catch(SQLException e1){
     }
   try{
     main1.driver1();
         con1=main1.getConn();
      sta4 = con1.createStatement(
                 ResultSet.TYPE_SCROLL_INSENSITIVE,
                       ResultSet.CONCUR_UPDATABLE);
        for (int i=当前记录号;i<model.getRowCount();i++){
            s1="insert into "+表名+" (";
            for (int k1=0;k1<列名[1].length;k1++)
            s1=s1+列名[1][k1]+",";
            s1=s1.substring(0,s1.length()-1)+" ) values (";
        for (int j=0;j<列名[1].length;j++){
         if (类型1.lastIndexOf(","+列数据类型[j]+",")>=0){
          if (model.getValueAt(i,j)==null) s1=s1+"0";
          else s1=s1+model.getValueAt(i,j).toString().trim();
          }
         else{
         if (model.getValueAt(i,j)==null) s1=s1+"' '";
         else s1=s1+"'"+model.getValueAt(i,j).toString().trim()+"'";
            }
          if (j!=列名[1].length-1) s1=s1+",";
        }
         s1=s1+")";
          sta4.executeUpdate(s1);
        }
        sta4.close();     //关闭连接
        con1.close();
   }
      catch(SQLException e1)
      {
     JOptionPane.showMessageDialog( null, "操作出错，请检查数据表名是否重复，录入语句是否正确！"+s1);
      }
     }
     });
     if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",1,")>=0)){
          从excel.setBounds(按钮左边距,窗口高-80,按钮宽,20);
          panel.add(从excel);
          按钮左边距=按钮左边距+按钮宽;
     }

     JButton 从pdf = new JButton(按钮集[2]);
       从pdf.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
    int k0=model.getRowCount();
      for (int i1=0;i1<k0;i1++){
             model.removeRow(0);
      }
    当前记录号= model.getRowCount();
         if (导入文件名.length()==0){
         导入文件名=JOptionPane.showInputDialog("请输入导入文件完整路径例如：F:\\java.pdf","");
         return;
       }
      int p1=0,p2=0;
   if (导入文件名.lastIndexOf(".pdf")<0){
    p1=导入文件名.lastIndexOf(".");
    p2=导入文件名.lastIndexOf("\\\\");
    if (p2>p1){
     导入文件名=导入文件名+".pdf";
     导入文件名=导入文件名.replace("\\.","\\.\\.");
     }
    else {
    导入文件名=导入文件名.substring(0,p1)+".pdf";
    }
   }
     try {
     FileInputStream in = new FileInputStream(导入文件名);
     PDFParser parser = new PDFParser(in);
     parser.parse();
     PDDocument pdfdocument = parser.getPDDocument();
     PDFTextStripper stripper = new PDFTextStripper();
     s1 = stripper.getText(pdfdocument);
     in.close();
     } catch (Exception e1) {
          e1.printStackTrace();
     }
     String[] 记录=new String[列数];
     String s4="";
     int k=0,m1=0,k2=0,k5=0;
              记录[0]="";
     int l1=s1.length();
     for (int i1=0;i1<l1;i1++){
          s2=s1.substring(i1,i1+1);
          if (s1.charAt(i1)=='\r') {}
          else if (s1.charAt(i1)=='\n') {}
          else if ((s2.trim().equals("│"))&&(m1==1)) {
          if (k==列数-1) {
             k5=0;
               model.addRow(记录);
               k=0;
               m1=0;
                记录[k]="";
          }
          else {
          k++;
if (k<列数) 记录[k]="";
     }
     }
     else if (s2.trim().equals("│")) {
m1=1;
k=0;
记录[0]="";
     }
     else if ((k<列数)&&(m1==1)){
          try{
          记录[k]=记录[k]+s2;
      } catch (Exception e1) {
      }
     }
     }
try {
  main1.driver1();
         con1=main1.getConn();
           sta4 = con1.createStatement(
                   ResultSet.TYPE_SCROLL_INSENSITIVE,
                         ResultSet.CONCUR_UPDATABLE);
          s1="delete from "+表名;
          sta4.executeUpdate(s1);
         sta4.close();
         con1.close();
     }catch(SQLException e1){
     }
try{
     main1.driver1();
         con1=main1.getConn();
      sta4 = con1.createStatement(
                 ResultSet.TYPE_SCROLL_INSENSITIVE,
                       ResultSet.CONCUR_UPDATABLE);
        for (int i=当前记录号;i<model.getRowCount();i++){
            s1="insert into "+表名+" (";
            for (int k1=0;k1<列名[1].length;k1++)
            s1=s1+列名[1][k1]+",";
            s1=s1.substring(0,s1.length()-1)+" ) values (";
        for (int j=0;j<列名[1].length;j++){
         if (类型1.lastIndexOf(","+列数据类型[j]+",")>=0){
          if (model.getValueAt(i,j)==null) s1=s1+"0";
          else s1=s1+model.getValueAt(i,j).toString().trim();
         }
         else{
          if (model.getValueAt(i,j)==null) s1=s1+" ";
         else s1=s1+"'"+model.getValueAt(i,j).toString().trim()+"'";
            }
          if (j!=列名[1].length-1) s1=s1+",";
        }
         s1=s1+")";
          sta4.executeUpdate(s1);
        }
        sta4.close();
        con1.close();
   }
      catch(SQLException e1)
      {
     JOptionPane.showMessageDialog( null, "操作出错，请检查数据表名是否重复，录入语句是否正确！"+s1);
      }
     }
     });
     if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",2,")>=0)){
          从pdf.setBounds(按钮左边距,窗口高-80,按钮宽,20);
          panel.add(从pdf);
          按钮左边距=按钮左边距+按钮宽;
     }

     JButton exitButton = new JButton(按钮集[3]);
     exitButton.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
  if ((sw[2].length()>0)&&(sw[3].length()>0)&&(sw[4].length()>0))
   WorkflowDrivek1.means(sw);
frame.setVisible(false);
frame.dispose();
}
     });
     if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",3,")>=0)){
          exitButton.setBounds(按钮左边距,窗口高-80,按钮宽,20);
          panel.add(exitButton);
          按钮左边距=按钮左边距+按钮宽;
     }
     frame.add(panel);
  frame.setVisible(true); // 显示窗体
}
}

版本2
46.源码46，部件程序，修改式导出到office文件，包括word、excel、pdf文件数据导出部件。
     import java.awt.*;
     import java.awt.event.*;
     import java.io.*;
     import java.io.File.*;
     import javax.swing.*;
     import javax.swing.table.*;
     import java.sql.*;
     import com.itextpdf.text.Document;
     import com.itextpdf.text.DocumentException;
     import com.itextpdf.text.Font;
     import com.itextpdf.text.Paragraph;
     import com.itextpdf.text.pdf.BaseFont;
     import com.itextpdf.text.pdf.PdfWriter;
     import org.apache.poi.hssf.usermodel.HSSFCell;
     import org.apache.poi.hssf.usermodel.HSSFRichTextString;
     import org.apache.poi.hssf.usermodel.HSSFRow;
     import org.apache.poi.hssf.usermodel.HSSFSheet;
     import org.apache.poi.hssf.usermodel.HSSFWorkbook;
     import org.apache.poi.hwpf.extractor.WordExtractor;
     import org.apache.poi.ss.usermodel.Sheet;
     import org.pdfbox.pdfparser.PDFParser;
     import org.pdfbox.pdmodel.PDDocument;
     import org.pdfbox.util.PDFTextStripper;
      import com.jacob.activeX.ActiveXComponent;
     import com.jacob.com.Dispatch;
     import com.jacob.com.Variant;

/**
* 程序文件名：dataTransfer6.java 作者：程学先功能：修改式导出到office文件，包括word、excel、pdf文件。
* 原目的文件内容保留，当前表数据导出到指定文件中，如果关键字值和已有数据相同则更改已有数据否则添加到原文件尾部，如果原文件不存在将抛出异常。
* 目的表与源表数据类型、数据宽度应当对应相容，符合本程序中“类型对照表"设置的对应关系。完成日期：2013年1月22日
*/

public class dataTransfer6 extends JFrame {
static dataTransfer6 frame = new dataTransfer6();
private static JTable table;
static Connection con1;
static String url;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta4;
static ResultSet rs;
static int variabl2483 = 800, variabl2503 = 600;
static int variabl2651;
static int variabl26511;
static String[][] variabl2517;
static String[] variabl25171;
static int[] variabl1065;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int variabl1853 = 0, variabl18531 = 0;
static String[][] variabl2197;
static String[] variabl21971;
static DefaultTableModel model;
static String variabl2603;
static String variabl1873;
static String variabl1679, variabl1463;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl1735;
static String variabl2253;
static String[] variabl2053, variabl20531;
static int[] variabl1287, variabl12871;
private static Connection cont4;
private static Statement stat4;
private static ResultSetMetaData rsmdt4;
private static String[] variabl25170;
private static String variabl2309 = "";
private static int variabl26510;
private static String variabl2049;
static String s1 = "", s2 = "", s3 = "";
static String s4 = "                                                  ";
static char x1 = 10, x2 = 13, x3 = '"', x4 = ',';
private static String[][] variabl1601 = {
   { "java", "string", "string", "string", "int", "int", "string",
     "string", "string", "string", "boolean", "byte", "short",
     "long", "float", "int", "double", "float", "float",
     "byte[]" },
   { "sqlserver", "char", "nchar", "nvarchar", "int", "float",
     "datetime", "datetime", "text", "ntext", "bit", "tinyint",
     "smallint", "bigint", "numeric", "integer", "double",
     "money", "real", "image" },
   { "vfp", "c", "c", "c", "i", "n", "d", "t", "m", "m", "l", "i",
     "i", "i", "n", "i", "n", "b", "y", "g" },
   { "access", "text", "text", "text", "integer", "integer", "date",
     "date", "memo", "memo", "logical", "integer", "integer",
     "integer", "float", "integer", "float", "float", "float",
     "general" },
   { "oracle", "char", "char", "char", "number", "number", "date",
     "date", "long", "long", "char", "raw", "number", "number",
     "number", "number", "number", "number", "number", "blob" },
   { "mysql", "char", "char", "varchar", "int", "float", "date",
     "datetime", "text", "text", "tinyint", "tinyint",
     "smallint", "bigint", "float", "integer", "double",
     "float", "float", "blob" } };
static int variabl2851 = 0, variabl2339 = 0;

public static void means(String[] parameter) {
  frame = new dataTransfer6();
  variabl2483 = 800;
  variabl2503 = 600;
  variabl1853 = 0;
  variabl18531 = 0;
  s1 = "";
  s2 = "";
  s3 = "";
  x1 = 10;
  x2 = 13;
  x3 = '"';
  x4 = ',';
  variabl1601[0][0] = "java";
  variabl1601[0][1] = "string";
  variabl1601[0][2] = "string";
  variabl1601[0][3] = "string";
  variabl1601[0][4] = "int";
  variabl1601[0][5] = "int";
  variabl1601[0][6] = "string";
  variabl1601[0][7] = "string";
  variabl1601[0][8] = "string";
  variabl1601[0][9] = "string";
  variabl1601[0][10] = "boolean";
  variabl1601[0][11] = "byte";
  variabl1601[0][12] = "short";
  variabl1601[0][13] = "long";
  variabl1601[0][14] = "float";
  variabl1601[0][15] = "int";
  variabl1601[0][16] = "double";
  variabl1601[0][17] = "float";
  variabl1601[0][18] = "float";
  variabl1601[0][19] = "byte[]";
  variabl1601[1][0] = "sqlserver";
  variabl1601[1][1] = "char";
  variabl1601[1][2] = "nchar";
  variabl1601[1][3] = "nvarchar";
  variabl1601[1][4] = "int";
  variabl1601[1][5] = "float";
  variabl1601[1][6] = "datetime";
  variabl1601[1][7] = "datetime";
  variabl1601[1][8] = "text";
  variabl1601[1][9] = "ntext";
  variabl1601[1][10] = "bit";
  variabl1601[1][11] = "tinyint";
  variabl1601[1][12] = "smallint";
  variabl1601[1][13] = "bigint";
  variabl1601[1][14] = "numeric";
  variabl1601[1][15] = "integer";
  variabl1601[1][16] = "double";
  variabl1601[1][17] = "money";
  variabl1601[1][18] = "real";
  variabl1601[1][19] = "image";
  variabl1601[2][0] = "vfp";
  variabl1601[2][1] = "c";
  variabl1601[2][2] = "c";
  variabl1601[2][3] = "c";
  variabl1601[2][4] = "i";
  variabl1601[2][5] = "n";
  variabl1601[2][6] = "d";
  variabl1601[2][7] = "t";
  variabl1601[2][8] = "m";
  variabl1601[2][9] = "m";
  variabl1601[2][10] = "l";
  variabl1601[2][11] = "i";
  variabl1601[2][12] = "i";
  variabl1601[2][13] = "i";
  variabl1601[2][14] = "n";
  variabl1601[2][15] = "i";
  variabl1601[2][16] = "n";
  variabl1601[2][17] = "b";
  variabl1601[2][18] = "y";
  variabl1601[2][19] = "g";
  variabl1601[3][0] = "access";
  variabl1601[3][1] = "text";
  variabl1601[3][2] = "text";
  variabl1601[3][3] = "text";
  variabl1601[3][4] = "integer";
  variabl1601[3][5] = "integer";
  variabl1601[3][6] = "date";
  variabl1601[3][7] = "date";
  variabl1601[3][8] = "memo";
  variabl1601[3][9] = "memo";
  variabl1601[3][10] = "logical";
  variabl1601[3][11] = "integer";
  variabl1601[3][12] = "integer";
  variabl1601[3][13] = "integer";
  variabl1601[3][14] = "float";
  variabl1601[3][15] = "integer";
  variabl1601[3][16] = "float";
  variabl1601[3][17] = "float";
  variabl1601[3][18] = "float";
  variabl1601[3][19] = "general";
  variabl1601[4][0] = "oracle";
  variabl1601[4][1] = "char";
  variabl1601[4][2] = "char";
  variabl1601[4][3] = "char";
  variabl1601[4][4] = "number";
  variabl1601[4][5] = "number";
  variabl1601[4][6] = "date";
  variabl1601[4][7] = "date";
  variabl1601[4][8] = "long";
  variabl1601[4][9] = "long";
  variabl1601[4][10] = "char";
  variabl1601[4][11] = "raw";
  variabl1601[4][12] = "number";
  variabl1601[4][13] = "number";
  variabl1601[4][14] = "number";
  variabl1601[4][15] = "number";
  variabl1601[4][16] = "number";
  variabl1601[4][17] = "number";
  variabl1601[4][18] = "number";
  variabl1601[4][19] = "blob";
  variabl1601[5][0] = "mysql";
  variabl1601[5][1] = "char";
  variabl1601[5][2] = "char";
  variabl1601[5][3] = "varchar";
  variabl1601[5][4] = "int";
  variabl1601[5][5] = "float";
  variabl1601[5][6] = "date";
  variabl1601[5][7] = "datetime";
  variabl1601[5][8] = "text";
  variabl1601[5][9] = "text";
  variabl1601[5][10] = "tinyint";
  variabl1601[5][11] = "tinyint";
  variabl1601[5][12] = "smallint";
  variabl1601[5][13] = "bigint";
  variabl1601[5][14] = "float";
  variabl1601[5][15] = "integer";
  variabl1601[5][16] = "double";
  variabl1601[5][17] = "float";
  variabl1601[5][18] = "float";
  variabl1601[5][19] = "blob";
  variabl2049 = "";
  File file = new File(".\\com\\iText-5.0.5.jar");
  if (!file.exists()) {
   JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中！");
   return;
  }
  file = new File(".\\com\\jacob.jar");
  if (!file.exists()) {
   JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中！");
   return;
  }
  file = new File(".\\com\\poi-3.8-20120326.jar");
  if (!file.exists()) {
   JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中！");
   return;
  }
  file = new File(".\\com\\PDFBox-0.7.3.jar");
  if (!file.exists()) {
   JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中！");
   return;
  }
  variabl2603 = parameter[4];
  variabl1735 = parameter[8];
  variabl1463 = parameter[18];
  variabl1679 = parameter[2];
  String[] variabl240501 = { "导出到word", "导出到excel", "导出到PDF", "退出" };
  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) {
  }
  variabl2253 = parameter[6];
  String variabl1633 = parameter[19].trim();
  if ((variabl1633.length() > 0)
    && (variabl1633.substring(variabl1633.length() - 1).equals(",")))
   variabl1633 = variabl1633.substring(0, variabl1633.length() - 1);
  String variabl2429 = parameter[0];
  String[] l3 = variabl1633.split(",");
  variabl1873 = "";
  String[] t1;
  int b = 0, c = 0;
  if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) {
   t1 = variabl2429.split(",");
   for (int i = 0; i < t1.length; i++)
    if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0)
     variabl1873 = t1[i];
  }
  String[] l1;
  if (variabl1735.length() > 0) {
   l1 = variabl1735.split(",");
   int[] l2 = new int[l1.length];
   for (int i = 0; i < l1.length; i++) {
    l2[i] = Integer.valueOf(l1[i]);
   }
   variabl2651 = l1.length;
   variabl2517 = new String[2][variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = l3[l2[i]];
    variabl2517[1][i] = variabl2517[0][i];
   }
  } else {
   variabl2651 = l3.length;
   variabl2517 = new String[2][variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = l3[i];
    variabl2517[1][i] = variabl2517[0][i];
   }
  }
  s1 = "";
  for (int i = 0; i < variabl2651; i++)
   s1 = s1 + variabl2517[0][i] + ",";
  s1 = s1.substring(0, s1.length() - 1);
  try {
   con1 = main1.getConn();
   sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
     ResultSet.CONCUR_UPDATABLE);

   s1 = "select " + s1 + " from " + variabl2603;
   数据表查询结构002();
   if (variabl2049.length() > 0)
    s1 = s1 + " where " + variabl2049;
   ResultSet rs = sta4.executeQuery(s1);
   rsmd4 = rs.getMetaData();
   variabl2651 = rsmd4.getColumnCount();
   variabl2517 = new String[2][variabl2651];
   variabl1501 = new String[variabl2651];
   variabl1489 = new int[variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = rsmd4.getColumnName(i + 1);
    variabl2517[1][i] = variabl2517[0][i];
    variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
    variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
    if (variabl1489[i] < variabl2517[0][i].length())
     variabl1489[i] = variabl2517[0][i].length();
    if (variabl1489[i] < variabl2517[1][i].length())
     variabl1489[i] = variabl2517[1][i].length();
    if (variabl1489[i] > 50)
     variabl1489[i] = 50;
   }
   variabl2053 = variabl2253.split(",");
   variabl20531 = new String[variabl2053.length];
   variabl1287 = new int[variabl2053.length];
   variabl12871 = new int[variabl2053.length];
   variabl1913 = new String[variabl2651];
   variabl1169 = new String[variabl2651];
   for (b = 0; b < variabl2651; b++) {
    variabl1913[b] = variabl2517[1][b];
   }
   variabl1853 = 0;
   rs.last();
   variabl1853 = rs.getRow();
   variabl2197 = new String[variabl1853][variabl2651];
   rs.absolute(1);
   c = 0;
   b = 0;
   while (c < variabl1853) {
    rs.absolute(c + 1);
    while (b < variabl2651) {
     variabl2197[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close();
   sta4.close();
   con1.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "读取数据出错！");
  }
  if (variabl1873.length() > 0) {
   try {
    con1 = main1.getConn();
    sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select * from " + variabl1873;
    rs = sta4.executeQuery(s1);
    String s4 = "";
    String s5 = "";
    b = 1;
    while (rs.absolute(b)) {
     b++;
     s4 = rs.getString(1).trim();
     s5 = rs.getString(2).trim();
     for (int j = 0; j < variabl2651; j++) {
      if (variabl2517[0][j].trim()
        .equalsIgnoreCase(s4.trim())) {
       variabl2517[1][j] = s5;
       break;
      }
     }
    }
    rs.close();
    con1.close();
    sta4.close();
   } catch (SQLException e) {
    JOptionPane.showMessageDialog(null, "连接数据库出错！");
   }
  }
  for (int i = 0; i < variabl2651; i++) {
   for (int j = 0; j < variabl2053.length; j++)
    if (variabl2053[j].trim().equalsIgnoreCase(
      variabl2517[0][i].trim())) {
     variabl20531[j] = variabl2517[1][i];
     variabl1287[j] = i;
    }
  }
  frame.setTitle("数据修改式导出到office文件部件。根据关键字查出关键字相同记录用当前表中数据替代。作者：程学先");
  frame.setBounds(10, 10, variabl2483, variabl2503);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.setLayout(null);
  final JPanel panel = new JPanel(false);
  panel.setLayout(null);
  panel.setBounds(10, 10, variabl2483, variabl2503);
  final JScrollPane scrollPane = new JScrollPane();
  scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 100);
  panel.add(scrollPane);
  model = new DefaultTableModel(variabl2197, variabl2517[1]);
  table = new JTable(model);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
  for (int i = 0; i < variabl2651; i++) {
   TableColumn tc = table.getColumn(variabl2517[1][i]);
   tc.setPreferredWidth(variabl1489[i] * 14);
   tc.setMaxWidth(variabl1489[i] * 14);
   tc.sizeWidthToFit();
  }
  scrollPane.setViewportView(table);
  variabl2339 = (variabl2483 - 60) / variabl2851;
  int variabl1423 = 30;

  JButton variabl1439 = new JButton(variabl2405[0]);
  variabl1439.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    if (variabl1463.length() == 0) {
     variabl1463 = JOptionPane.showInputDialog(
       "请输入导出文件完整路径例如：F:\\java.doc", "");
     return;
    }
    int p1 = 0, p2 = 0;
    if (variabl1463.lastIndexOf(".doc") < 0) {
     p1 = variabl1463.lastIndexOf(".");
     p2 = variabl1463.lastIndexOf("\\\\");
     if (p2 > p1) {
      variabl1463 = variabl1463 + ".doc";
      variabl1463 = variabl1463.replace("\\.", "\\.\\.");
     } else {
      variabl1463 = variabl1463.substring(0, p1) + ".doc";
     }
    }
    try {
     FileInputStream in = new FileInputStream(new File(
       variabl1463));
     WordExtractor extractor = null;
     extractor = new WordExtractor(in);
     String variabl2581 = extractor.getText();
     int m1 = 0;
     ;
     String[] variabl2615 = new String[variabl2651];
     int k = 0;
     int k2 = 0, k5 = 0;
     variabl2615[k] = "";
     for (int i = 0; i < variabl2581.length(); i++) {
      if (variabl2581.charAt(i) == '\r') {
       s3 = "";
       for (int k3 = 0; k3 < variabl2053.length; k3++)
        s3 = s3 + variabl2615[variabl1287[k3]].trim();
       k2 = 0;
       for (int j1 = 0; j1 < model.getRowCount(); j1++) {
        s2 = "";
        for (int k4 = 0; k4 < variabl2053.length; k4++) {
         s2 = s2
           + model.getValueAt(j1,
             variabl1287[k4]).toString()
             .trim();
        }
        if (s3.trim().equalsIgnoreCase(s2.trim())) {
         k2 = j1;
         k5 = 1;
         break;
        }
       }
       if (k5 == 0) {
        model.addRow(variabl2615);
        variabl1853++;
       }
       k5 = 0;
       variabl2615[0] = "";
       k = 0;
       m1 = 1;
       if ((i < variabl2581.length() - 2)
         && (variabl2581.charAt(i + 2) == '\r'))
        break;
      } else if (variabl2581.charAt(i) == '\n') {
      } else if ((byte) (variabl2581.charAt(i)) == 9) {
       k++;
       m1 = 0;
       if (k < variabl2651)
        variabl2615[k] = "";
      } else if (k < variabl2651) {
       variabl2615[k] = variabl2615[k]
         + variabl2581.charAt(i);
      }
     }
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null,
       "读取数据出错，可能是原文件中数据结构与数据表不同，不能作修改式导出！");
    }
    try {
     ActiveXComponent word = new ActiveXComponent(
       "Word.Application");
     Dispatch documents = word.getProperty("Documents")
       .toDispatch();
     try {
      Dispatch doc = Dispatch.call(documents, "Add")
        .toDispatch();
      Dispatch selection = Dispatch.get(word, "Selection")
        .toDispatch();
      Dispatch.call(selection, "HomeKey");
      Dispatch tables = Dispatch.get(doc, "Tables")
        .toDispatch();
      Dispatch range = Dispatch.get(selection, "Range")
        .toDispatch();
      Dispatch newTable = Dispatch.call(tables, "Add", range,
        new Variant(variabl1853),
        new Variant(variabl2651)).toDispatch();
      for (int i1 = 0; i1 < model.getRowCount(); i1++) {
       for (int j = 0; j < variabl2651; j++) {
        Dispatch table = Dispatch.call(tables, "Item",
          new Variant(1)).toDispatch();
        Dispatch cell = Dispatch
          .call(table, "Cell",
            new Variant(i1 + 1),
            new Variant(j + 1))
          .toDispatch();
        Dispatch.call(cell, "Select");
        s1 = "" + model.getValueAt(i1, j);
        Dispatch.put(selection, "Text", s1);
       }
      }
      Dispatch.call(
        (Dispatch) Dispatch.call(word, "WordBasic")
          .getDispatch(), "FileSaveAs",
        variabl1463);
     } catch (Exception e1) {
      e1.printStackTrace();
     } finally {
      Dispatch.call(word, "Quit");
     }
    } catch (Exception e1) {
     e1.printStackTrace();
    }
    return;
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
   variabl1439.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1439);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl1141 = new JButton(variabl2405[1]);
  variabl1141.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    if (variabl1463.length() == 0) {
     variabl1463 = JOptionPane.showInputDialog(
       "请输入导出文件完整路径例如：F:\\java.xls", "");
     return;
    }
    int p1 = 0, p2 = 0;
    if (variabl1463.lastIndexOf(".xls") < 0) {
     p1 = variabl1463.lastIndexOf(".");
     p2 = variabl1463.lastIndexOf("\\\\");
     if (p2 > p1) {
      variabl1463 = variabl1463 + ".xls";
      variabl1463 = variabl1463.replace("\\.", "\\.\\.");
     } else {
      variabl1463 = variabl1463.substring(0, p1) + ".xls";
     }
    }
    InputStream is = null;
    HSSFWorkbook wbWorkbook = null;
    try {
     is = new FileInputStream(variabl1463);
     wbWorkbook = new HSSFWorkbook(is);
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
     JOptionPane.showMessageDialog(null, "读取文件失败，请检查路径是否正确！",
       "错误", JOptionPane.INFORMATION_MESSAGE);
    } catch (IOException e2) {
     e2.printStackTrace();
    }
    HSSFSheet sheet = wbWorkbook.getSheetAt(0);
    int lastRowNum = sheet.getLastRowNum();
    int variabl1157 = sheet.getPhysicalNumberOfRows();
    HSSFRow row = sheet.getRow(1);
    int variabl1185 = row.getPhysicalNumberOfCells();
    if (variabl1185 != variabl2651)
     JOptionPane.showMessageDialog(null,
       "原文件中数据结构与数据表不同，不能作修改式导出！");
    String[] val;
    int k2 = 0, k5 = 0;
    String value = "";
    for (int i = 0; i < variabl1157; i++) {
     row = sheet.getRow(i);
     if (row != null) {
      for (int j = 0; j < variabl1185; j++) {
       HSSFCell cell = row.getCell(j);
       if (cell != null) {
        switch (cell.getCellType()) {
        case HSSFCell.CELL_TYPE_FORMULA:
         break;
        case HSSFCell.CELL_TYPE_NUMERIC:
         value += cell.getNumericCellValue() + ",";
         break;
        case HSSFCell.CELL_TYPE_STRING:
         value += cell.getStringCellValue() + ",";
         break;
        default:
         value += "0";
         break;
        }
       }
      }
      val = value.split(",");
      s3 = "";
      for (int k3 = 0; k3 < variabl2053.length; k3++)
       s3 = s3 + val[variabl1287[k3]].trim();
      k2 = 0;
      for (int j1 = 0; j1 < model.getRowCount(); j1++) {
       s2 = "";
       for (int k4 = 0; k4 < variabl2053.length; k4++)
        s2 = s2
          + model.getValueAt(j1, variabl1287[k4])
            .toString().trim();
       if (s3.trim().equalsIgnoreCase(s2.trim())) {
        k2 = j1;
        k5 = 1;
        break;
       }
      }
      if (k5 == 0) {
       model.addRow(val);
       variabl1853++;
      }
      k5 = 0;
      value = "";
     }
    }
    HSSFWorkbook book = new HSSFWorkbook();
    sheet = book.createSheet(variabl2603);
    HSSFRow header = sheet.createRow(0);
    int colCount = variabl2651;
    for (int i = 0; i < variabl2651; i++) {
     HSSFCell cell = header.createCell(i);
     cell.setCellValue(new HSSFRichTextString(variabl1913[i]));
    }
    for (int j = 0; j < model.getRowCount(); j++) {
     row = sheet.createRow(j);
     for (int i = 0; i < colCount; i++) {
      HSSFCell cell = row.createCell(i);
      s1 = "" + model.getValueAt(j, i);
      cell.setCellValue(new HSSFRichTextString(s1));
     }
    }
    try {
     FileOutputStream fileO = new FileOutputStream(variabl1463);
     book.write(fileO);
     fileO.close();
    } catch (Exception e1) {
     e1.printStackTrace();
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
   variabl1141.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1141);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl2095 = new JButton(variabl2405[2]);
  variabl2095.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    if (variabl1463.length() == 0) {
     variabl1463 = JOptionPane.showInputDialog(
       "请输入导出文件完整路径例如：F:\\java.pdf", "");
     return;
    }
    int p1 = 0, p2 = 0;
    if (variabl1463.lastIndexOf(".pdf") < 0) {
     p1 = variabl1463.lastIndexOf(".");
     p2 = variabl1463.lastIndexOf("\\\\");
     if (p2 > p1) {
      variabl1463 = variabl1463 + ".pdf";
      variabl1463 = variabl1463.replace("\\.", "\\.\\.");
     } else {
      variabl1463 = variabl1463.substring(0, p1) + ".pdf";
     }
    }
    try {
     FileInputStream in = new FileInputStream(variabl1463);
     PDFParser parser = new PDFParser(in);
     parser.parse();
     PDDocument pdfdocument = parser.getPDDocument();
     PDFTextStripper stripper = new PDFTextStripper();
     s1 = stripper.getText(pdfdocument);
     in.close();
    } catch (Exception e1) {
     e1.printStackTrace();
    }
    String[] variabl2615 = new String[variabl2651];
    String s4 = "";
    int k = 0, m1 = 0, k2 = 0, k5 = 0;
    variabl2615[0] = "";
    int l1 = s1.length();
    for (int i1 = 0; i1 < l1; i1++) {
     s2 = s1.substring(i1, i1 + 1);
     if (s1.charAt(i1) == '\r') {
     } else if (s1.charAt(i1) == '\n') {
     } else if ((s2.trim().equals("│")) && (m1 == 1)) {
      if (k == variabl2651 - 1) {
       s3 = "";
       for (int k3 = 0; k3 < variabl2053.length; k3++)
        s3 = s3 + variabl2615[variabl1287[k3]].trim();
       k2 = 0;
       for (int j1 = 0; j1 < model.getRowCount(); j1++) {
        s4 = "";
        for (int k4 = 0; k4 < variabl2053.length; k4++)
         s4 = s4
           + model.getValueAt(j1,
             variabl1287[k4]).toString()
             .trim();
        if (s3.trim().equalsIgnoreCase(s4.trim())) {
         k2 = j1;
         k5 = 1;
         break;
        }
       }
       if (k5 == 0) {
        model.addRow(variabl2615);
        variabl1853++;
       }
       k5 = 0;
       k = 0;
       m1 = 0;
       variabl2615[k] = "";
      } else {
       k++;
       if (k < variabl2651)
        variabl2615[k] = "";
      }
     } else if (s2.trim().equals("│")) {
      m1 = 1;
      k = 0;
      variabl2615[0] = "";
     } else if ((k < variabl2651) && (m1 == 1)) {
      try {
       variabl2615[k] = variabl2615[k] + s2;
      } catch (Exception e1) {
      }
     }
    }
    File file = new File(variabl1463);
    if (file.exists()) {
     file.delete();
    }
    Document document = new Document();
    try {
     PdfWriter.getInstance(document, new FileOutputStream(
       variabl1463));
     document.open();
     BaseFont bfComic = BaseFont.createFont(
       "c:\\windows\\fonts\\SIMFANG.TTF",
       BaseFont.IDENTITY_H, BaseFont.NOT_EMBEDDED);
     Font font = new Font(bfComic, 9);
     s1 = "┌";
     for (int j = 0; j < variabl2651; j++) {
      for (int k0 = 0; k0 < variabl1489[j]; k0++)
       s1 = s1 + "─";
      if (j != variabl2651 - 1)
       s1 = s1 + "┬";
     }
     s1 = s1 + "┐";
     document.add(new Paragraph(s1, font));
     int variabl18532 = model.getRowCount();
     s4 = "";
     String s5 = "";
     float lengtg1 = 0;
     for (int i = 0; i < variabl18532; i++) {
      s1 = "│";
      for (int j = 0; j < variabl2197[0].length; j++) {
       if (model.getValueAt(i, j) == null)
        s4 = " ";
       else
        s4 = model.getValueAt(i, j).toString().trim();
       s3 = "";
       lengtg1 = 0;
       for (int j1 = 0; j1 < s4.length(); j1++) {
        s5 = s4.substring(j1, j1 + 1);
        s1 = s1 + s5;
        if (s5.compareTo("z") < 0) {
         if (s5.compareTo("0") < 0)
          lengtg1 = lengtg1 + 0.51f;
         else
          lengtg1 = lengtg1 + 0.51f;
        } else
         lengtg1 = lengtg1 + 1;
       }
       while (lengtg1 < variabl1489[j]) {
        s1 = s1 + " ";
        lengtg1 = lengtg1 + 0.51f;
       }
       s1 = s1 + "│";
       lengtg1 = 0;
      }
      document.add(new Paragraph(s1, font));
      if (i < variabl18532 - 1) {
       s1 = "├";
       for (int j = 0; j < variabl2651; j++) {
        for (int k0 = 0; k0 < variabl1489[j]; k0++)
         s1 = s1 + "─";
        if (j != variabl2651 - 1)
         s1 = s1 + "┼";
       }
       s1 = s1 + "┤";
       document.add(new Paragraph(s1, font));
      } else {
       s1 = "└";
       for (int j = 0; j < variabl2651; j++) {
        for (int k0 = 0; k0 < variabl1489[j]; k0++)
         s1 = s1 + "─";
        if (j != variabl2651 - 1)
         s1 = s1 + "┴";
       }
       s1 = s1 + "┘";
       document.add(new Paragraph(s1, font));
      }
     }
    } catch (DocumentException de) {
     System.err.println(de.getMessage());
    } catch (IOException ioe) {
     System.err.println(ioe.getMessage());
    }
    document.close();
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
   variabl2095.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl2095);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton exitButton = new JButton(variabl2405[3]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    frame.setVisible(false);
    frame.dispose();
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
   exitButton
     .setBounds(variabl1423, variabl2503 - 80, variabl2339, 20);
   panel.add(exitButton);
   variabl1423 = variabl1423 + variabl2339;
  }
  frame.add(panel);
  frame.setVisible(true);
}

static void variabl1005(String variabl1103) {
  try {
   cont4 = main1.getConn();
   stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
     ResultSet.CONCUR_UPDATABLE);
   String s1 = "select * from " + variabl1103;
   rs = stat4.executeQuery(s1);
   rsmdt4 = rs.getMetaData();
   variabl26510 = rsmdt4.getColumnCount();
   variabl25170 = new String[variabl26510];
   for (int i = 0; i < variabl26510; i++) {
    variabl25170[i] = rsmdt4.getColumnName(i + 1);
   }
   rs.close();
   stat4.close();
   cont4.close();
  } catch (SQLException e1) {
   JOptionPane.showMessageDialog(null, "读取数据表结构出错！");
  }
  variabl2309 = "";
  int b0 = 0;
  while (b0 < variabl2517.length) {
   if (b0 == 0)
    variabl2309 = variabl25170[b0];
   else
    variabl2309 = variabl2309 + "," + variabl25170[b0];
   b0++;
  }
}

static void 数据表查询结构002() {
  String[] t11 = variabl2603.split(",");
  String variabl23090 = "";
  variabl2049 = "";
  if (t11.length > 1) {
   for (int i = 0; i < t11.length; i++) {
    variabl1005(t11[i]);
    for (int j = 0; j < variabl25170.length; j++)
     if (("," + variabl23090 + ",").indexOf(","
       + variabl25170[j] + ",") >= 0) {
      if (variabl2049.length() == 0)
       variabl2049 = t11[i - 1] + "." + variabl25170[j]
         + "=" + t11[i] + "." + variabl25170[j];
      else
       variabl2049 = variabl2049 + " and " + t11[i - 1]
         + "." + variabl25170[j] + "=" + t11[i]
         + "." + variabl25170[j];
     }
    if (variabl23090.length() == 0)
     variabl23090 = variabl2309;
    else
     variabl23090 = variabl23090 + "," + variabl2309;
   }
  }
}
}
47.源码47，部件程序，从纯文本文件、XML文件或其他数据表覆盖式导入数据到当前表数据导入部件。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
* 程序文件名：dataTransfer7.java 作者：程学先功能：从纯文本文件、XML文件或其他数据表覆盖式导入数据到当前表。
* 如果从数据表导入，当前表作为目的表必须存在且必须与源表数据类型、数据宽度对应相容，符合本程序中“类型对照表"设置的对应关系。
* 完成日期：2013年1月22日被调用语句：dataTransfer7.means(parameter) 必须提供的参数：目的数据“表名”。
* 应当提供的参数：“导入文件名”、“源表名”。二选一。可选参数：“字段号表”、“要求按钮号表”、源数据库“DBMS名称”、源数据库“ODBC数据源名称”。
*/

public class dataTransfer7 extends JFrame {
static dataTransfer7 frame = new dataTransfer7();
private static JTable table;
static Connection con;
static Connection con1;
static String url;
static String variabl10911;
static ResultSetMetaData rsmd3;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta3;
static Statement sta4;
static ResultSet rs;
static int variabl2483 = 800, variabl2503 = 600;
static int variabl2651;
static int variabl26511;
static String[][] variabl2517;
static String[] variabl25171;
static int[] variabl1065;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int[] variabl1119, variabl1125;
static int variabl1853 = 0, variabl18531 = 0;
static String[][] variabl2197;
static String[][] variabl21971;
static DefaultTableModel model;
static String variabl2603;
static String variabl2429;
static String variabl1873;
static String variabl1625, variabl1339;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl12491;
static String variabl1735;
public static String[] sw = new String[11];
static String s1 = "", s2 = "", s3 = "";
static String s6 = "                                                  ";
static char x1 = 10, x2 = 13, x3 = '"', x4 = ',';
private static String[][] variabl1601 = {
   { "java", "string", "string", "string", "int", "int", "string",
     "string", "string", "string", "boolean", "byte", "short",
     "long", "float", "int", "double", "float", "float",
     "byte[]" },
   { "sqlserver", "char", "nchar", "nvarchar", "int", "float",
     "datetime", "datetime", "text", "ntext", "bit", "tinyint",
     "smallint", "bigint", "numeric", "integer", "double",
     "money", "real", "image" },
   { "vfp", "c", "c", "c", "i", "n", "d", "t", "m", "m", "l", "i",
     "i", "i", "n", "i", "n", "b", "y", "g" },
   { "access", "text", "text", "text", "integer", "integer", "date",
     "date", "memo", "memo", "logical", "integer", "integer",
     "integer", "float", "integer", "float", "float", "float",
     "general" },
   { "oracle", "char", "char", "char", "number", "number", "date",
     "date", "long", "long", "char", "raw", "number", "number",
     "number", "number", "number", "number", "number", "blob" },
   { "mysql", "char", "char", "varchar", "int", "float", "date",
     "datetime", "text", "text", "tinyint", "tinyint",
     "smallint", "bigint", "float", "integer", "double",
     "float", "float", "blob" } };
static String variabl2511 = main1.variabl2511;
static String variabl25111 = main1.variabl25111;
static int variabl2851 = 0, variabl2339 = 0;

public static void means(String[] parameter) {
  sw = new String[11];
  sw[1] = main1.sw1 + "";
  sw[2] = main1.sw2;
  sw[3] = main1.sw3;
  sw[4] = main1.sw4;
  sw[5] = main1.sw5;
  sw[6] = main1.sw6;
  sw[7] = main1.sw7;
  sw[8] = main1.sw8;
  sw[9] = main1.sw9;
  sw[10] = main1.sw10;
  main1.sw1 = 0;
  main1.sw2 = "";
  main1.sw3 = "";
  main1.sw4 = "";
  main1.sw5 = "";
  main1.sw6 = "";
  main1.sw7 = "";
  main1.sw8 = "";
  main1.sw9 = "";
  main1.sw10 = "";
  frame = new dataTransfer7();
  variabl2483 = 800;
  variabl2503 = 600;
  variabl1853 = 0;
  variabl18531 = 0;
  s1 = "";
  s2 = "";
  s3 = "";
  s6 = "                                                  ";
  x1 = 10;
  x2 = 13;
  x3 = '"';
  x4 = ',';
  variabl2511 = main1.variabl2511;
  variabl25111 = main1.variabl25111;
  variabl1601[0][0] = "java";
  variabl1601[0][1] = "string";
  variabl1601[0][2] = "string";
  variabl1601[0][3] = "string";
  variabl1601[0][4] = "int";
  variabl1601[0][5] = "int";
  variabl1601[0][6] = "string";
  variabl1601[0][7] = "string";
  variabl1601[0][8] = "string";
  variabl1601[0][9] = "string";
  variabl1601[0][10] = "boolean";
  variabl1601[0][11] = "byte";
  variabl1601[0][12] = "short";
  variabl1601[0][13] = "long";
  variabl1601[0][14] = "float";
  variabl1601[0][15] = "int";
  variabl1601[0][16] = "double";
  variabl1601[0][17] = "float";
  variabl1601[0][18] = "float";
  variabl1601[0][19] = "byte[]";
  variabl1601[1][0] = "sqlserver";
  variabl1601[1][1] = "char";
  variabl1601[1][2] = "nchar";
  variabl1601[1][3] = "nvarchar";
  variabl1601[1][4] = "int";
  variabl1601[1][5] = "float";
  variabl1601[1][6] = "datetime";
  variabl1601[1][7] = "datetime";
  variabl1601[1][8] = "text";
  variabl1601[1][9] = "ntext";
  variabl1601[1][10] = "bit";
  variabl1601[1][11] = "tinyint";
  variabl1601[1][12] = "smallint";
  variabl1601[1][13] = "bigint";
  variabl1601[1][14] = "numeric";
  variabl1601[1][15] = "integer";
  variabl1601[1][16] = "double";
  variabl1601[1][17] = "money";
  variabl1601[1][18] = "real";
  variabl1601[1][19] = "image";
  variabl1601[2][0] = "vfp";
  variabl1601[2][1] = "c";
  variabl1601[2][2] = "c";
  variabl1601[2][3] = "c";
  variabl1601[2][4] = "i";
  variabl1601[2][5] = "n";
  variabl1601[2][6] = "d";
  variabl1601[2][7] = "t";
  variabl1601[2][8] = "m";
  variabl1601[2][9] = "m";
  variabl1601[2][10] = "l";
  variabl1601[2][11] = "i";
  variabl1601[2][12] = "i";
  variabl1601[2][13] = "i";
  variabl1601[2][14] = "n";
  variabl1601[2][15] = "i";
  variabl1601[2][16] = "n";
  variabl1601[2][17] = "b";
  variabl1601[2][18] = "y";
  variabl1601[2][19] = "g";
  variabl1601[3][0] = "access";
  variabl1601[3][1] = "text";
  variabl1601[3][2] = "text";
  variabl1601[3][3] = "text";
  variabl1601[3][4] = "integer";
  variabl1601[3][5] = "integer";
  variabl1601[3][6] = "date";
  variabl1601[3][7] = "date";
  variabl1601[3][8] = "memo";
  variabl1601[3][9] = "memo";
  variabl1601[3][10] = "logical";
  variabl1601[3][11] = "integer";
  variabl1601[3][12] = "integer";
  variabl1601[3][13] = "integer";
  variabl1601[3][14] = "float";
  variabl1601[3][15] = "integer";
  variabl1601[3][16] = "float";
  variabl1601[3][17] = "float";
  variabl1601[3][18] = "float";
  variabl1601[3][19] = "general";
  variabl1601[4][0] = "oracle";
  variabl1601[4][1] = "char";
  variabl1601[4][2] = "char";
  variabl1601[4][3] = "char";
  variabl1601[4][4] = "number";
  variabl1601[4][5] = "number";
  variabl1601[4][6] = "date";
  variabl1601[4][7] = "date";
  variabl1601[4][8] = "long";
  variabl1601[4][9] = "long";
  variabl1601[4][10] = "char";
  variabl1601[4][11] = "raw";
  variabl1601[4][12] = "number";
  variabl1601[4][13] = "number";
  variabl1601[4][14] = "number";
  variabl1601[4][15] = "number";
  variabl1601[4][16] = "number";
  variabl1601[4][17] = "number";
  variabl1601[4][18] = "number";
  variabl1601[4][19] = "blob";
  variabl1601[5][0] = "mysql";
  variabl1601[5][1] = "char";
  variabl1601[5][2] = "char";
  variabl1601[5][3] = "varchar";
  variabl1601[5][4] = "int";
  variabl1601[5][5] = "float";
  variabl1601[5][6] = "date";
  variabl1601[5][7] = "datetime";
  variabl1601[5][8] = "text";
  variabl1601[5][9] = "text";
  variabl1601[5][10] = "tinyint";
  variabl1601[5][11] = "tinyint";
  variabl1601[5][12] = "smallint";
  variabl1601[5][13] = "bigint";
  variabl1601[5][14] = "float";
  variabl1601[5][15] = "integer";
  variabl1601[5][16] = "double";
  variabl1601[5][17] = "float";
  variabl1601[5][18] = "float";
  variabl1601[5][19] = "blob";
  variabl2603 = parameter[4];
  variabl1735 = parameter[8];
  variabl1339 = parameter[18];
  variabl1625 = parameter[2];
  String[] variabl240501 = { "从数据表导入", "标准格式导入", "紧缩格式导入", "自定义格式导入",
    "从XML文件导入", "退出" };
  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) {
  }
  variabl12491 = parameter[1];
  variabl10911 = parameter[3];
  if ((variabl12491 == null) || (variabl12491.length() == 0))
   variabl12491 = main1.variabl1275;
  if ((variabl10911 == null) || (variabl10911.length() == 0))
   variabl10911 = main1.variabl1091;
  String variabl1633 = parameter[19].trim();
  if ((variabl1633.length() > 0)
    && (variabl1633.substring(variabl1633.length() - 1).equals(",")))
   variabl1633 = variabl1633.substring(0, variabl1633.length() - 1);
  variabl2429 = parameter[0];
  String[] l3 = variabl1633.split(",");
  variabl1873 = "";
  String[] t1;
  int b = 0, c = 0;
  if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) {
   t1 = variabl2429.split(",");
   for (int i = 0; i < t1.length; i++)
    if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0)
     variabl1873 = t1[i];
  }
  String[] l1;
  if (variabl1735.length() > 0) {
   l1 = variabl1735.split(",");
   int[] l2 = new int[l1.length];
   for (int i = 0; i < l1.length; i++) {
    l2[i] = Integer.valueOf(l1[i]);
   }
   variabl2651 = l1.length;
   variabl2517 = new String[2][variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = l3[l2[i]];
    variabl2517[1][i] = variabl2517[0][i];
   }
  } else {
   variabl2651 = l3.length;
   variabl2517 = new String[2][variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = l3[i];
    variabl2517[1][i] = variabl2517[0][i];
   }
  }
  s1 = "";
  for (int i = 0; i < variabl2651; i++) {
   s1 = s1 + variabl2517[0][i] + ",";
  }
  s1 = s1.substring(0, s1.length() - 1);
  try {
   if (("," + variabl2429).lastIndexOf("," + variabl2603 + ",") >= 0) {
    main1.driver1();
    con1 = main1.getConn();
    sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select " + s1 + " from " + variabl2603;
    if ((sw[3].length() > 0) && (sw[4].length() > 0))
     s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";
   } else {
    main1.driver1();
    con1 = main1.getConn();
    sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    if (variabl1625.length() < 1) {
     JOptionPane
       .showMessageDialog(null, "源、目的数据表都不存在，必须存在其中一个！");
     return;
    }
    s1 = "select * from " + variabl1625;
   }
   ResultSet rs = sta4.executeQuery(s1);
   rsmd4 = rs.getMetaData();
   variabl2651 = rsmd4.getColumnCount();
   variabl2517 = new String[2][variabl2651];
   variabl1501 = new String[variabl2651];
   variabl1489 = new int[variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = rsmd4.getColumnName(i + 1);
    variabl2517[1][i] = variabl2517[0][i];
    variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
    variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
    if (variabl1489[i] < variabl2517[0][i].length())
     variabl1489[i] = variabl2517[0][i].length();
    if (variabl1489[i] < variabl2517[1][i].length())
     variabl1489[i] = variabl2517[1][i].length();
    if (variabl1489[i] > 50)
     variabl1489[i] = 50;
   }
   if (((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0))
     && (variabl12491.trim().length() > 0)) {
    int variabl2111 = 0, variabl21111 = 0;
    for (int i = 0; i < variabl1601.length; i++) {
     if (variabl12491.trim().equals(variabl1601[i][0]))
      variabl21111 = i;
     if (main1.variabl1275.equals(variabl1601[i][0]))
      variabl2111 = i;
    }
    variabl1913 = new String[variabl2651];
    variabl1169 = new String[variabl2651];
    variabl1119 = new int[variabl2651];
    for (b = 0; b < variabl2651; b++) {
     variabl1913[b] = variabl2517[1][b];
     variabl1119[b] = variabl1489[b];
     for (int i = 1; i < variabl1601[0].length; i++) {
      if (variabl1501[b].toLowerCase().trim()
        .equals(variabl1601[variabl2111][i].trim())) {
       variabl1169[b] = variabl1601[variabl21111][i];
       break;
      }
     }
    }
   }
   variabl1853 = 0;
   rs.last();
   variabl1853 = rs.getRow();
   variabl2197 = new String[variabl1853][variabl2651];
   rs.absolute(1);
   c = 0;
   b = 0;
   while (c < variabl1853) {
    rs.absolute(c + 1);
    while (b < variabl2651) {
     variabl2197[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close();
   sta4.close();
   con1.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "读取数据出错！");
  }
  if (variabl1873.length() > 0) {
   try {
    main1.driver1();
    con = main1.getConn();
    sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select * from " + variabl1873;
    rs = sta3.executeQuery(s1);
    String s4 = "";
    String s5 = "";
    b = 1;
    while (rs.absolute(b)) {
     b++;
     s4 = rs.getString(1);
     s5 = rs.getString(2);
     for (int j = 0; j < variabl2651; j++) {
      if (variabl2517[0][j].trim().equals(s4.trim())) {
       variabl2517[1][j] = s5;
       variabl1913[j] = s5;
       break;
      }
     }
    }
    rs.close();
    con.close();
    sta3.close();
   } catch (SQLException e) {
    JOptionPane.showMessageDialog(null, "连接数据库出错！");
   }
  }
  s2 = "";
  for (int i = 0; i < variabl2651; i++) {
   s2 = s2 + variabl2517[1][i] + ",";
  }
  s2 = s2.substring(0, s2.length() - 1);
  frame.setTitle("从文本文件、XML文件或数据库表导入数据库到本地部件。特别注意数据类型、宽度的对应。作者：程学先");
  frame.setBounds(10, 10, variabl2483, variabl2503);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.setLayout(null);
  final JPanel panel = new JPanel(false);
  panel.setLayout(null);
  panel.setBounds(10, 10, variabl2483, variabl2503);
  final JScrollPane scrollPane = new JScrollPane();
  scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 100);
  panel.add(scrollPane);
  model = new DefaultTableModel(variabl2197, variabl2517[1]);
  table = new JTable(model);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
  for (int i = 0; i < variabl2651; i++) {
   TableColumn tc = table.getColumn(variabl2517[1][i]);
   tc.setPreferredWidth(variabl1489[i] * 14);
   tc.setMaxWidth(variabl1489[i] * 14);
   tc.sizeWidthToFit();
  }
  scrollPane.setViewportView(table);
  variabl2339 = (variabl2483 - 60) / variabl2851;
  int variabl1423 = 30;
  for (int i = 0; i < 100; i++)
   s3 = s3 + " ";
  JButton variabl1933 = new JButton(variabl2405[0]);
  variabl1933.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat4;
    Statement stat3;
    try {
     if (("," + variabl2429)
       .lastIndexOf("," + variabl2603 + ",") >= 0) {
      main1.driver1();
      con1 = main1.getConn();
      stat4 = con1.createStatement(
        ResultSet.TYPE_SCROLL_INSENSITIVE,
        ResultSet.CONCUR_UPDATABLE);
      s1 = "select " + s2 + " from " + variabl1625;
      ResultSet rs1 = stat4.executeQuery(s1);
      rs1.last();
      variabl18531 = rs1.getRow();
      variabl25171 = s2.split(",");
      variabl26511 = variabl25171.length;
      variabl21971 = new String[variabl18531][variabl26511];
      rs1.absolute(1);
      int c = 0;
      int b = 0;
      while (c < variabl18531) {
       rs1.absolute(c + 1);
       while (b < variabl2651) {
        variabl21971[c][b] = rs1.getString(b + 1);
        b++;
       }
       c++;
       b = 0;
      }
      rs1.close();
      stat4.close();
      con1.close();
     }
    } catch (SQLException e1) {
    }

    if (("," + variabl2429).lastIndexOf("," + variabl2603 + ",") >= 0) {
     try {
      main1.driver1();
      con = main1.getConn();
      stat3 = con.createStatement(
        ResultSet.TYPE_SCROLL_INSENSITIVE,
        ResultSet.CONCUR_UPDATABLE);
      s1 = "drop table " + variabl2603;
      stat3.executeUpdate(s1);
      stat3.close();
      con.close();
     } catch (SQLException e1) {
     }
    }
    try {
     con = main1.getConn();
     stat3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     s1 = "CREATE TABLE " + variabl2603 + " (";
     for (int i = 0; i < variabl2517[1].length; i++) {
      s1 = s1 + variabl2517[1][i] + " " + variabl1169[i];
      if (variabl2511.lastIndexOf("," + variabl1501[i] + ",") < 0)
       s1 = s1 + "(" + variabl1489[i] + ")";
      if (i != variabl2517[1].length - 1)
       s1 = s1 + ",";
     }
     s1 = s1 + ")";
     stat3.executeUpdate(s1);
     if (("," + variabl2429)
       .lastIndexOf("," + variabl2603 + ",") < 0) {
      variabl18531 = variabl1853;
      variabl26511 = variabl2651;
      variabl25171 = new String[variabl26511];
      variabl21971 = new String[variabl18531][variabl26511];
      for (int b = 0; b < variabl26511; b++) {
       variabl25171[b] = variabl1913[b];
       variabl1489[b] = variabl1119[b];
       variabl1501[b] = variabl1169[b];
      }
      for (int i = 0; i < variabl1853; i++)
       for (int j = 0; j < variabl2651; j++) {
        variabl21971[i][j] = variabl2197[i][j];
       }
     }
     stat3.close();
     con.close();
    } catch (SQLException e1) {
     JOptionPane.showMessageDialog(null,
       "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
    }
    try {
     main1.driver1();
     con = main1.getConn();
     stat3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     for (int i = 0; i < variabl21971.length; i++) {
      s1 = "insert into " + variabl2603 + " (";
      for (int k1 = 0; k1 < variabl2517[1].length; k1++)
       s1 = s1 + variabl2517[1][k1] + ",";
      s1 = s1.substring(0, s1.length() - 1) + " ) values (";
      for (int j = 0; j < variabl2517[1].length; j++) {
       if (variabl25111.lastIndexOf("," + variabl1501[j]
         + ",") >= 0) {
        if (variabl21971[i][j] == null)
         variabl21971[i][j] = "0";
        s1 = s1 + variabl21971[i][j];
       } else {
        if (variabl21971[i][j] == null)
         variabl21971[i][j] = " ";
        s1 = s1 + "'" + variabl21971[i][j] + "'";
       }
       if (j != variabl2517[1].length - 1)
        s1 = s1 + ",";
      }
      s1 = s1 + ")";
      stat3.executeUpdate(s1);
     }
     stat3.close();
     con.close();
    } catch (SQLException e1) {
     JOptionPane.showMessageDialog(null,
       "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
   variabl1933.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1933);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl2225 = new JButton(variabl2405[1]);
  variabl2225.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     main1.driver1();
     con = main1.getConn();
     stat3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     s1 = "delete from " + variabl2603;
     stat3.executeUpdate(s1);
     stat3.close();
     con.close();
    } catch (SQLException e1) {
    }
    try {
     FileReader fs = new FileReader(variabl1339);
     BufferedReader br = new BufferedReader(fs);
     String tempStr = null;
     String[] variabl23691 = new String[variabl2651];
     int k1 = 0, k2 = 0, k5 = 0;
     for (int i1 = 0; (tempStr = br.readLine()) != null; i1++) {
      for (int j = 0; j < variabl2651; j++) {
       variabl23691[j] = tempStr.substring(k1, k1
         + variabl1489[j]);
       k1 = k1 + variabl1489[j];
      }
      try {
       main1.driver1();
       con = main1.getConn();
       stat3 = con.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
       s1 = "insert into " + variabl2603 + " (";
       for (int k3 = 0; k3 < variabl2517[1].length; k3++)
        s1 = s1 + variabl2517[1][k3] + ",";
       s1 = s1.substring(0, s1.length() - 1)
         + " ) values (";
       for (int j = 0; j < variabl2517[1].length; j++) {
        if (variabl25111.lastIndexOf(","
          + variabl1501[j] + ",") >= 0) {
         if (variabl23691[j] == null)
          variabl23691[j] = "0";
         s1 = s1 + variabl23691[j].trim();
        } else {
         if (variabl23691[j] == null)
          variabl23691[j] = " ";
         s1 = s1 + "'" + variabl23691[j].trim()
           + "'";
        }
        if (j != variabl2517[1].length - 1)
         s1 = s1 + ",";
       }
       s1 = s1 + ")";
       stat3.executeUpdate(s1);
       stat3.close();
       con.close();
      } catch (SQLException e1) {
       JOptionPane.showMessageDialog(null,
         "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
      }
      k1 = 0;
     }
     fs.close();
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
    } catch (IOException e2) {
     e2.printStackTrace();
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
   variabl2225.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl2225);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl1891 = new JButton(variabl2405[2]);
  variabl1891.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     main1.driver1();
     con = main1.getConn();
     stat3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     s1 = "delete from " + variabl2603;
     stat3.executeUpdate(s1);
     stat3.close();
     con.close();
    } catch (SQLException e1) {
    }
    try {
     FileReader fs = new FileReader(variabl1339);
     BufferedReader br = new BufferedReader(fs);
     String tempStr = null;
     String[] variabl23691 = new String[variabl2651];
     char x6 = '"';
     for (int i = 0; (tempStr = br.readLine()) != null; i++) {
      variabl23691 = tempStr.split(",");
      for (int j = 0; j < variabl2651; j++) {
       if (variabl23691[j].lastIndexOf("" + x6) >= 0)
        variabl23691[j] = variabl23691[j].substring(1,
          variabl23691[j].length() - 1);
      }
      try {
       main1.driver1();
       con = main1.getConn();
       stat3 = con.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
       s1 = "insert into " + variabl2603 + " (";
       for (int k3 = 0; k3 < variabl2517[1].length; k3++)
        s1 = s1 + variabl2517[1][k3] + ",";
       s1 = s1.substring(0, s1.length() - 1)
         + " ) values (";
       for (int j = 0; j < variabl2517[1].length; j++) {
        if (variabl25111.lastIndexOf(","
          + variabl1501[j] + ",") >= 0) {
         if (variabl23691[j] == null)
          variabl23691[j] = "0";
         s1 = s1 + variabl23691[j].trim();
        } else {
         if (variabl23691[j] == null)
          variabl23691[j] = " ";
         s1 = s1 + "'" + variabl23691[j].trim()
           + "'";
        }
        if (j != variabl2517[1].length - 1)
         s1 = s1 + ",";
       }
       s1 = s1 + ")";
       stat3.executeUpdate(s1);

       stat3.close();
       con.close();
      } catch (SQLException e1) {
       JOptionPane.showMessageDialog(null,
         "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
      }

     }
     fs.close();
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
    } catch (IOException e2) {
     e2.printStackTrace();
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
   variabl1891.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1891);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl1403 = new JButton(variabl2405[3]);
  variabl1403.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     main1.driver1();
     con = main1.getConn();
     stat3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     s1 = "delete from " + variabl2603;
     stat3.executeUpdate(s1);
     stat3.close();
     con.close();
    } catch (SQLException e1) {
    }
    char x1 = 13, x2 = 10;
    try {
     String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符", "");
     FileReader fs = new FileReader(variabl1339);
     BufferedReader br = new BufferedReader(fs);
     String tempStr = null;
     String[] variabl23691 = new String[variabl2651];
     String x6 = "", x7 = null;
     for (int i = 0; (tempStr = br.readLine()) != null; i++) {
      x6 = tempStr;
      while (x6.indexOf("】【") < 0) {
       if ((tempStr = br.readLine()) != null) {
        x6 = x6 + x1 + tempStr;
        i++;
       }
      }
      x6 = x6.substring(0, x6.length() - 2);
      variabl23691 = x6.split(x5);
      x6 = "";
      try {
       main1.driver1();
       con = main1.getConn();
       stat3 = con.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
       s1 = "insert into " + variabl2603 + " (";
       for (int k3 = 0; k3 < variabl2517[1].length; k3++)
        s1 = s1 + variabl2517[1][k3] + ",";
       s1 = s1.substring(0, s1.length() - 1)
         + " ) values (";
       for (int j = 0; j < variabl2517[1].length; j++) {
        if (variabl25111.lastIndexOf(","
          + variabl1501[j] + ",") >= 0) {
         if (variabl23691[j] == null)
          variabl23691[j] = "0";
         s1 = s1 + variabl23691[j].trim();
        } else {
         if (variabl23691[j] == null)
          variabl23691[j] = " ";
         s1 = s1 + "'" + variabl23691[j].trim()
           + "'";
        }
        if (j != variabl2517[1].length - 1)
         s1 = s1 + ",";
       }
       s1 = s1 + ")";
       stat3.executeUpdate(s1);

       stat3.close();
       con.close();
      } catch (SQLException e1) {
       JOptionPane.showMessageDialog(null,
         "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
      }
     }
     fs.close();
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
    } catch (IOException e2) {
     e2.printStackTrace();
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
   variabl1403.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1403);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl1163 = new JButton(variabl2405[4]);
  variabl1163.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     main1.driver1();
     con = main1.getConn();
     stat3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     s1 = "delete from " + variabl2603;
     stat3.executeUpdate(s1);
     stat3.close();
     con.close();
    } catch (SQLException e1) {
    }
    try {
     DocumentBuilderFactory factory = DocumentBuilderFactory
       .newInstance();
     DocumentBuilder db = factory.newDocumentBuilder();
     Document doc = db.parse(new File(variabl1339));
     Element elmtInfo = doc.getDocumentElement();
     NodeList nodes = elmtInfo.getChildNodes();
     String[] variabl25170 = new String[variabl2651];
     String[] variabl2369 = new String[variabl2651];
     String[] variabl23691 = new String[variabl2651];
     int k = 0, k1 = 0;
     for (int i = 0; i < nodes.getLength(); i++) {
      NodeList ns = nodes.item(i).getChildNodes();
      k = 0;
      for (int j2 = 0; j2 < variabl2651; j2++)
       variabl23691[j2] = "";
      k1 = 0;
      for (int j = 0; j < ns.getLength(); j++) {
       Node record = ns.item(j);
       if (record.toString().lastIndexOf("null") > 0) {
        variabl25170[k] = ns
          .item(j)
          .toString()
          .substring(
            1,
            record.toString().lastIndexOf(
              ":"));
        variabl2369[k] = record.getTextContent();
        for (int j2 = 0; j2 < variabl2651; j2++) {
         if (variabl2517[1][j2]
           .lastIndexOf(variabl25170[k]) >= 0) {
          variabl23691[j2] = variabl2369[k];
          break;
         }
        }
        k++;
        k1 = 1;
       }
      }
      if (k1 > 0) {
       try {
        main1.driver1();
        con = main1.getConn();
        stat3 = con.createStatement(
          ResultSet.TYPE_SCROLL_INSENSITIVE,
          ResultSet.CONCUR_UPDATABLE);
        s1 = "insert into " + variabl2603 + " (";
        for (int k3 = 0; k3 < variabl2517[1].length; k3++)
         s1 = s1 + variabl2517[1][k3] + ",";
        s1 = s1.substring(0, s1.length() - 1)
          + " ) values (";
        for (int j = 0; j < variabl2517[1].length; j++) {
         if (variabl25111.lastIndexOf(","
           + variabl1501[j] + ",") >= 0) {
          if (variabl23691[j] == null)
           variabl23691[j] = "0";
          s1 = s1 + variabl23691[j].trim();
         } else {
          if (variabl23691[j] == null)
           variabl23691[j] = " ";
          s1 = s1 + "'" + variabl23691[j].trim()
            + "'";
         }
         if (j != variabl2517[1].length - 1)
          s1 = s1 + ",";
        }
        s1 = s1 + ")";
        stat3.executeUpdate(s1);

        stat3.close();
        con.close();
       } catch (SQLException e1) {
        JOptionPane.showMessageDialog(null,
          "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
       }
      }
     }
    } catch (ParserConfigurationException e1) {
     e1.printStackTrace();
    } catch (SAXException e2) {
     e2.printStackTrace();
    } catch (IOException e3) {
     e3.printStackTrace();
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 0)) {
   variabl1163.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1163);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton exitButton = new JButton(variabl2405[5]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    if ((sw[2].length() > 0) && (sw[3].length() > 0)
      && (sw[4].length() > 0))
     WorkflowDrivek1.means(sw);
    frame.setVisible(false);
    frame.dispose();
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",5,") >= 0)) {
   exitButton
     .setBounds(variabl1423, variabl2503 - 80, variabl2339, 20);
   panel.add(exitButton);
   variabl1423 = variabl1423 + variabl2339;
  }
  main1.driver1();
  frame.add(panel);
  frame.setVisible(true);
}
}
48.源码48，部件程序，从纯文本文件、XML文件或其他数据表添加式导入数据到当前表数据导入部件。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
* 程序文件名：dataTransfer8.java 作者：程学先功能：从纯文本文件、XML文件或其他数据表添加式导入数据到当前表。
* 原有标数据全部保留，导入数据添加到尾部。特别注意，本程序未检查实体完整性，需要关注关键字重复记录问题。
* 如果从数据表导入，当前表作为目的表必须存在且必须与源表数据类型、数据宽度对应相容，符合本程序中“类型对照表"设置的对应关系。
*/

public class dataTransfer8 extends JFrame {
static dataTransfer8 frame = new dataTransfer8();
private static JTable table;
static Connection con;
static Connection con1;
static String url;
static String variabl10911;
static ResultSetMetaData rsmd3;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta3;
static Statement sta4;
static ResultSet rs;
static int variabl2483 = 800, variabl2503 = 600;
static int variabl2651;
static int variabl26511;
static String[][] variabl2517;
static String[] variabl25171;
static int[] variabl1065;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int[] variabl1119, variabl1125;
static int variabl1853 = 0, variabl18531 = 0;
static String[][] variabl2197;
static String[][] variabl21971;
static DefaultTableModel model;
static String variabl2603;
static String variabl2429;
static String variabl1873;
static String variabl1625, variabl1339;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl12491;
static String variabl1735;
static String s1 = "", s2 = "", s3 = "";
static String s6 = "                                                  ";
static char x1 = 10, x2 = 13, x3 = '"', x4 = ',';
private static String[][] variabl1601 = {
   { "java", "string", "string", "string", "int", "int", "string",
     "string", "string", "string", "boolean", "byte", "short",
     "long", "float", "int", "double", "float", "float",
     "byte[]" },
   { "sqlserver", "char", "nchar", "nvarchar", "int", "float",
     "datetime", "datetime", "text", "ntext", "bit", "tinyint",
     "smallint", "bigint", "numeric", "integer", "double",
     "money", "real", "image" },
   { "vfp", "c", "c", "c", "i", "n", "d", "t", "m", "m", "l", "i",
     "i", "i", "n", "i", "n", "b", "y", "g" },
   { "access", "text", "text", "text", "integer", "integer", "date",
     "date", "memo", "memo", "logical", "integer", "integer",
     "integer", "float", "integer", "float", "float", "float",
     "general" },
   { "oracle", "char", "char", "char", "number", "number", "date",
     "date", "long", "long", "char", "raw", "number", "number",
     "number", "number", "number", "number", "number", "blob" },
   { "mysql", "char", "char", "varchar", "int", "float", "date",
     "datetime", "text", "text", "tinyint", "tinyint",
     "smallint", "bigint", "float", "integer", "double",
     "float", "float", "blob" } };
static String variabl25111 = main1.variabl25111;
static int variabl2851 = 0, variabl2339 = 0;

public static void means(String[] parameter) {
  frame = new dataTransfer8();
  variabl2483 = 800;
  variabl2503 = 600;
  variabl1853 = 0;
  variabl18531 = 0;
  s1 = "";
  s2 = "";
  s3 = "";
  s6 = "                                                  ";
  x1 = 10;
  x2 = 13;
  x3 = '"';
  x4 = ',';
  variabl25111 = main1.variabl25111;
  variabl1601[0][0] = "java";
  variabl1601[0][1] = "string";
  variabl1601[0][2] = "string";
  variabl1601[0][3] = "string";
  variabl1601[0][4] = "int";
  variabl1601[0][5] = "int";
  variabl1601[0][6] = "string";
  variabl1601[0][7] = "string";
  variabl1601[0][8] = "string";
  variabl1601[0][9] = "string";
  variabl1601[0][10] = "boolean";
  variabl1601[0][11] = "byte";
  variabl1601[0][12] = "short";
  variabl1601[0][13] = "long";
  variabl1601[0][14] = "float";
  variabl1601[0][15] = "int";
  variabl1601[0][16] = "double";
  variabl1601[0][17] = "float";
  variabl1601[0][18] = "float";
  variabl1601[0][19] = "byte[]";
  variabl1601[1][0] = "sqlserver";
  variabl1601[1][1] = "char";
  variabl1601[1][2] = "nchar";
  variabl1601[1][3] = "nvarchar";
  variabl1601[1][4] = "int";
  variabl1601[1][5] = "float";
  variabl1601[1][6] = "datetime";
  variabl1601[1][7] = "datetime";
  variabl1601[1][8] = "text";
  variabl1601[1][9] = "ntext";
  variabl1601[1][10] = "bit";
  variabl1601[1][11] = "tinyint";
  variabl1601[1][12] = "smallint";
  variabl1601[1][13] = "bigint";
  variabl1601[1][14] = "numeric";
  variabl1601[1][15] = "integer";
  variabl1601[1][16] = "double";
  variabl1601[1][17] = "money";
  variabl1601[1][18] = "real";
  variabl1601[1][19] = "image";
  variabl1601[2][0] = "vfp";
  variabl1601[2][1] = "c";
  variabl1601[2][2] = "c";
  variabl1601[2][3] = "c";
  variabl1601[2][4] = "i";
  variabl1601[2][5] = "n";
  variabl1601[2][6] = "d";
  variabl1601[2][7] = "t";
  variabl1601[2][8] = "m";
  variabl1601[2][9] = "m";
  variabl1601[2][10] = "l";
  variabl1601[2][11] = "i";
  variabl1601[2][12] = "i";
  variabl1601[2][13] = "i";
  variabl1601[2][14] = "n";
  variabl1601[2][15] = "i";
  variabl1601[2][16] = "n";
  variabl1601[2][17] = "b";
  variabl1601[2][18] = "y";
  variabl1601[2][19] = "g";
  variabl1601[3][0] = "access";
  variabl1601[3][1] = "text";
  variabl1601[3][2] = "text";
  variabl1601[3][3] = "text";
  variabl1601[3][4] = "integer";
  variabl1601[3][5] = "integer";
  variabl1601[3][6] = "date";
  variabl1601[3][7] = "date";
  variabl1601[3][8] = "memo";
  variabl1601[3][9] = "memo";
  variabl1601[3][10] = "logical";
  variabl1601[3][11] = "integer";
  variabl1601[3][12] = "integer";
  variabl1601[3][13] = "integer";
  variabl1601[3][14] = "float";
  variabl1601[3][15] = "integer";
  variabl1601[3][16] = "float";
  variabl1601[3][17] = "float";
  variabl1601[3][18] = "float";
  variabl1601[3][19] = "general";
  variabl1601[4][0] = "oracle";
  variabl1601[4][1] = "char";
  variabl1601[4][2] = "char";
  variabl1601[4][3] = "char";
  variabl1601[4][4] = "number";
  variabl1601[4][5] = "number";
  variabl1601[4][6] = "date";
  variabl1601[4][7] = "date";
  variabl1601[4][8] = "long";
  variabl1601[4][9] = "long";
  variabl1601[4][10] = "char";
  variabl1601[4][11] = "raw";
  variabl1601[4][12] = "number";
  variabl1601[4][13] = "number";
  variabl1601[4][14] = "number";
  variabl1601[4][15] = "number";
  variabl1601[4][16] = "number";
  variabl1601[4][17] = "number";
  variabl1601[4][18] = "number";
  variabl1601[4][19] = "blob";
  variabl1601[5][0] = "mysql";
  variabl1601[5][1] = "char";
  variabl1601[5][2] = "char";
  variabl1601[5][3] = "varchar";
  variabl1601[5][4] = "int";
  variabl1601[5][5] = "float";
  variabl1601[5][6] = "date";
  variabl1601[5][7] = "datetime";
  variabl1601[5][8] = "text";
  variabl1601[5][9] = "text";
  variabl1601[5][10] = "tinyint";
  variabl1601[5][11] = "tinyint";
  variabl1601[5][12] = "smallint";
  variabl1601[5][13] = "bigint";
  variabl1601[5][14] = "float";
  variabl1601[5][15] = "integer";
  variabl1601[5][16] = "double";
  variabl1601[5][17] = "float";
  variabl1601[5][18] = "float";
  variabl1601[5][19] = "blob";
  variabl2603 = parameter[4];
  variabl1735 = parameter[8];
  variabl1339 = parameter[18];
  variabl1625 = parameter[2];
  String[] variabl240501 = { "从数据表导入", "标准格式导入", "紧缩格式导入", "自定义格式导入",
    "从XML文件导入", "退出" };
  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) {
  }
  variabl12491 = parameter[1];
  variabl10911 = parameter[3];
  if ((variabl12491 == null) || (variabl12491.length() == 0))
   variabl12491 = main1.variabl1275;
  if ((variabl10911 == null) || (variabl10911.length() == 0))
   variabl10911 = main1.variabl1091;
  String variabl1633 = parameter[19].trim();
  if ((variabl1633.length() > 0)
    && (variabl1633.substring(variabl1633.length() - 1).equals(",")))
   variabl1633 = variabl1633.substring(0, variabl1633.length() - 1);
  variabl2429 = parameter[0];
  String[] l3 = variabl1633.split(",");
  variabl1873 = "";
  String[] t1;
  int b = 0, c = 0;
  if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) {
   t1 = variabl2429.split(",");
   for (int i = 0; i < t1.length; i++)
    if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0)
     variabl1873 = t1[i];
  }
  String[] l1;
  if (variabl1735.length() > 0) {
   l1 = variabl1735.split(",");
   int[] l2 = new int[l1.length];
   for (int i = 0; i < l1.length; i++) {
    l2[i] = Integer.valueOf(l1[i]);
   }
   variabl2651 = l1.length;
   variabl2517 = new String[2][variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = l3[l2[i]];
    variabl2517[1][i] = variabl2517[0][i];
   }
  } else {
   variabl2651 = l3.length;
   variabl2517 = new String[2][variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = l3[i];
    variabl2517[1][i] = variabl2517[0][i];
   }
  }
  s1 = "";
  for (int i = 0; i < variabl2651; i++) {
   s1 = s1 + variabl2517[0][i] + ",";
  }
  s1 = s1.substring(0, s1.length() - 1);
  try {
   if (("," + variabl2429).lastIndexOf("," + variabl2603 + ",") >= 0) {
    main1.driver1();
    con1 = main1.getConn();
    sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select " + s1 + " from " + variabl2603;
   } else {
    JOptionPane.showMessageDialog(null, "目的数据表不存在，不能导入！");
    return;
   }
   ResultSet rs = sta4.executeQuery(s1);
   rsmd4 = rs.getMetaData();
   variabl2651 = rsmd4.getColumnCount();
   variabl2517 = new String[2][variabl2651];
   variabl1501 = new String[variabl2651];
   variabl1489 = new int[variabl2651];
   variabl1913 = new String[variabl2651];
   variabl1119 = new int[variabl2651];
   variabl1169 = new String[variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = rsmd4.getColumnName(i + 1);
    variabl2517[1][i] = variabl2517[0][i];
    variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
    variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
    if (variabl1489[i] < variabl2517[0][i].length())
     variabl1489[i] = variabl2517[0][i].length();
    if (variabl1489[i] < variabl2517[1][i].length())
     variabl1489[i] = variabl2517[1][i].length();
    if (variabl1489[i] > 50)
     variabl1489[i] = 50;
   }
   if (((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0))
     && (variabl12491.trim().length() > 0)) {
    int variabl2111 = 0, variabl21111 = 0;
    for (int i = 0; i < variabl1601.length; i++) {
     if (variabl12491.trim().equals(variabl1601[i][0]))
      variabl21111 = i;
     if (main1.variabl1275.equals(variabl1601[i][0]))
      variabl2111 = i;
    }
    for (b = 0; b < variabl2651; b++) {
     variabl1913[b] = variabl2517[1][b];
     variabl1119[b] = variabl1489[b];
     for (int i = 1; i < variabl1601[0].length; i++) {
      if (variabl1501[b].toLowerCase().trim()
        .equals(variabl1601[variabl2111][i])) {
       variabl1169[b] = variabl1601[variabl21111][i];
       break;
      }
     }
    }
   }
   variabl1853 = 0;
   rs.last();
   variabl1853 = rs.getRow();
   variabl2197 = new String[variabl1853][variabl2651];
   rs.absolute(1);
   c = 0;
   b = 0;
   while (c < variabl1853) {
    rs.absolute(c + 1);
    while (b < variabl2651) {
     variabl2197[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close();
   sta4.close();
   con1.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "读取数据出错！");
  }
  if (variabl1873.length() > 0) {
   try {
    main1.driver1();
    con = main1.getConn();
    sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select * from " + variabl1873;
    rs = sta3.executeQuery(s1);
    String s4 = "";
    String s5 = "";
    b = 1;
    while (rs.absolute(b)) {
     b++;
     s4 = rs.getString(1);
     s5 = rs.getString(2);
     for (int j = 0; j < variabl2651; j++) {
      if (variabl2517[0][j].trim().equals(s4.trim())) {
       variabl2517[1][j] = s5;
       variabl1913[j] = s5;
       break;
      }
     }
    }
    rs.close();
    con.close();
    sta3.close();
   } catch (SQLException e) {
    JOptionPane.showMessageDialog(null, "连接数据库出错！");
   }
  }
  s2 = "";
  for (int i = 0; i < variabl2651; i++) {
   s2 = s2 + variabl2517[1][i] + ",";
  }
  s2 = s2.substring(0, s2.length() - 1);
  frame.setTitle("从文本文件、XML文件或数据库表导入数据库到本地部件。特别注意数据类型、宽度的对应。作者：程学先");
  frame.setBounds(10, 10, variabl2483, variabl2503);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.setLayout(null);
  final JPanel panel = new JPanel(false);
  panel.setLayout(null);
  panel.setBounds(10, 10, variabl2483, variabl2503);
  final JScrollPane scrollPane = new JScrollPane();
  scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 100);
  panel.add(scrollPane);

  model = new DefaultTableModel(variabl2197, variabl2517[1]);
  table = new JTable(model);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
  for (int i = 0; i < variabl2651; i++) {
   TableColumn tc = table.getColumn(variabl2517[1][i]);
   tc.setPreferredWidth(variabl1489[i] * 14);
   tc.setMaxWidth(variabl1489[i] * 14);
   tc.sizeWidthToFit();
  }
  scrollPane.setViewportView(table);
  variabl2339 = (variabl2483 - 60) / variabl2851;
  int variabl1423 = 30;
  for (int i = 0; i < 100; i++)
   s3 = s3 + " ";
  JButton variabl1933 = new JButton(variabl2405[0]);
  variabl1933.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat4;
    Statement stat3;
    try {
     if (("," + variabl2429)
       .lastIndexOf("," + variabl2603 + ",") >= 0) {
      main1.driver1();
      con1 = main1.getConn();
      stat4 = con1.createStatement(
        ResultSet.TYPE_SCROLL_INSENSITIVE,
        ResultSet.CONCUR_UPDATABLE);
      s1 = "select " + s2 + " from " + variabl1625;
      ResultSet rs1 = stat4.executeQuery(s1);
      rs1.last();
      variabl18531 = rs1.getRow();
      variabl25171 = s2.split(",");
      variabl26511 = variabl25171.length;
      variabl21971 = new String[variabl18531][variabl26511];
      rs1.absolute(1);
      int c = 0;
      int b = 0;
      while (c < variabl18531) {
       rs1.absolute(c + 1);
       while (b < variabl2651) {
        variabl21971[c][b] = rs1.getString(b + 1);
        b++;
       }
       c++;
       b = 0;
      }
      rs1.close();
      stat4.close();
      con1.close();
     }
    } catch (SQLException e1) {
    }
    try {
     main1.driver1();
     con = main1.getConn();
     stat3 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     for (int i = 0; i < variabl21971.length; i++) {
      s1 = "insert into " + variabl2603 + " (";
      for (int k1 = 0; k1 < variabl2517[1].length; k1++)
       s1 = s1 + variabl2517[1][k1] + ",";
      s1 = s1.substring(0, s1.length() - 1) + " ) values (";
      for (int j = 0; j < variabl2517[1].length; j++) {
       if (variabl25111.lastIndexOf("," + variabl1501[j]
         + ",") >= 0) {
        if (variabl21971[i][j] == null)
         variabl21971[i][j] = "0";
        s1 = s1 + variabl21971[i][j];
       } else {
        if (variabl21971[i][j] == null)
         variabl21971[i][j] = " ";
        s1 = s1 + "'" + variabl21971[i][j] + "'";
       }
       if (j != variabl2517[1].length - 1)
        s1 = s1 + ",";
      }
      s1 = s1 + ")";
      stat3.executeUpdate(s1);
     }
     stat3.close();
     con.close();
    } catch (SQLException e1) {
     JOptionPane.showMessageDialog(null,
       "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
   variabl1933.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1933);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl2225 = new JButton(variabl2405[1]);
  variabl2225.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     FileReader fs = new FileReader(variabl1339);
     BufferedReader br = new BufferedReader(fs);
     String tempStr = null;
     String[] variabl23691 = new String[variabl2651];
     int k1 = 0, k2 = 0, k5 = 0;
     for (int i1 = 0; (tempStr = br.readLine()) != null; i1++) {
      for (int j = 0; j < variabl2651; j++) {
       variabl23691[j] = tempStr.substring(k1, k1
         + variabl1489[j]);
       k1 = k1 + variabl1489[j];
      }
      try {
       main1.driver1();
       con = main1.getConn();
       stat3 = con.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
       s1 = "insert into " + variabl2603 + " (";
       for (int k3 = 0; k3 < variabl2517[1].length; k3++)
        s1 = s1 + variabl2517[1][k3] + ",";
       s1 = s1.substring(0, s1.length() - 1)
         + " ) values (";
       for (int j = 0; j < variabl2517[1].length; j++) {
        if (variabl25111.lastIndexOf(","
          + variabl1501[j] + ",") >= 0) {
         if (variabl23691[j] == null)
          variabl23691[j] = "0";
         s1 = s1 + variabl23691[j].trim();
        } else {
         if (variabl23691[j] == null)
          variabl23691[j] = " ";
         s1 = s1 + "'" + variabl23691[j].trim()
           + "'";
        }
        if (j != variabl2517[1].length - 1)
         s1 = s1 + ",";
       }
       s1 = s1 + ")";
       stat3.executeUpdate(s1);
       stat3.close();
       con.close();
      } catch (SQLException e1) {
       JOptionPane.showMessageDialog(null,
         "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
      }
      k1 = 0;
     }
     fs.close();
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
    } catch (IOException e2) {
     e2.printStackTrace();
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
   variabl2225.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl2225);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton exitButton = new JButton(variabl2405[5]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    frame.setVisible(false);
    frame.dispose();
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",5,") >= 0)) {
   exitButton
     .setBounds(variabl1423, variabl2503 - 80, variabl2339, 20);
   panel.add(exitButton);
   variabl1423 = variabl1423 + variabl2339;
  }
  main1.driver1();
  frame.add(panel);
  frame.setVisible(true);
}
}
49.源码49，部件程序，从纯文本文件、XML文件或其他数据表修改式导入数据到当前表数据导入部件。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
* 程序文件名：dataTransfer9.java 作者：程学先功能：从纯文本文件、XML文件或其他数据表修改式导入数据到当前表。
* 关键字子相同记录按导入表更新，关键字不在原表中的记录作为新记录添加在尾部。
* 如果目的表已经存在，必须与源表数据类型、数据宽度对应相容，符合本程序中“类型对照表"设置的对应关系。
*/

public class dataTransfer9 extends JFrame {
static dataTransfer9 frame = new dataTransfer9();
private static JTable table;
static Connection con;
static Connection con1;
static String url;
static String variabl10911;
static ResultSetMetaData rsmd3;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta3;
static Statement sta4;
static ResultSet rs;
static int variabl2483 = 800, variabl2503 = 600;
static int variabl2651;
static int variabl26511;
static String[][] variabl2517;
static String[] variabl25171;
static int[] variabl1065;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int[] variabl1119, variabl1125;
static int variabl1853 = 0, variabl18531 = 0;
static String[][] variabl2197;
static String[][] variabl21971;
static DefaultTableModel model;
static String variabl2603;
static String variabl2429;
static String variabl1873;
static String variabl1625, variabl1339;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl12491;
static String variabl1735;
static String variabl2253;
static String[] variabl14211;
static String[] variabl2053, variabl20531;
static int[] variabl1287, variabl12871;
static String s1 = "", s2 = "", s3 = "";
static String s6 = "                                                  ";
static char x1 = 10, x2 = 13, x3 = '"', x4 = ',';
private static String[][] variabl1601 = {
   { "java", "string", "string", "string", "int", "int", "string",
     "string", "string", "string", "boolean", "byte", "short",
     "long", "float", "int", "double", "float", "float",
     "byte[]" },
   { "sqlserver", "char", "nchar", "nvarchar", "int", "float",
     "datetime", "datetime", "text", "ntext", "bit", "tinyint",
     "smallint", "bigint", "numeric", "integer", "double",
     "money", "real", "image" },
   { "vfp", "c", "c", "c", "i", "n", "d", "t", "m", "m", "l", "i",
     "i", "i", "n", "i", "n", "b", "y", "g" },
   { "access", "text", "text", "text", "integer", "integer", "date",
     "date", "memo", "memo", "logical", "integer", "integer",
     "integer", "float", "integer", "float", "float", "float",
     "general" },
   { "oracle", "char", "char", "char", "number", "number", "date",
     "date", "long", "long", "char", "raw", "number", "number",
     "number", "number", "number", "number", "number", "blob" },
   { "mysql", "char", "char", "varchar", "int", "float", "date",
     "datetime", "text", "text", "tinyint", "tinyint",
     "smallint", "bigint", "float", "integer", "double",
     "float", "float", "blob" } };
static String variabl25111 = main1.variabl25111;
static int variabl2851 = 0, variabl2339 = 0;

public static void means(String[] parameter) {
  frame = new dataTransfer9();
  variabl2483 = 800;
  variabl2503 = 600;
  variabl1853 = 0;
  variabl18531 = 0;
  s1 = "";
  s2 = "";
  s3 = "";
  s6 = "                                                  ";
  x1 = 10;
  x2 = 13;
  x3 = '"';
  x4 = ',';
  variabl25111 = main1.variabl25111;
  variabl1601[0][0] = "java";
  variabl1601[0][1] = "string";
  variabl1601[0][2] = "string";
  variabl1601[0][3] = "string";
  variabl1601[0][4] = "int";
  variabl1601[0][5] = "int";
  variabl1601[0][6] = "string";
  variabl1601[0][7] = "string";
  variabl1601[0][8] = "string";
  variabl1601[0][9] = "string";
  variabl1601[0][10] = "boolean";
  variabl1601[0][11] = "byte";
  variabl1601[0][12] = "short";
  variabl1601[0][13] = "long";
  variabl1601[0][14] = "float";
  variabl1601[0][15] = "int";
  variabl1601[0][16] = "double";
  variabl1601[0][17] = "float";
  variabl1601[0][18] = "float";
  variabl1601[0][19] = "byte[]";
  variabl1601[1][0] = "sqlserver";
  variabl1601[1][1] = "char";
  variabl1601[1][2] = "nchar";
  variabl1601[1][3] = "nvarchar";
  variabl1601[1][4] = "int";
  variabl1601[1][5] = "float";
  variabl1601[1][6] = "datetime";
  variabl1601[1][7] = "datetime";
  variabl1601[1][8] = "text";
  variabl1601[1][9] = "ntext";
  variabl1601[1][10] = "bit";
  variabl1601[1][11] = "tinyint";
  variabl1601[1][12] = "smallint";
  variabl1601[1][13] = "bigint";
  variabl1601[1][14] = "numeric";
  variabl1601[1][15] = "integer";
  variabl1601[1][16] = "double";
  variabl1601[1][17] = "money";
  variabl1601[1][18] = "real";
  variabl1601[1][19] = "image";
  variabl1601[2][0] = "vfp";
  variabl1601[2][1] = "c";
  variabl1601[2][2] = "c";
  variabl1601[2][3] = "c";
  variabl1601[2][4] = "i";
  variabl1601[2][5] = "n";
  variabl1601[2][6] = "d";
  variabl1601[2][7] = "t";
  variabl1601[2][8] = "m";
  variabl1601[2][9] = "m";
  variabl1601[2][10] = "l";
  variabl1601[2][11] = "i";
  variabl1601[2][12] = "i";
  variabl1601[2][13] = "i";
  variabl1601[2][14] = "n";
  variabl1601[2][15] = "i";
  variabl1601[2][16] = "n";
  variabl1601[2][17] = "b";
  variabl1601[2][18] = "y";
  variabl1601[2][19] = "g";
  variabl1601[3][0] = "access";
  variabl1601[3][1] = "text";
  variabl1601[3][2] = "text";
  variabl1601[3][3] = "text";
  variabl1601[3][4] = "integer";
  variabl1601[3][5] = "integer";
  variabl1601[3][6] = "date";
  variabl1601[3][7] = "date";
  variabl1601[3][8] = "memo";
  variabl1601[3][9] = "memo";
  variabl1601[3][10] = "logical";
  variabl1601[3][11] = "integer";
  variabl1601[3][12] = "integer";
  variabl1601[3][13] = "integer";
  variabl1601[3][14] = "float";
  variabl1601[3][15] = "integer";
  variabl1601[3][16] = "float";
  variabl1601[3][17] = "float";
  variabl1601[3][18] = "float";
  variabl1601[3][19] = "general";
  variabl1601[4][0] = "oracle";
  variabl1601[4][1] = "char";
  variabl1601[4][2] = "char";
  variabl1601[4][3] = "char";
  variabl1601[4][4] = "number";
  variabl1601[4][5] = "number";
  variabl1601[4][6] = "date";
  variabl1601[4][7] = "date";
  variabl1601[4][8] = "long";
  variabl1601[4][9] = "long";
  variabl1601[4][10] = "char";
  variabl1601[4][11] = "raw";
  variabl1601[4][12] = "number";
  variabl1601[4][13] = "number";
  variabl1601[4][14] = "number";
  variabl1601[4][15] = "number";
  variabl1601[4][16] = "number";
  variabl1601[4][17] = "number";
  variabl1601[4][18] = "number";
  variabl1601[4][19] = "blob";
  variabl1601[5][0] = "mysql";
  variabl1601[5][1] = "char";
  variabl1601[5][2] = "char";
  variabl1601[5][3] = "varchar";
  variabl1601[5][4] = "int";
  variabl1601[5][5] = "float";
  variabl1601[5][6] = "date";
  variabl1601[5][7] = "datetime";
  variabl1601[5][8] = "text";
  variabl1601[5][9] = "text";
  variabl1601[5][10] = "tinyint";
  variabl1601[5][11] = "tinyint";
  variabl1601[5][12] = "smallint";
  variabl1601[5][13] = "bigint";
  variabl1601[5][14] = "float";
  variabl1601[5][15] = "integer";
  variabl1601[5][16] = "double";
  variabl1601[5][17] = "float";
  variabl1601[5][18] = "float";
  variabl1601[5][19] = "blob";
  variabl2603 = parameter[4];
  variabl1735 = parameter[8];
  variabl1339 = parameter[18];
  variabl1625 = parameter[2];
  String[] variabl240501 = { "从数据表导入", "标准格式导入", "紧缩格式导入", "自定义格式导入",
    "从XML文件导入", "退出" };
  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) {
  }
  variabl12491 = parameter[1];
  variabl10911 = parameter[3];
  if ((variabl12491 == null) || (variabl12491.length() == 0))
   variabl12491 = main1.variabl1275;
  if ((variabl10911 == null) || (variabl10911.length() == 0))
   variabl10911 = main1.variabl1091;
  variabl2253 = parameter[6];
  String variabl1633 = parameter[19].trim();
  if ((variabl1633.length() > 0)
    && (variabl1633.substring(variabl1633.length() - 1).equals(",")))
   variabl1633 = variabl1633.substring(0, variabl1633.length() - 1);
  variabl2429 = parameter[0];
  String[] l3 = variabl1633.split(",");
  variabl1873 = "";
  String[] t1;
  int b = 0, c = 0;
  if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) {
   t1 = variabl2429.split(",");
   for (int i = 0; i < t1.length; i++)
    if (t1[i].lastIndexOf(variabl2603 + "字典表") > 00)
     variabl1873 = t1[i];
  }
  String[] l1;
  if (variabl1735.length() > 0) {
   l1 = variabl1735.split(",");
   int[] l2 = new int[l1.length];
   for (int i = 0; i < l1.length; i++) {
    l2[i] = Integer.valueOf(l1[i]);
   }
   variabl2651 = l1.length;
   variabl2517 = new String[2][variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = l3[l2[i]];
    variabl2517[1][i] = variabl2517[0][i];
   }
  } else {
   variabl2651 = l3.length;
   variabl2517 = new String[2][variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = l3[i];
    variabl2517[1][i] = variabl2517[0][i];
   }
  }
  s1 = "";
  for (int i = 0; i < variabl2651; i++) {
   s1 = s1 + variabl2517[0][i] + ",";
  }
  s1 = s1.substring(0, s1.length() - 1);
  try {
   if (("," + variabl2429).lastIndexOf("," + variabl2603 + ",") >= 0) {
    main1.driver1();
    con1 = main1.getConn();
    sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select " + s1 + " from " + variabl2603;
   }
   ResultSet rs = sta4.executeQuery(s1);
   rsmd4 = rs.getMetaData();
   variabl2651 = rsmd4.getColumnCount();
   variabl2517 = new String[2][variabl2651];
   variabl1501 = new String[variabl2651];
   variabl1489 = new int[variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = rsmd4.getColumnName(i + 1);
    variabl2517[1][i] = variabl2517[0][i];
    variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
    variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
    if (variabl1489[i] < variabl2517[0][i].length())
     variabl1489[i] = variabl2517[0][i].length();
    if (variabl1489[i] < variabl2517[1][i].length())
     variabl1489[i] = variabl2517[1][i].length();
    if (variabl1489[i] > 50)
     variabl1489[i] = 50;
   }
   variabl2053 = variabl2253.split(",");
   variabl20531 = new String[variabl2053.length];
   variabl1287 = new int[variabl2053.length];
   variabl12871 = new int[variabl2053.length];
   if (((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0))
     && (variabl12491.trim().length() > 0)) {
    int variabl2111 = 0, variabl21111 = 0;
    for (int i = 0; i < variabl1601.length; i++) {
     if (variabl12491.trim().equals(variabl1601[i][0]))
      variabl21111 = i;
     if (main1.variabl1275.equals(variabl1601[i][0]))
      variabl2111 = i;
    }
    variabl1913 = new String[variabl2651];
    variabl1169 = new String[variabl2651];
    variabl1119 = new int[variabl2651];
    for (b = 0; b < variabl2651; b++) {
     variabl1913[b] = variabl2517[1][b];
     variabl1119[b] = variabl1489[b];
     for (int i = 1; i < variabl1601[0].length; i++) {
      if (variabl1501[b].toLowerCase().trim()
        .equals(variabl1601[variabl2111][i])) {
       variabl1169[b] = variabl1601[variabl21111][i];
       break;
      }
     }
    }
   }
   variabl1853 = 0;
   rs.last();
   variabl1853 = rs.getRow();
   variabl2197 = new String[variabl1853][variabl2651];
   rs.absolute(1);
   c = 0;
   b = 0;
   while (c < variabl1853) {
    rs.absolute(c + 1);
    while (b < variabl2651) {
     variabl2197[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close();
   sta4.close();
   con1.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "读取数据出错！");
  }
  for (int i = 0; i < variabl2651; i++) {
   for (int j = 0; j < variabl2053.length; j++)
    if (variabl2053[j].trim().equals(variabl2517[0][i].trim())) {
     variabl20531[j] = variabl2517[1][i];
     variabl1287[j] = i;
    }
  }
  if (variabl1873.length() > 0) {
   try {
    main1.driver1();
    con = main1.getConn();
    sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select * from " + variabl1873;
    rs = sta3.executeQuery(s1);
    String s4 = "";
    String s5 = "";
    b = 1;
    while (rs.absolute(b)) {
     b++;
     s4 = rs.getString(1);
     s5 = rs.getString(2);
     for (int j = 0; j < variabl2651; j++) {
      if (variabl2517[0][j].trim().equals(s4.trim())) {
       variabl2517[1][j] = s5;
       variabl1913[j] = s5;
       break;
      }
     }
    }
    rs.close();
    con.close();
    sta3.close();
   } catch (SQLException e) {
    JOptionPane.showMessageDialog(null, "连接数据库出错！");
   }
  }
  s2 = "";
  for (int i = 0; i < variabl2651; i++) {
   s2 = s2 + variabl2517[1][i] + ",";
  }
  s2 = s2.substring(0, s2.length() - 1);
  frame.setTitle("从文本文件、XML文件或数据库表导入数据库到本地部件。特别注意数据类型、宽度的对应。作者：程学先");
  frame.setBounds(10, 10, variabl2483, variabl2503);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.setLayout(null);
  final JPanel panel = new JPanel(false);
  panel.setLayout(null);
  panel.setBounds(10, 10, variabl2483, variabl2503);
  final JScrollPane scrollPane = new JScrollPane();
  scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 100);
  panel.add(scrollPane);

  JButton variabl1933 = new JButton(variabl2405[0]);
  variabl1933.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat4;
    Statement stat3;
    try {
     if (("," + variabl2429)
       .lastIndexOf("," + variabl2603 + ",") >= 0) {
      main1.driver1();
      con1 = main1.getConn();
      stat4 = con1.createStatement(
        ResultSet.TYPE_SCROLL_INSENSITIVE,
        ResultSet.CONCUR_UPDATABLE);
      s1 = "select " + s2 + " from " + variabl1625;
      ResultSet rs1 = stat4.executeQuery(s1);
      rs1.last();
      variabl18531 = rs1.getRow();
      variabl14211 = new String[variabl18531];
      variabl25171 = s2.split(",");
      variabl26511 = variabl25171.length;
      for (int k = 0; k < variabl2053.length; k++) {
       for (int j = 0; j < variabl26511; j++) {
        if (variabl20531[k].trim().equals(
          variabl25171[j].trim())) {
         variabl12871[k] = j;
         break;
        }
       }
      }
      variabl21971 = new String[variabl18531][variabl26511];
      rs1.absolute(1);
      int c = 0;
      int b = 0;
      s2 = "";
      while (c < variabl18531) {
       rs1.absolute(c + 1);
       while (b < variabl2651) {
        variabl21971[c][b] = rs1.getString(b + 1);
        b++;
       }
       c++;
       b = 0;
      }
      for (int i = 0; i < variabl18531; i++) {
       variabl14211[i] = "";
       for (int k = 0; k < variabl2053.length; k++) {
        variabl14211[i] = variabl14211[i]
          + variabl21971[i][variabl12871[k]]
            .trim();
       }
      }
      rs1.close();
      stat4.close();
      con1.close();
     }
    } catch (SQLException e1) {
    }
    try {
     main1.driver1();
     con = main1.getConn();
     stat4 = con.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     int f0 = 0;
     for (int i = 0; i < variabl1853; i++) {
      s3 = "";
      for (int j = 0; j < variabl2053.length; j++)
       s3 = s3 + variabl2197[i][variabl1287[j]].trim();
      f0 = 0;
      for (int i1 = 0; i1 < variabl18531; i1++) {
       if (variabl14211[i1].trim().equals(s3.trim()))
        f0 = 1;
      }
      if (f0 == 0) {
       s1 = "insert into " + variabl2603 + " (";
       for (int k1 = 0; k1 < variabl2517[1].length; k1++)
        s1 = s1 + variabl2517[1][k1] + ",";
       s1 = s1.substring(0, s1.length() - 1)
         + " ) values (";
       for (int j = 0; j < variabl2517[1].length; j++) {
        if (variabl25111.lastIndexOf(","
          + variabl1501[j] + ",") >= 0) {
         if (variabl21971[i][j] == null)
          variabl21971[i][j] = "0";
         s1 = s1 + variabl21971[i][j];
        } else {
         if (variabl21971[i][j] == null)
          variabl21971[i][j] = " ";
         s1 = s1 + "'" + variabl21971[i][j] + "'";
        }
        if (j != variabl2517[1].length - 1)
         s1 = s1 + ",";
       }
       s1 = s1 + ")";
       stat4.executeUpdate(s1);
      } else {
       s1 = "update " + variabl2603 + " set ";
       for (int k1 = 0; k1 < variabl2517[1].length; k1++) {
        s1 = s1 + variabl2517[1][k1] + "=";
        if (variabl25111.lastIndexOf(","
          + variabl1501[k1] + ",") >= 0) {
         if (variabl21971[i][k1] == null)
          variabl21971[i][k1] = "0";
         s1 = s1 + variabl21971[i][k1];
        } else {
         if (variabl21971[i][k1] == null)
          variabl21971[i][k1] = " ";
         s1 = s1 + "'" + variabl21971[i][k1] + "'";
        }
        if (k1 != variabl2517[1].length - 1)
         s1 = s1 + ",";
       }
       s2 = " where ";
       for (int k = 0; k < variabl2053.length; k++) {
        s2 = s2 + variabl20531[k] + "='"
          + variabl21971[i][variabl12871[k]]
          + "'";
        if (k < variabl2053.length - 1)
         s2 = s2 + " and ";
       }
       s1 = s1 + s2;
       stat4.executeUpdate(s1);
      }
     }
     stat4.close();
     con.close();
    } catch (SQLException e1) {
     JOptionPane.showMessageDialog(null,
       "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
    }

   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
   variabl1933.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1933);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl2225 = new JButton(variabl2405[1]);
  variabl2225.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     FileReader fs = new FileReader(variabl1339);
     BufferedReader br = new BufferedReader(fs);
     String tempStr = null;
     String[] variabl23691 = new String[variabl2651];
     int k1 = 0, k2 = 0, k5 = 0;
     for (int i1 = 0; (tempStr = br.readLine()) != null; i1++) {
      k5 = 0;
      for (int j = 0; j < variabl2651; j++) {
       variabl23691[j] = tempStr.substring(k1, k1
         + variabl1489[j]);
       k1 = k1 + variabl1489[j];
      }
      s3 = "";
      for (int k3 = 0; k3 < variabl2053.length; k3++)
       s3 = s3 + variabl23691[variabl1287[k3]].trim();
      k2 = 0;
      for (int j1 = 0; j1 < variabl1853; j1++) {
       s2 = "";
       for (int k4 = 0; k4 < variabl2053.length; k4++)
        s2 = s2
          + variabl2197[j1][variabl1287[k4]]
            .trim();
       if (s3.trim().equals(s2.trim())) {
        k2 = j1;
        k5 = 1;
       }
      }
      try {
       main1.driver1();
       con = main1.getConn();
       stat3 = con.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
       if (k5 == 0) {
        s1 = "insert into " + variabl2603 + " (";
        for (int k6 = 0; k6 < variabl2517[1].length; k6++)
         s1 = s1 + variabl2517[1][k6] + ",";
        s1 = s1.substring(0, s1.length() - 1)
          + " ) values (";
        for (int j = 0; j < variabl2517[1].length; j++) {
         if (variabl25111.lastIndexOf(","
           + variabl1501[j] + ",") >= 0) {
          if (variabl23691[j] == null)
           variabl23691[j] = "0";
          s1 = s1 + variabl23691[j];
         } else {
          if (variabl23691[j] == null)
           variabl23691[j] = " ";
          s1 = s1 + "'" + variabl23691[j] + "'";
         }
         if (j != variabl2517[1].length - 1)
          s1 = s1 + ",";
        }
        s1 = s1 + ")";
        stat3.executeUpdate(s1);
       } else {
        s1 = "update " + variabl2603 + " set ";
        for (int k6 = 0; k6 < variabl2517[1].length; k6++) {
         s1 = s1 + variabl2517[1][k6] + "=";
         if (variabl25111.lastIndexOf(","
           + variabl1501[k6] + ",") >= 0) {
          if (variabl23691[k6] == null)
           variabl23691[k6] = "0";
          s1 = s1 + variabl23691[k6];
         } else {
          if (variabl23691[k6] == null)
           variabl23691[k6] = " ";
          s1 = s1 + "'" + variabl23691[k6] + "'";
         }
         if (k6 != variabl2517[1].length - 1)
          s1 = s1 + ",";
        }
        s2 = " where ";
        for (int k = 0; k < variabl2053.length; k++) {
         s2 = s2 + variabl20531[k] + "='"
           + variabl23691[variabl12871[k]]
           + "'";
         if (k < variabl2053.length - 1)
          s2 = s2 + " and ";
        }
        s1 = s1 + s2;
        stat3.executeUpdate(s1);

        stat3.close();
        con.close();
       }
      } catch (SQLException e1) {
       JOptionPane.showMessageDialog(null,
         "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
      }
      k1 = 0;
     }
     fs.close();
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
    } catch (IOException e2) {
     e2.printStackTrace();
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
   variabl2225.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl2225);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl1891 = new JButton(variabl2405[2]);
  variabl1891.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     FileReader fs = new FileReader(variabl1339);
     BufferedReader br = new BufferedReader(fs);
     String tempStr = null;
     String[] variabl23691 = new String[variabl2651];
     int k2 = 0, k5 = 0;
     char x6 = '"';
     for (int i = 0; (tempStr = br.readLine()) != null; i++) {
      k5 = 0;
      variabl23691 = tempStr.split(",");
      for (int j = 0; j < variabl2651; j++) {
       if (variabl23691[j].lastIndexOf("" + x6) >= 0)
        variabl23691[j] = variabl23691[j].substring(1,
          variabl23691[j].length() - 1);
      }
      s3 = "";
      for (int k3 = 0; k3 < variabl2053.length; k3++)
       s3 = s3 + variabl23691[variabl1287[k3]].trim();
      k2 = 0;
      for (int j1 = 0; j1 < variabl1853; j1++) {
       s2 = "";
       for (int k4 = 0; k4 < variabl2053.length; k4++)
        s2 = s2
          + variabl2197[j1][variabl1287[k4]]
            .trim();
       if (s3.trim().equals(s2.trim())) {
        k2 = j1;
        k5 = 1;
       }
      }
      try {
       main1.driver1();
       con = main1.getConn();
       stat3 = con.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
       if (k5 == 0) {
        s1 = "insert into " + variabl2603 + " (";
        for (int k6 = 0; k6 < variabl2517[1].length; k6++)
         s1 = s1 + variabl2517[1][k6] + ",";
        s1 = s1.substring(0, s1.length() - 1)
          + " ) values (";
        for (int j = 0; j < variabl2517[1].length; j++) {
         if (variabl25111.lastIndexOf(","
           + variabl1501[j] + ",") >= 0) {
          if (variabl23691[j] == null)
           variabl23691[j] = "0";
          s1 = s1 + variabl23691[j];
         } else {
          if (variabl23691[j] == null)
           variabl23691[j] = " ";
          s1 = s1 + "'" + variabl23691[j] + "'";
         }
         if (j != variabl2517[1].length - 1)
          s1 = s1 + ",";
        }
        s1 = s1 + ")";
        stat3.executeUpdate(s1);
       } else {
        s1 = "update " + variabl2603 + " set ";
        for (int k6 = 0; k6 < variabl2517[1].length; k6++) {
         s1 = s1 + variabl2517[1][k6] + "=";
         if (variabl25111.lastIndexOf(","
           + variabl1501[k6] + ",") >= 0) {
          if (variabl23691[k6] == null)
           variabl23691[k6] = "0";
          s1 = s1 + variabl23691[k6];
         } else {
          if (variabl23691[k6] == null)
           variabl23691[k6] = " ";
          s1 = s1 + "'" + variabl23691[k6] + "'";
         }
         if (k6 != variabl2517[1].length - 1)
          s1 = s1 + ",";
        }
        s2 = " where ";
        for (int k = 0; k < variabl2053.length; k++) {
         s2 = s2 + variabl20531[k] + "='"
           + variabl23691[variabl12871[k]]
           + "'";
         if (k < variabl2053.length - 1)
          s2 = s2 + " and ";
        }
        s1 = s1 + s2;
        stat3.executeUpdate(s1);
        stat3.close();
        con.close();
       }
      } catch (SQLException e1) {
       JOptionPane.showMessageDialog(null,
         "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
      }
     }
     fs.close();
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
    } catch (IOException e2) {
     e2.printStackTrace();
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
   variabl1891.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1891);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl1403 = new JButton(variabl2405[3]);
  variabl1403.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符", "");
     FileReader fs = new FileReader(variabl1339);
     BufferedReader br = new BufferedReader(fs);
     String tempStr = null;
     String[] variabl23691 = new String[variabl2651];
     int k2 = 0, k5 = 0;
     String s5 = "";
     String x6 = "", x7 = null;
     char x1 = 13;
     for (int i = 0; (tempStr = br.readLine()) != null; i++) {
      k5 = 0;
      x6 = tempStr;
      while (x6.indexOf("】【") < 0) {
       if ((tempStr = br.readLine()) != null) {
        x6 = x6 + x1 + tempStr;
        i++;
       }
      }
      x6 = x6.substring(0, x6.length() - 2);
      variabl23691 = x6.split(x5);
      s3 = "";
      for (int k3 = 0; k3 < variabl2053.length; k3++)
       s3 = s3 + variabl23691[variabl1287[k3]].trim();
      k2 = 0;
      for (int j1 = 0; j1 < variabl1853; j1++) {
       s2 = "";
       for (int k4 = 0; k4 < variabl2053.length; k4++)
        s2 = s2
          + variabl2197[j1][variabl1287[k4]]
            .trim();
       if (s3.trim().equals(s2.trim())) {
        k2 = j1;
        k5 = 1;
       }
      }
      try {
       main1.driver1();
       con = main1.getConn();
       stat3 = con.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
       if (k5 == 0) {
        s1 = "insert into " + variabl2603 + " (";
        for (int k6 = 0; k6 < variabl2517[1].length; k6++)
         s1 = s1 + variabl2517[1][k6] + ",";
        s1 = s1.substring(0, s1.length() - 1)
          + " ) values (";
        for (int j = 0; j < variabl2517[1].length; j++) {
         if (variabl25111.lastIndexOf(","
           + variabl1501[j] + ",") >= 0) {
          if (variabl23691[j] == null)
           variabl23691[j] = "0";
          s1 = s1 + variabl23691[j];
         } else {
          if (variabl23691[j] == null)
           variabl23691[j] = " ";
          s1 = s1 + "'" + variabl23691[j] + "'";
         }
         if (j != variabl2517[1].length - 1)
          s1 = s1 + ",";
        }
        s1 = s1 + ")";
        stat3.executeUpdate(s1);
       } else {
        s1 = "update " + variabl2603 + " set ";
        for (int k6 = 0; k6 < variabl2517[1].length; k6++) {
         s1 = s1 + variabl2517[1][k6] + "=";
         if (variabl25111.lastIndexOf(","
           + variabl1501[k6] + ",") >= 0) {
          if (variabl23691[k6] == null)
           variabl23691[k6] = "0";
          s1 = s1 + variabl23691[k6];
         } else {
          if (variabl23691[k6] == null)
           variabl23691[k6] = " ";
          s1 = s1 + "'" + variabl23691[k6] + "'";
         }
         if (k6 != variabl2517[1].length - 1)
          s1 = s1 + ",";
        }
        s2 = " where ";
        for (int k = 0; k < variabl2053.length; k++) {
         s2 = s2 + variabl20531[k] + "='"
           + variabl23691[variabl12871[k]]
           + "'";
         if (k < variabl2053.length - 1)
          s2 = s2 + " and ";
        }
        s1 = s1 + s2;
        stat3.executeUpdate(s1);
        stat3.close();
        con.close();
       }
      } catch (SQLException e1) {
       JOptionPane.showMessageDialog(null,
         "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
      }
     }
     fs.close();
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
    } catch (IOException e2) {
     e2.printStackTrace();
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
   variabl1403.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1403);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl1163 = new JButton(variabl2405[4]);
  variabl1163.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    Statement stat3;
    try {
     DocumentBuilderFactory factory = DocumentBuilderFactory
       .newInstance();
     DocumentBuilder db = factory.newDocumentBuilder();
     Document doc = db.parse(new File(variabl1339));
     Element elmtInfo = doc.getDocumentElement();
     NodeList nodes = elmtInfo.getChildNodes();
     String[] variabl25170 = new String[variabl2651];
     String[] variabl2369 = new String[variabl2651];
     String[] variabl23691 = new String[variabl2651];
     int k = 0, k1 = 0, k2 = 0, k5 = 0;
     for (int i = 0; i < nodes.getLength(); i++) {
      k5 = 0;
      NodeList ns = nodes.item(i).getChildNodes();
      k = 0;
      for (int j2 = 0; j2 < variabl2651; j2++)
       variabl23691[j2] = "";
      k1 = 0;
      for (int j = 0; j < ns.getLength(); j++) {
       Node record = ns.item(j);
       if (record.toString().lastIndexOf("null") > 0) {
        variabl25170[k] = ns
          .item(j)
          .toString()
          .substring(
            1,
            record.toString().lastIndexOf(
              ":"));
        variabl2369[k] = record.getTextContent();
        for (int j2 = 0; j2 < variabl2651; j2++) {
         if (variabl2517[1][j2]
           .lastIndexOf(variabl25170[k]) >= 0) {
          variabl23691[j2] = variabl2369[k];
          break;
         }
        }
        k++;
        k1 = 1;
       }
      }
      if (k1 > 0) {
       s3 = "";
       for (int k3 = 0; k3 < variabl2053.length; k3++)
        s3 = s3 + variabl23691[variabl1287[k3]].trim();
       k2 = 0;
       for (int j1 = 0; j1 < variabl1853; j1++) {
        s2 = "";
        for (int k4 = 0; k4 < variabl2053.length; k4++)
         s2 = s2
           + variabl2197[j1][variabl1287[k4]]
             .trim();
        if (s3.trim().equals(s2.trim())) {
         k2 = j1;
         k5 = 1;
        }
       }
       try {
        main1.driver1();
        con = main1.getConn();
        stat3 = con.createStatement(
          ResultSet.TYPE_SCROLL_INSENSITIVE,
          ResultSet.CONCUR_UPDATABLE);
        if (k5 == 0) {
         s1 = "insert into " + variabl2603 + " (";
         for (int k6 = 0; k6 < variabl2517[1].length; k6++)
          s1 = s1 + variabl2517[1][k6] + ",";
         s1 = s1.substring(0, s1.length() - 1)
           + " ) values (";
         for (int j = 0; j < variabl2517[1].length; j++) {
          if (variabl25111.lastIndexOf(","
            + variabl1501[j] + ",") >= 0) {
           if (variabl23691[j] == null)
            variabl23691[j] = "0";
           s1 = s1 + variabl23691[j].trim();
          } else {
           if (variabl23691[j] == null)
            variabl23691[j] = " ";
           s1 = s1 + "'"
             + variabl23691[j].trim()
             + "'";
          }
          if (j != variabl2517[1].length - 1)
           s1 = s1 + ",";
         }
         s1 = s1 + ")";
         stat3.executeUpdate(s1);
        } else {
         s1 = "update " + variabl2603 + " set ";
         for (int k6 = 0; k6 < variabl2517[1].length; k6++) {
          s1 = s1 + variabl2517[1][k6] + "=";
          if (variabl25111.lastIndexOf(","
            + variabl1501[k6] + ",") >= 0) {
           if (variabl23691[k6] == null)
            variabl23691[k6] = "0";
           s1 = s1 + variabl23691[k6].trim();
          } else {
           if (variabl23691[k6] == null)
            variabl23691[k6] = " ";
           s1 = s1 + "'"
             + variabl23691[k6].trim()
             + "'";
          }
          if (k6 != variabl2517[1].length - 1)
           s1 = s1 + ",";
         }
         s2 = " where ";
         for (int k7 = 0; k7 < variabl2053.length; k7++) {
          s2 = s2
            + variabl20531[k7]
            + "='"
            + variabl23691[variabl12871[k7]]
              .trim() + "'";
          if (k7 < variabl2053.length - 1)
           s2 = s2 + " and ";
         }
         s1 = s1 + s2;
         stat3.executeUpdate(s1);
         stat3.close();
         con.close();
        }
       } catch (SQLException e1) {
        JOptionPane.showMessageDialog(null,
          "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
       }
      }
     }
    } catch (ParserConfigurationException e1) {
     e1.printStackTrace();
    } catch (SAXException e2) {
     e2.printStackTrace();
    } catch (IOException e3) {
     e3.printStackTrace();
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 0)) {
   variabl1163.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1163);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton exitButton = new JButton(variabl2405[5]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    frame.setVisible(false);
    frame.dispose();
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",5,") >= 0)) {
   exitButton
     .setBounds(variabl1423, variabl2503 - 80, variabl2339, 20);
   panel.add(exitButton);
   variabl1423 = variabl1423 + variabl2339;
  }
  main1.driver1();
  frame.add(panel);
  frame.setVisible(true);
}
}
50.源码50，部件程序，覆盖式从office文件，包括word、excel、pdf文件导入数据导入部件。
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.io.File.*;
import javax.swing.*;
import javax.swing.table.*;
import java.sql.*;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hwpf.extractor.WordExtractor;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;

/**
* 程序文件名：dataTransfer10.java 作者：程学先功能：覆盖式从office文件，包括word、excel、pdf文件导入。
* 原目的表内容将删除。目的表与源表数据类型、数据宽度应当对应相容。完成日期：2013年1月22日
* 被调用语句：dataTransfer10.means(parameter) 必须提供的参数：数据“表名”、“导入文件名”。
*/

public class dataTransfer10 extends JFrame {
static dataTransfer10 frame = new dataTransfer10();
private static JTable table;
static Connection con1;
static String url;
static ResultSetMetaData rsmd4;
static PreparedStatement pstmt;
static Statement sta4;
static ResultSet rs;
static int variabl2483 = 800, variabl2503 = 600;
static int variabl2651;
static int variabl26511;
static String[][] variabl2517;
static String[] variabl25171;
static int[] variabl1065;
static String[] variabl1913;
static String[] variabl1501;
static String[] variabl1169;
static int[] variabl1489, variabl1571;
static int variabl1853 = 0, variabl18531 = 0;
static int[] variabl1119, variabl1125;
static int variabl1527;
static String[][] variabl2197;
static DefaultTableModel model;
static String variabl2603;
static String variabl1873;
static String variabl1339;
static String[] variabl2405 = null;
static String variabl1187;
static String variabl1735;
public static String[] sw = new String[11];
static String s1 = "", s2 = "", s3 = "";
static String s4 = " ";
static char x1 = 10, x2 = 13, x3 = '"', x4 = ',';
static String variabl25111 = main1.variabl25111;
static int variabl2851 = 0, variabl2339 = 0;

public static void means(String[] parameter) {
  frame = new dataTransfer10();
  variabl2483 = 800;
  variabl2503 = 600;
  variabl1853 = 0;
  variabl18531 = 0;
  s1 = "";
  s2 = "";
  s3 = "";
  s4 = "                                                  ";
  x1 = 10;
  x2 = 13;
  x3 = '"';
  x4 = ',';
  variabl25111 = main1.variabl25111;
  File file = new File(".\\com\\iText-5.0.5.jar");
  if (!file.exists()) {
   JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中！");
   return;
  }
  file = new File(".\\com\\jacob.jar");
  if (!file.exists()) {
   JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中！");
   return;
  }
  file = new File(".\\com\\poi-3.8-20120326.jar");
  if (!file.exists()) {
   JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中！");
   return;
  }
  file = new File(".\\com\\PDFBox-0.7.3.jar");
  if (!file.exists()) {
   JOptionPane.showMessageDialog(null, "请将有关jar文件包下载到com文件夹中！");
   return;
  }
  sw = new String[11];
  sw[1] = main1.sw1 + "";
  sw[2] = main1.sw2;
  sw[3] = main1.sw3;
  sw[4] = main1.sw4;
  sw[5] = main1.sw5;
  sw[6] = main1.sw6;
  sw[7] = main1.sw7;
  sw[8] = main1.sw8;
  sw[9] = main1.sw9;
  sw[10] = main1.sw10;
  main1.sw1 = 0;
  main1.sw2 = "";
  main1.sw3 = "";
  main1.sw4 = "";
  main1.sw5 = "";
  main1.sw6 = "";
  main1.sw7 = "";
  main1.sw8 = "";
  main1.sw9 = "";
  main1.sw10 = "";
  variabl2603 = parameter[4];
  variabl1735 = parameter[8];
  variabl1339 = parameter[18];
  String[] variabl240501 = { "从word导入", "从excel导入", "从PDF文件导入", "退出" };
  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) {
  }
  String variabl1633 = parameter[19].trim();
  if ((variabl1633.length() > 0)
    && (variabl1633.substring(variabl1633.length() - 1).equals(",")))
   variabl1633 = variabl1633.substring(0, variabl1633.length() - 1);
  String variabl2429 = parameter[0];
  String[] l3 = variabl1633.split(",");
  variabl1873 = "";
  String[] t1;
  int b = 0, c = 0;
  if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) {
   t1 = variabl2429.split(",");
   for (int i = 0; i < t1.length; i++)
    if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0)
     variabl1873 = t1[i];
  }
  String[] l1;
  if (variabl1735.length() > 0) {
   l1 = variabl1735.split(",");
   int[] l2 = new int[l1.length];
   for (int i = 0; i < l1.length; i++) {
    l2[i] = Integer.valueOf(l1[i]);
   }
   variabl2651 = l1.length;
   variabl2517 = new String[2][variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = l3[l2[i]];
    variabl2517[1][i] = variabl2517[0][i];
   }
  } else {
   variabl2651 = l3.length;
   variabl2517 = new String[2][variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = l3[i];
    variabl2517[1][i] = variabl2517[0][i];
   }
  }
  s1 = "";
  for (int i = 0; i < variabl2651; i++)
   s1 = s1 + variabl2517[0][i] + ",";
  s1 = s1.substring(0, s1.length() - 1);
  try {
   if (("," + variabl2429).lastIndexOf("," + variabl2603 + ",") >= 0) {
    con1 = main1.getConn();
    sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select " + s1 + " from " + variabl2603;
    if ((sw[3].length() > 0) && (sw[4].length() > 0))
     s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";
   } else {
    JOptionPane.showMessageDialog(null, "目的数据表不存在，不能导入！");
    return;
   }
   ResultSet rs = sta4.executeQuery(s1);
   rsmd4 = rs.getMetaData();
   variabl2651 = rsmd4.getColumnCount();
   variabl2517 = new String[2][variabl2651];
   variabl1501 = new String[variabl2651];
   variabl1489 = new int[variabl2651];
   for (int i = 0; i < variabl2651; i++) {
    variabl2517[0][i] = rsmd4.getColumnName(i + 1);
    variabl2517[1][i] = variabl2517[0][i];
    variabl1501[i] = rsmd4.getColumnTypeName(i + 1);
    variabl1489[i] = rsmd4.getColumnDisplaySize(i + 1);
    if (variabl1489[i] < variabl2517[0][i].length())
     variabl1489[i] = variabl2517[0][i].length();
    if (variabl1489[i] < variabl2517[1][i].length())
     variabl1489[i] = variabl2517[1][i].length();
    if (variabl1489[i] > 50)
     variabl1489[i] = 50;
   }
   variabl1913 = new String[variabl2651];
   variabl1169 = new String[variabl2651];
   variabl1119 = new int[variabl2651];
   for (b = 0; b < variabl2651; b++) {
    variabl1913[b] = variabl2517[1][b];
    variabl1119[b] = variabl1489[b];
   }
   variabl1853 = 0;
   rs.last();
   variabl1853 = rs.getRow();
   variabl2197 = new String[variabl1853][variabl2651];
   rs.absolute(1);
   c = 0;
   b = 0;
   while (c < variabl1853) {
    rs.absolute(c + 1);
    while (b < variabl2651) {
     variabl2197[c][b] = rs.getString(b + 1);
     b++;
    }
    c++;
    b = 0;
   }
   rs.close();
   sta4.close();
   con1.close();
  } catch (SQLException e) {
   JOptionPane.showMessageDialog(null, "读取数据出错！");
  }
  if (variabl1873.length() > 0) {
   try {
    con1 = main1.getConn();
    sta4 = con1.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
      ResultSet.CONCUR_UPDATABLE);
    s1 = "select * from " + variabl1873;
    rs = sta4.executeQuery(s1);
    String s4 = "";
    String s5 = "";
    b = 1;
    while (rs.absolute(b)) {
     b++;
     s4 = rs.getString(1);
     s5 = rs.getString(2);
     for (int j = 0; j < variabl2651; j++) {
      if (variabl2517[0][j].trim().equals(s4.trim())) {
       variabl2517[1][j] = s5;
       variabl1913[j] = s5;
       break;
      }
     }
    }
    rs.close();
    con1.close();
    sta4.close();
   } catch (SQLException e) {
    JOptionPane.showMessageDialog(null, "连接数据库出错！");
   }
  }
  frame.setTitle("数据覆盖式从office文件导入部件。                           作者：程学先");
  frame.setBounds(10, 10, variabl2483, variabl2503);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.setLayout(null);
  final JPanel panel = new JPanel(false);
  panel.setLayout(null);
  panel.setBounds(10, 10, variabl2483, variabl2503);
  final JScrollPane scrollPane = new JScrollPane();
  scrollPane.setBounds(0, 0, variabl2483 - 20, variabl2503 - 100);
  panel.add(scrollPane);
  model = new DefaultTableModel(variabl2197, variabl2517[1]);
  table = new JTable(model);
  table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
  for (int i = 0; i < variabl2651; i++) {
   TableColumn tc = table.getColumn(variabl2517[1][i]);
   tc.setPreferredWidth(variabl1489[i] * 14);
   tc.setMaxWidth(variabl1489[i] * 14);
   tc.sizeWidthToFit();
  }
  scrollPane.setViewportView(table);
  variabl2339 = (variabl2483 - 60) / variabl2851;
  int variabl1423 = 30;

  JButton variabl1439 = new JButton(variabl2405[0]);
  variabl1439.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    variabl1527 = model.getRowCount();
    if (variabl1339.length() == 0) {
     variabl1339 = JOptionPane.showInputDialog(
       "请输入导入文件完整路径例如：F:\\java.doc", "");
     return;
    }
    int p1 = 0, p2 = 0;
    if (variabl1339.lastIndexOf(".doc") < 0) {
     p1 = variabl1339.lastIndexOf(".");
     p2 = variabl1339.lastIndexOf("\\\\");
     if (p2 > p1) {
      variabl1339 = variabl1339 + ".doc";
      variabl1339 = variabl1339.replace("\\.", "\\.\\.");
     } else {
      variabl1339 = variabl1339.substring(0, p1) + ".doc";
     }
    }
    try {
     FileInputStream in = new FileInputStream(new File(
       variabl1339));
     WordExtractor extractor = null;
     extractor = new WordExtractor(in);
     String variabl2581 = extractor.getText();
     int m1 = 0;
     ;
     String[] variabl2615 = new String[variabl2651];
     int k = 0;
     int k2 = 0, k5 = 0;
     variabl2615[k] = "";
     for (int i = 0; i < variabl2581.length(); i++) {
      if (variabl2581.charAt(i) == '\r') {
       k5 = 0;
       model.addRow(variabl2615);
       variabl1853++;
       variabl2615[0] = "";
       k = 0;
       m1 = 1;
       if ((i < variabl2581.length() - 2)
         && (variabl2581.charAt(i + 2) == '\r'))
        break;
      } else if (variabl2581.charAt(i) == '\n') {
      } else if ((byte) (variabl2581.charAt(i)) == 9) {
       k++;
       m1 = 0;
       if (k < variabl2651)
        variabl2615[k] = "";
      } else if (k < variabl2651) {
       variabl2615[k] = variabl2615[k]
         + variabl2581.charAt(i);
      }
     }
    } catch (Exception e1) {
     JOptionPane.showMessageDialog(null, "读取数据出错！");
    }
    try {
     main1.driver1();
     con1 = main1.getConn();
     sta4 = con1.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     s1 = "delete from " + variabl2603;
     sta4.executeUpdate(s1);
     sta4.close();
     con1.close();
    } catch (SQLException e1) {
    }
    try {
     main1.driver1();
     con1 = main1.getConn();
     sta4 = con1.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     for (int i = 0; i < model.getRowCount(); i++) {
      s1 = "insert into " + variabl2603 + " (";
      for (int k1 = 0; k1 < variabl2517[1].length; k1++)
       s1 = s1 + variabl2517[1][k1] + ",";
      s1 = s1.substring(0, s1.length() - 1) + " ) values (";
      for (int j = 0; j < variabl2517[1].length; j++) {
       if (variabl25111.lastIndexOf("," + variabl1501[j]
         + ",") >= 0) {
        if (model.getValueAt(i, j) == null)
         s1 = s1 + "0";
        else
         s1 = s1
           + model.getValueAt(i, j).toString()
             .trim();
       } else {
        if (model.getValueAt(i, j) == null)
         s1 = s1 + " ";
        else
         s1 = s1
           + "'"
           + model.getValueAt(i, j).toString()
             .trim() + "'";
       }
       if (j != variabl2517[1].length - 1)
        s1 = s1 + ",";
      }
      s1 = s1 + ")";
      sta4.executeUpdate(s1);
     }
     sta4.close();
     con1.close();
    } catch (SQLException e1) {
     JOptionPane.showMessageDialog(null,
       "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {
   variabl1439.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1439);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl1141 = new JButton(variabl2405[1]);
  variabl1141.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    variabl1527 = model.getRowCount();
    if (variabl1339.length() == 0) {
     variabl1339 = JOptionPane.showInputDialog(
       "请输入导入文件完整路径例如：F:\\java.xls", "");
     return;
    }
    int p1 = 0, p2 = 0;
    if (variabl1339.lastIndexOf(".xls") < 0) {
     p1 = variabl1339.lastIndexOf(".");
     p2 = variabl1339.lastIndexOf("\\\\");
     if (p2 > p1) {
      variabl1339 = variabl1339 + ".xls";
      variabl1339 = variabl1339.replace("\\.", "\\.\\.");
     } else {
      variabl1339 = variabl1339.substring(0, p1) + ".xls";
     }
    }
    InputStream is = null;
    HSSFWorkbook wbWorkbook = null;
    try {
     is = new FileInputStream(variabl1339);
     wbWorkbook = new HSSFWorkbook(is);
    } catch (FileNotFoundException e1) {
     e1.printStackTrace();
     JOptionPane.showMessageDialog(null, "读取文件失败，请检查路径是否正确！",
       "错误", JOptionPane.INFORMATION_MESSAGE);
    } catch (IOException e2) {
     e2.printStackTrace();
    }
    HSSFSheet sheet = wbWorkbook.getSheetAt(0);
    int lastRowNum = sheet.getLastRowNum();
    int variabl1157 = sheet.getPhysicalNumberOfRows();
    HSSFRow row = sheet.getRow(1);
    int variabl1185 = row.getPhysicalNumberOfCells();
    if (variabl1185 != variabl2651)
     JOptionPane.showMessageDialog(null, "原文件中数据结构与数据表不同！");
    String[] val;
    int k2 = 0, k5 = 0;
    String value = "";
    for (int i = 0; i < variabl1157; i++) {
     row = sheet.getRow(i);
     if (row != null) {
      for (int j = 0; j < variabl1185; j++) {
       HSSFCell cell = row.getCell(j);
       if (cell != null) {
        switch (cell.getCellType()) {
        case HSSFCell.CELL_TYPE_FORMULA:
         break;
        case HSSFCell.CELL_TYPE_NUMERIC:
         value += cell.getNumericCellValue() + ",";
         break;
        case HSSFCell.CELL_TYPE_STRING:
         value += cell.getStringCellValue() + ",";
         break;
        default:
         value += "0";
         break;
        }
       }
      }
      val = value.split(",");
      k5 = 0;
      model.addRow(val);
      value = "";
     }
    }
    try {
     main1.driver1();
     con1 = main1.getConn();
     sta4 = con1.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     s1 = "delete from " + variabl2603;
     sta4.executeUpdate(s1);
     sta4.close();
     con1.close();
    } catch (SQLException e1) {
    }
    try {
     main1.driver1();
     con1 = main1.getConn();
     sta4 = con1.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     for (int i = variabl1527 + 1; i < model.getRowCount(); i++) {
      s1 = "insert into " + variabl2603 + " (";
      for (int k1 = 0; k1 < variabl2517[1].length; k1++)
       s1 = s1 + variabl2517[1][k1] + ",";
      s1 = s1.substring(0, s1.length() - 1) + " ) values (";
      for (int j = 0; j < variabl2517[1].length; j++) {
       if (variabl25111.lastIndexOf("," + variabl1501[j]
         + ",") >= 0) {
        if (model.getValueAt(i, j) == null)
         s1 = s1 + "0";
        else
         s1 = s1
           + model.getValueAt(i, j).toString()
             .trim();
       } else {
        if (model.getValueAt(i, j) == null)
         s1 = s1 + "' '";
        else
         s1 = s1
           + "'"
           + model.getValueAt(i, j).toString()
             .trim() + "'";
       }
       if (j != variabl2517[1].length - 1)
        s1 = s1 + ",";
      }
      s1 = s1 + ")";
      sta4.executeUpdate(s1);
     }
     sta4.close();
     con1.close();
    } catch (SQLException e1) {
     JOptionPane.showMessageDialog(null,
       "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {
   variabl1141.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl1141);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton variabl2095 = new JButton(variabl2405[2]);
  variabl2095.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    variabl1527 = model.getRowCount();
    if (variabl1339.length() == 0) {
     variabl1339 = JOptionPane.showInputDialog(
       "请输入导入文件完整路径例如：F:\\java.pdf", "");
     return;
    }
    int p1 = 0, p2 = 0;
    if (variabl1339.lastIndexOf(".pdf") < 0) {
     p1 = variabl1339.lastIndexOf(".");
     p2 = variabl1339.lastIndexOf("\\\\");
     if (p2 > p1) {
      variabl1339 = variabl1339 + ".xls";
      variabl1339 = variabl1339.replace("\\.", "\\.\\.");
     } else {
      variabl1339 = variabl1339.substring(0, p1) + ".pdf";
     }
    }
    try {
     FileInputStream in = new FileInputStream(variabl1339);
     PDFParser parser = new PDFParser(in);
     parser.parse();
     PDDocument pdfdocument = parser.getPDDocument();
     PDFTextStripper stripper = new PDFTextStripper();
     s1 = stripper.getText(pdfdocument);
     in.close();
    } catch (Exception e1) {
     e1.printStackTrace();
    }
    String[] variabl2615 = new String[variabl2651];
    String s4 = "";
    int k = 0, m1 = 0, k2 = 0, k5 = 0;
    variabl2615[0] = "";
    int l1 = s1.length();
    for (int i1 = 0; i1 < l1; i1++) {
     s2 = s1.substring(i1, i1 + 1);
     if (s1.charAt(i1) == '\r') {
     } else if (s1.charAt(i1) == '\n') {
     } else if ((s2.trim().equals("│")) && (m1 == 1)) {
      if (k == variabl2651 - 1) {
       k5 = 0;
       model.addRow(variabl2615);
       k = 0;
       m1 = 0;
       variabl2615[k] = "";
      } else {
       k++;
       if (k < variabl2651)
        variabl2615[k] = "";
      }
     } else if (s2.trim().equals("│")) {
      m1 = 1;
      k = 0;
      variabl2615[0] = "";
     } else if ((k < variabl2651) && (m1 == 1)) {
      try {
       variabl2615[k] = variabl2615[k] + s2;
      } catch (Exception e1) {
      }
     }
    }
    try {
     main1.driver1();
     con1 = main1.getConn();
     sta4 = con1.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     s1 = "delete from " + variabl2603;
     sta4.executeUpdate(s1);
     sta4.close();
     con1.close();
    } catch (SQLException e1) {
    }
    try {
     main1.driver1();
     con1 = main1.getConn();
     sta4 = con1.createStatement(
       ResultSet.TYPE_SCROLL_INSENSITIVE,
       ResultSet.CONCUR_UPDATABLE);
     for (int i = variabl1527 + 1; i < model.getRowCount(); i++) {
      s1 = "insert into " + variabl2603 + " (";
      for (int k1 = 0; k1 < variabl2517[1].length; k1++)
       s1 = s1 + variabl2517[1][k1] + ",";
      s1 = s1.substring(0, s1.length() - 1) + " ) values (";
      for (int j = 0; j < variabl2517[1].length; j++) {
       if (variabl25111.lastIndexOf("," + variabl1501[j]
         + ",") >= 0) {
        if (model.getValueAt(i, j) == null)
         s1 = s1 + "0";
        else
         s1 = s1
           + model.getValueAt(i, j).toString()
             .trim();
       } else {
        if (model.getValueAt(i, j) == null)
         s1 = s1 + " ";
        else
         s1 = s1
           + "'"
           + model.getValueAt(i, j).toString()
             .trim() + "'";
       }
       if (j != variabl2517[1].length - 1)
        s1 = s1 + ",";
      }
      s1 = s1 + ")";
      sta4.executeUpdate(s1);
     }
     sta4.close();
     con1.close();
    } catch (SQLException e1) {
     JOptionPane.showMessageDialog(null,
       "操作出错，请检查数据表名是否重复，录入语句是否正确！" + s1);
    }
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {
   variabl2095.setBounds(variabl1423, variabl2503 - 80, variabl2339,
     20);
   panel.add(variabl2095);
   variabl1423 = variabl1423 + variabl2339;
  }

  JButton exitButton = new JButton(variabl2405[3]);
  exitButton.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent e) {
    if ((sw[2].length() > 0) && (sw[3].length() > 0)
      && (sw[4].length() > 0))
     WorkflowDrivek1.means(sw);
    frame.setVisible(false);
    frame.dispose();
   }
  });
  if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {
   exitButton
     .setBounds(variabl1423, variabl2503 - 80, variabl2339, 20);
   panel.add(exitButton);
   variabl1423 = variabl1423 + variabl2339;
  }
  frame.add(panel);
  frame.setVisible(true);
}
}

转载本文请联系原作者获取授权，同时请注明本文来自程学先科学网博客。
链接地址：https://blog.sciencenet.cn/blog-2551-1118219.html

上一篇：管理信息系统软件生产线源码41-45
下一篇：管理信息系统软件生产线源码51-55

收藏 IP: 183.94.47.*| 热度|

当前推荐数：0

该博文允许注册用户评论请点击登录评论 (0 个评论)

数据加载中...

返回顶部

程学先

扫一扫，分享此博文

发展部件技术分享 http://blog.sciencenet.cn/u/求新研究方向:数据库、MIS,教育部教指委计算机分委会专家工作组成员

博文

管理信息系统软件生产线源码46-50

当前推荐数：0

该博文允许注册用户评论请点击登录评论 (0 个评论)

程学先

全部作者的精选博文

全部作者的其他最新博文

全部精选博文导读

相关博文

发展部件技术分享 http://blog.sciencenet.cn/u/求新 研究方向:数据库、MIS,教育部教指委计算机分委会专家工作组成员

博文

管理信息系统软件生产线源码46-50

当前推荐数：0

该博文允许注册用户评论 请点击登录 评论 (0 个评论)

程学先

全部作者的精选博文

全部作者的其他最新博文

全部精选博文导读

相关博文

发展部件技术分享 http://blog.sciencenet.cn/u/求新研究方向:数据库、MIS,教育部教指委计算机分委会专家工作组成员

该博文允许注册用户评论请点击登录评论 (0 个评论)