版本1

56.源码56，部件程序，高度综合多表导出部件。包括多表数据排序、导出到数据库、导出到txt文件、导出到Office文件等数据导出部件。

/**

 * 程序文件名：dataTransfer18.java

 * 作者：程学先 

 * 功能：高度综合多表导出部件。包括多表数据排序、导出到数据库、导出到txt文件、导出到Office文件等。

 * 导出到数据库操作允许源表字段数多于目的表。包括覆盖、修改、添加三种方式。

 * 覆盖方式将删除目的表原有数据。修改方式将修改关键字相同的记录，录入新关键字记录。

 * 添加方式录入新关键字记录，对于关键字相同的老记录保持不变，而源表中相应记录不被导入目的表，

 * 以防止出现关键字重复的情况。

 * 完成日期：2018年5月22日

 * 被调用语句：dataTransfer18.means(parameter);

 * 必须提供的参数：数据“表名”。

 * 可选择参数：“字段号表”、“要求按钮号表”、“打印格式文件名”。

 * 如果是多字段，以英文逗号分隔。如果不要求导出到数据库，可以不给具体值。

 * 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；

 * 否则写入所有将涉及的字段在表中的顺序后，号与号之间以英文逗号分隔。

 * 本部件预设的按钮控件共5个，序号及按钮名：1排序、2接续排序、3导出到数据库、4导出到txt文件、5导出到office文件、6退出

 * 在入口处通过“要求按钮号表”选择按钮以实现所需要的功能。

 * 排序：要求先点击表格中某一列，将按本列数据从小到大对全表格数据排序。按本按钮后，标签变为还原，再按后恢复原表数据模样。

 * 接续排序：在按“排序”按钮后本按钮激活，如果先点某一列，则会在上一次排序基础上对于上一排序列中值相同者按当前列继续排序。

 * 导出到数据库：将当前显示数据导出到一个数据表中。将提问表名，输入表名后会在当前数据库中查是否存在该表？

 * 如果已经存在该表，会检查字段匹配情况。

 * 如果完全匹配，则提问导入方式：1、删除原表数据，用新表覆盖。2、与原表数据关键字相同者用新数据覆盖，否则添加。

 * 3、除关键字值有重复者外全部添加到原表尾，对于关键字重复的记录不录入，放弃修改。

 * 如果不完全匹配，则先提问：是只导入匹配部分的数据，还是补充添加那些原表中不存在的字段后再导入。之后提问导入方式。

 * 如果数据库中没有该表，将首先新建表，之后将表格中数据全部存到新表中。

 * 导出到txt文件：将提问导出格式：1、每字段值一行导出。2、各字段按设定长度全部以字符串形式导出，每条记录一行，字段数据间无分隔。

 * 3、每条记录一行，数字各类型数据以10进制数据形式表示；其他类型数据均以字符串形式表示，加双引号与逗号分隔。

 * 4、提问分隔符，每条记录一行，各类型数据以自然形式表示，字符串类型数据也不加双引号，字段间加所输入的分隔符分隔。

 * 分隔符可以由多个字符组成，例如：####

 * 导出到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 java.util.*;

import javax.sound.sampled.*;

import com.itextpdf.text.*;

import com.itextpdf.text.Font;

import com.itextpdf.text.pdf.*;

import org.apache.poi.hssf.usermodel.*;

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 dataTransfer18 extends JFrame {

private static JTable table;    //创建表格

  static String DBMS系统=main1.DBMS系统;

static Connection con;    //连接数据库

static String ODBC数据源=main1.ODBC数据源; //ODBC数据源表名，根据用户定义写明

static String url;     //某些数据库的连接URL

static String 表名=main1.表名;      //数据表名

static String 表名表="";

static String 打印格式文件名="";

static String 字典表名=main1.字典表名;//将操作的数据表的字段名说明

static String[] 关键字段名=null;//存放关键字字段名的数组

static String 字段名字串="";

static String[] 字段名串=null;

static int 窗口宽=main1.窗口宽,窗口高=main1.窗口高;//窗口宽、窗口高

    static int 列数=main1.列数;  //数据表列数

    static int 表格列数;

    static String [] 列名;  //数据表列名

    static String 连接条件="";

    static String [] 表格列名; 

    static String [] 列标题;  

    static String[] 列数据类型; //存放当前记录各字段数据类型的数组

    static String[] 表列数据类型;    //存放表格各列数据类型的数组

    static int[] 列数据宽度,列小数位数;   //存放当前记录各字段数据宽度的数组

    static int[] 表列数据宽度;  //存放表格各列数据宽度的数组

static int 记录条数=main1.记录条数,记录条数1=0;   //记录条数

static String[][] 表格数据;//存放表格数据的数组

static String[][] 备份数据; 

static String [] 按钮集=null;

static String 要求按钮号表;

static String 要求字段号表; //需要显示的字段的顺序号

static JButton sortButton1,sortButton,printButton,exitButton;

static JButton 导出1,导出2,导出3;

static String [][] 排序数据; 

static String [][] 排序备份; 

static int 起始序号=0,终了序号=0,当前列号=0,上次列号=0;

static String [] 一条空记录; 

static String[] 关键字段值;

static int[] 关键字序号;  

static int selectedRow=0;

static DefaultTableModel model;

static String [] rowValues=new String[表格列数];  

static String 导出表名="",导出文件名="";

static String s1="",s2="",s3=""; 

static String[] 当前字段值;

static PreparedStatement pstmt;

static Statement sta;

static int 按钮数=0,按钮宽=0;

static Set <String> hs=null;

public static void means(String [] parameter) {

DBMS系统=main1.DBMS系统;

ODBC数据源=main1.ODBC数据源;

表名 = parameter[4]; // 数据表名

表名表 = parameter[0];

要求字段号表 = parameter[8];

打印格式文件名 = parameter[15];

导出表名="";

导出文件名="";

列数=main1.列数;

记录条数=main1.记录条数;记录条数1=0;

连接条件=parameter[20];

字段名字串=parameter[19];

字段名串=parameter[19].split(",");

hs=new HashSet();

    main1.driver1();

String [] 按钮集01={"排序","接续排序","打印","导出到数据表","导出到txt文件","导出到office文件","退出"};

    按钮集=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[8]; 

    String []s6=字段名字串.split(",");

String s02="";

if (parameter[8].length()>0){

String [] 字段号表=parameter[8].split(",");

 列名=new String[字段号表.length];

 for (int i=0;i<字段号表.length;i++){

  列名[i]=s6[Integer.parseInt(字段号表[i])];

  if (s02.length()>0) s02=s02+","+列名[i];

  else s02=列名[i];

 }

 字段名字串=s02;

}

else {

   列名=new String[s6.length];

   for (int i=0;i<s6.length;i++){

    列名[i]=s6[i];

    if (s02.length()>0) s02=s02+","+列名[i];

    else s02=列名[i];

   }

   字段名字串=s02;

}

起始序号=0;终了序号=0;当前列号=0;上次列号=0;

selectedRow=0;

rowValues=new String[表格列数];  

s1="";s2="";s3=""; 

dataTransfer18 frame = new dataTransfer18(); // 创建窗体

frame.setTitle("表格式显示部件之1                           作者：程学先"); // 设置窗体标题

frame.setBounds(10, 10, 窗口宽, 窗口高); // 设置窗体的位置和大小

frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式

DBMS系统=parameter[1];

ODBC数据源=parameter[3];

表名=parameter[4];

if (parameter[6].trim().length()>0) 

关键字段名=parameter[6].split(",");

else 关键字段名=new String[1];

关键字序号=new int[关键字段名.length];

要求字段号表=parameter[8];

    关键字段值=new String[关键字段名.length];

    for (int i=0;i<关键字段名.length;i++){

   关键字段值[i]="";

   关键字序号[i]=0; 

     }

      con=main1.getConn();   

      try {

     Statement sta = con.createStatement(   //建立连接

     ResultSet.TYPE_SCROLL_INSENSITIVE,   

     ResultSet.CONCUR_UPDATABLE);  

       if (连接条件.trim().length()>0)

       s1="select "+字段名字串+" from "+表名+" where "+连接条件;

       else

      s1="select "+字段名字串+" from "+表名;

          ResultSet rs=sta.executeQuery(s1);

          rs.last(); 

          记录条数=rs.getRow();

          ResultSetMetaData rsmd = rs.getMetaData();

      列数=rsmd.getColumnCount();  

      列名=new  String[列数];  //定义列名数组

      列数据类型=new  String[列数];  //定义列字段类型数组

      列数据宽度=new int [列数];  //定义列数据宽度

      列小数位数=new int [列数]; 

     int [] 列序号=new int[列数];

      int b=-1,b0=0;

      要求字段号表=","+要求字段号表+",";

      while(b0<列数) {        

         if ((要求字段号表.length()<3) || (要求字段号表.lastIndexOf(","+(b0+1)+",")>=0))  {

             b=b+1;

                                  列序号[b]=b0;    

         }

         列名[b0]=rsmd.getColumnName(b0+1);

列数据宽度[b0] = 列数据宽度[b0]=rsmd.getColumnDisplaySize(b0+1);//获取列数据宽度

if (列数据宽度[b0] < 列名[b0].length())

列数据宽度[b0] = 列名[b0].length();

if (列数据宽度[b0] < 列名[b0].length())

列数据宽度[b0] = 列名[b0].length();

if (列数据宽度[b0] > 50)

列数据宽度[b0] = 50;

               列小数位数[b0]=rsmd.getScale(b0+1);

            b0++; 

      }

      表格列数=b+1;

      表格列名=new  String[表格列数];  //定义列名数组

      表列数据类型=new  String[表格列数];  //定义列字段类型数组

      表列数据宽度=new int [表格列数];  //定义列数据宽度

      b=0;        //列号

      while(b<表格列数){

     表格列名[b]=列名[列序号[b]];

     表列数据类型[b]=列数据类型[列序号[b]];

     表列数据宽度[b]=列数据宽度[列序号[b]];

     b++;

      }

for (int j = 0; j < 关键字段名.length; j++)

for (int i = 0; i < 表格列数; i++) {

if (关键字段名[j].trim().equals(表格列名[i].trim())) {

关键字序号[j] = i;

break;

}

}

         表格数据=new String[记录条数][表格列数]; 

          rs.absolute(1); 

          int c=0;    //行号

          b=0;        //列号

          while(c<记录条数) {

                rs.absolute(c+1);  

                while(b<表格列数){

                       表格数据[c][b]=rs.getString(列序号[b]+1); 

                       b++;

                }

                c++;

                b=0;

          }     

    rs.close();     //关闭查询结果集

            sta.close();     //关闭连接

        }     

         catch(Exception e1) 

         {

               e1.printStackTrace(); 

         } 

    备份数据=new String[记录条数][表格列数];

       要求按钮号表=","+要求按钮号表+",";

        列标题=new  String[表格列数];

        int b=0;        //列号

        while(b<表格列数){

        列标题[b]=表格列名[b];

         b++;

        }

        if (字典表名.length()>0){

            con=main1.getConn();    

        try{

               Statement sta = con.createStatement(   //建立连接

         ResultSet.TYPE_SCROLL_INSENSITIVE,   

         ResultSet.CONCUR_UPDATABLE);  

             s1="select * from "+字典表名;

                  ResultSet rs=sta.executeQuery(s1);

       while (rs.next()) {        

         String 字段名称 = rs.getString(1);

         String 标签名称 = rs.getString(2);

         b=0;

              while(b<表格列数){

                  if (列标题[b].equals(字段名称)) {

                列标题[b]=标签名称;

                    break;

                }  

                 b++;

               }

       }

            rs.close();     //关闭查询结果集

                sta.close();     //关闭连接

            }

        catch(Exception e1) 

             { e1.printStackTrace();  } 

        }

    final JScrollPane scrollPane = new JScrollPane();

      scrollPane.setBounds(0,0,窗口宽-100,窗口高-100);

        frame.setLayout(null);

        frame.getContentPane().add(scrollPane, BorderLayout.CENTER); 

    model = new DefaultTableModel(表格数据,列标题); 

当前字段值=new String[列标题.length];

final char x1=10,x2=13,x3='"',x4=','; 

    for (int c=0;c<记录条数;c++)

           for (b=0;b<表格列数;b++) 

              备份数据[c][b]=表格数据[c][b];  

              table = new JTable(model);

              table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

              table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

        for(int i=0;i<表格列数;i++) {  

            TableColumn tc = table.getColumn(列标题[i]);

            JTableHeader header = table.getTableHeader();

            tc.setPreferredWidth(表列数据宽度[i]*14);

            tc.setMaxWidth(表列数据宽度[i]*14);

            tc.sizeWidthToFit();

        }

        scrollPane.setViewportView(table); 

    frame.setVisible(true); // 显示窗体

        table.addMouseListener(new MouseAdapter() { 

            public void mouseClicked(MouseEvent e) {

                selectedRow = table.getSelectedRow(); 

          }        

         });

           排序数据=new String[记录条数][表格列数+1];

           排序备份=new String[记录条数][表格列数+1];

           for (b=0;b<表格列数;b++) {

               for (int c=0;c<记录条数;c++){

              if (备份数据[c][b]==null) 排序数据[c][b]="";

              else  排序数据[c][b]=备份数据[c][b];

               }

          if (main1.小数型数据类型.indexOf(","+表列数据类型[b]+",")>=0){

                   for (int c=0;c<记录条数;c++){

                  排序数据[c][b]="0000000000"+排序数据[c][b];

                  int k1=排序数据[c][b].lastIndexOf('.');

                  if (k1==-1){ 

                  k1=排序数据[c][b].length();

                  排序数据[c][b]=排序数据[c][b]+".000000";}

                else 排序数据[c][b]=排序数据[c][b]+"000000";

                  排序数据[c][b]=排序数据[c][b].substring(k1-10,k1+1)

                  +排序数据[c][b].substring(k1+1,k1+6);

                    }

          }

          else if (main1.小数型数据类型.indexOf(","+表列数据类型[b]+",")>=0){

                   for (int c=0;c<记录条数;c++){

                  排序数据[c][b]="0000000000"+排序数据[c][b];

                  排序数据[c][b]=排序数据[c][b].substring(排序数据[c][b].length()-10);

                   }

          }

          }

           for (int c=0;c<记录条数;c++)

          排序数据[c][表格列数]=""+c; 

            for (int c=0;c<记录条数;c++)

               for (b=0;b<表格列数+1;b++) 

              排序备份[c][b]=排序数据[c][b];

          起始序号=0;终了序号=0;

               int 按钮宽=(窗口宽-20)/按钮数;

               int 按钮左边距=5;

        sortButton = new JButton(按钮集[0]);  

         sortButton.addActionListener(new ActionListener() {  

            public void actionPerformed(ActionEvent e) { 

            rowValues=new String[表格列数];  

            if (sortButton.getText().trim().equals("排序")) 

            {

            if (table.getSelectedColumn()<0) 

            JOptionPane.showMessageDialog(null,"请先点击要排序的某一列，再按本按钮！");

            else {

                sortButton.setText("还原");

                sortButton1.setEnabled(true); 

                上次列号=table.getSelectedColumn(); 

                当前列号=table.getSelectedColumn(); 

                }

            String s;

            int i,j,k=0;

            for (int c=0;c<记录条数;c++){

            for (i=0;i<记录条数-c-1;i++){

                if (排序数据[i][当前列号].compareTo(排序数据[i+1][当前列号])>0)

                for (j=0;j<=表格列数;j++){ 

                   s=排序数据[i][j];

                           排序数据[i][j]=排序数据[i+1][j];

                           排序数据[i+1][j]=s;

                }

            }

            }

                 model.setRowCount(0);     

                for (int c=0;c<记录条数;c++){

                int n=Integer.parseInt(排序数据[c][表格列数]);

                for (int b=0;b<表格列数;b++){

                表格数据[c][b]=备份数据[n][b];

                rowValues[b]=备份数据[n][b];

              }

                model.addRow(rowValues);

                }

                }

            else 

            {

            sortButton.setText("排序");

            sortButton1.setEnabled(false); 

            model.setRowCount(0);    

                  for (int c=0;c<记录条数;c++){

                    for (int b=0;b<表格列数;b++){

                    rowValues[b]=备份数据[c][b];

                    排序数据[c][b]=排序备份[c][b];

                  }

                    model.addRow(rowValues);

                    排序数据[c][表格列数]=排序备份[c][表格列数];

                  }

            }}

        });

      if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",0,")>=0)){

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

                 frame.add(sortButton);   

                                              按钮左边距=按钮左边距+按钮宽;

       }

        sortButton1 = new JButton(按钮集[1]); 

       sortButton1.setEnabled(false);  

       sortButton1.addActionListener(new ActionListener() { 

          public void actionPerformed(ActionEvent e) { 

               当前列号=table.getSelectedColumn(); 

          String s="",s2=排序数据[0][上次列号];

          int n1=0,n2=0;

          int i,j,k=0;

          for (int c=0;c<记录条数;c++){

          if ((c==记录条数-1)||(s2.compareTo(排序数据[c+1][上次列号])!=0)){

          if (c<记录条数-1) 

          s2=排序数据[c+1][上次列号];

             n2=c;

          for (i=n1;i<n2;i++){   

          for (j=n1;j<n2+n1-i;j++){

              if (排序数据[j][当前列号].compareTo(排序数据[j+1][当前列号])>0)

              for (k=0;k<=表格列数;k++){

                 s=排序数据[j][k];

                         排序数据[j][k]=排序数据[j+1][k];

                         排序数据[j+1][k]=s;

              }

            }

        }

            n1=n2+1;  

          }

          }

             上次列号=当前列号; 

          model.setRowCount(0);    

            for (int c=0;c<记录条数;c++){

            int n=Integer.parseInt(排序数据[c][表格列数]); 

            for (int b=0;b<表格列数;b++){

            rowValues[b]=备份数据[n][b];

          }

            model.addRow(rowValues);

            }

          }

      });

     if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",1,")>=0)){

               sortButton1.setBounds(按钮左边距,窗口高-80,按钮宽-5,20); 

               frame.add(sortButton1);    

                                        按钮左边距=按钮左边距+按钮宽;

     }

        

       JButton Button11 = new JButton(按钮集[2]);

        if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",2,")>=0)){

            Button11.setBounds(按钮左边距,窗口高-80,按钮宽-5,20);         

            frame.add(Button11);   

                                     按钮左边距=按钮左边距+按钮宽;

        }

              Button11.addActionListener(new ActionListener() {

              public void actionPerformed(ActionEvent e) {

  try {

if (打印格式文件名.trim().length() == 0)

table.print();

else

dataPreview1.printView1(表格数据, 打印格式文件名);

} catch (Exception e1) {

JOptionPane.showMessageDialog(null, "打印失败！");

}

             }

              });

  

    JButton Button12 = new JButton(按钮集[3]);   //导出到数据表

     if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",3,")>=0)){

         Button12.setBounds(按钮左边距,窗口高-80,按钮宽-5,20);      

         frame.add(Button12);  

                                  按钮左边距=按钮左边距+按钮宽;

         }

     Button12.addActionListener(new ActionListener() {

           public void actionPerformed(ActionEvent e) {

int k = 0;

int k0 = 0;

if ((导出表名==null)||(导出表名.length() == 0)){

导出表名 = JOptionPane.showInputDialog("请输入数据表名称", "");

}

k = 0;

if ((导出表名!=null)&&(("," + 表名表 + ",").lastIndexOf(导出表名) >= 0))

k = 1;

if (k == 0) {     //导出到新表

       if (连接条件.trim().length()>0)

       s1="select "+字段名字串+" into " + 导出表名 + " from "+表名+" where "+连接条件;

       else

      s1="select "+字段名字串+" into " + 导出表名 +" from "+表名;

try {

con = main1.getConn();

if (!con.isClosed()) {

Statement rsmd = con.createStatement();

rsmd.executeUpdate(s1);

}

} catch (Exception e1) {

e1.printStackTrace();

}

return; // 完成导入

}

String[] 导出表列名=null;

String 导出表列名1="";

int[] 匹配字段序号 = null;

int 匹配字段数 = 0;

con = main1.getConn(); //导出到已有表，读导出表结构与关键字数据

s1 = "select * from " + 导出表名;

try {

Statement sta = con.createStatement(

// 建立连接

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

ResultSet rs = sta.executeQuery(s1);

ResultSetMetaData rsmd = rs.getMetaData();

int 导出表列数 = rsmd.getColumnCount(); // 获取列数

导出表列名 = new String[导出表列数]; // 欲导入表结构

int b0 = 0;

while (b0 < 导出表列数) {

导出表列名[b0] = rsmd.getColumnName(b0 + 1); // 获取列名存到数组中

if (导出表列名1.length()==0)

导出表列名1=导出表列名1+导出表列名[b0];

else 导出表列名1=导出表列名1+","+导出表列名[b0];

b0++;

}

rs.last();

int rows=rs.getRow();   //目的表记录数

String [][] s4=new String[rows][导出表列数];//目的表数据

rs.absolute(1);

int i1=0;

String s6="";//s6关键字值集

while (i1<rows){ 

for(int j=0;j<导出表列数;j++){

s4[i1][j]=rs.getString(j+1);

}

i1++;

rs.next();

}

for (int i=0;i<rows;i++){

for (int i2=0;i2<关键字序号.length;i2++){

for(int j=0;j<导出表列数;j++){

if (导出表列名[j].equals(列名[关键字序号[i2]])){

s6=s6+s4[i][j]+",";  //关键字值集

}

}

}

hs.add(s6);  //目的表关键字值集合

s6="";

}

//以下检查字段名匹配情况

int k1 = 0;

String[] 不匹配列名 = new String[导出表列数]; // 准备保存未找到的字段名

int[] 不匹配序号 = new int[导出表列数]; // 准备保存未找到的字段在表格中序号

匹配字段序号 = new int[表格列数];

匹配字段数 = 0;

String 类型0 = "";

for (int i = 0; i < 表格列数; i++) {

k = 0;

for (int j = 0; j < 导出表列数; j++){

if (表格列名[i].equals(导出表列名[j])) {

k = 1;

break;

}

}

if (k == 0) {

不匹配列名[k1] = 表格列名[i];//导出表没有，源数据有的字段

不匹配序号[k1] = i;

k1++;

} else {

匹配字段序号[匹配字段数] = i;

匹配字段数++;

}

}

String[] options = new String[] { "在导出表中增加这些字段",

"只导出同名字的字段值", "退出" };

int num = 0;

if (k1 > 0) {  //导入字段情况存在不匹配

num = JOptionPane.showOptionDialog(null,

"有些字段在导出目标表中不存在，请定处理方式？", "选择字段匹配方式",

JOptionPane.YES_NO_CANCEL_OPTION,

JOptionPane.INFORMATION_MESSAGE, null,

options, "只导出同名字的字段值");

if (options[num].trim().equals("退出"))

return;

if (options[num].trim().equals("在导出表中增加这些字段")) {

try {

con = main1.getConn(); // 调用前面方法连接数据库

if (!con.isClosed()) {

Statement rsmd1 = con.createStatement();

for (int i = 0; i < k1; i++) {

类型0 = 表列数据类型[不匹配序号[i]];

s1 = "ALTER TABLE  " + 导出表名+ "  ADD  " + 不匹配列名[i]

+ " " + 类型0;

导出表列名1=导出表列名1+","+不匹配列名[i];

if (main1.类型.indexOf(","+类型0+",") >= 0)

s1 = s1+ "("+ ("" + 表列数据宽度[不匹配序号[i]])+ ")";

else if (main1.小数型数据类型.indexOf(","+类型0+",")>=0)

s1 = s1+ "("+ ("" + 表列数据宽度[不匹配序号[i]])

+ "," + 列小数位数[不匹配序号[i]]+ ")";

匹配字段序号[匹配字段数] = 不匹配序号[i];

匹配字段数++;

rsmd1.executeUpdate(s1);  //补充列

}

for (int i = 0; i < 匹配字段数; i++) {

}

}

} catch (Exception e1) {

e1.printStackTrace();

}

}

}

rs.close(); // 关闭查询结果集

sta.close(); // 关闭连接

} catch (Exception e1) {

e1.printStackTrace();

}

String[] options = new String[] { "覆盖原表数据", "替代原记录", "添加到原表尾",

"退出" };

int num = JOptionPane.showOptionDialog(null,

"是否复盖原表内容（原表数据将删除）？", "选择导出方式",

JOptionPane.YES_NO_CANCEL_OPTION,

JOptionPane.INFORMATION_MESSAGE, null, options,

"覆盖原表数据");

if (options[num].trim().equals("退出"))

return;

if (options[num].trim().equals("替代原记录"))

k0 = 1;

if (options[num].trim().equals("添加到原表尾"))

k0 = 2;

if (options[num].trim().equals("覆盖原表数据")) {

con = main1.getConn();

s1 = "delete from " + 导出表名;

try {

sta = con.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

pstmt = con.prepareStatement(s1);

pstmt.execute();

con.close();

sta.close();

} catch (Exception e2) {

e2.printStackTrace();

}

}

导出表列名=导出表列名1.split(",");

if (k0 == 0) {       //覆盖原纪录

String s3 = "(";

for (int i = 0; i < 匹配字段数; i++) { // 字段序号

s3 = s3 + 列名[匹配字段序号[i]];

if (i < 匹配字段数 - 1)

s3 = s3 + ",";

else

s3 = s3 + ")";

}

String sp = "";

int k1=0;

for (int j = 0; j < 记录条数; j++) {

s1 = "";

for (int i = 0; i < 导出表列名.length; i++) { // 字段序号

for (k1=0;k1<列名.length;k1++){

if (列名[k1].equals(导出表列名[i]))

break;

}

sp = 表格数据[j][k1];

if (sp == null)

sp = "";

if (main1.数字数据类型.indexOf(","+表列数据类型[k1]+",")>=0) {

if (sp.length() == 0)

sp = "0";

s1 = s1 + sp;

} else {

s1 = s1 + "'" + sp + "'";

}

if (i < 匹配字段数 - 1)

s1 = s1 + ",";

}

s1 = "insert into " + 导出表名 +" ("+导出表列名1+") " + " values  (" + s1+ ")";

try {

                            con = main1.getConn();

pstmt = con.prepareStatement(s1);

pstmt.execute();

con.close();

} catch (Exception e2) {

e2.printStackTrace();

}

}

}

else {               //修改式导入或添加式导入

con = main1.getConn(); // 连接数据库

try {

s1 = "";

int j = 0;

String s6="",s7="",s8=""; //在导出表中不要有点，在源表中要带表名带点

for (int i1=0;i1<表格数据.length;i1++){

selectedRow=i1;

s1="";s7="";s8="";s6="";

for (int i = 0; i < 关键字段名.length; i++) {

关键字段名[i]=列名[关键字序号[i]];   //s5

关键字段值[i] = model.getValueAt(selectedRow, 关键字序号[i])

.toString();// 取当前行关键字值

if ((关键字段值[i]==null)||(关键字段值[i].length()==0)){

JOptionPane.showMessageDialog(null, "关键字数据欠缺！");

return;

}

s6=s6+关键字段值[i]+",";

if (关键字段名[i].indexOf(".")>0){

  s1 = s1 + 关键字段名[i] + "='" + 关键字段值[i] + "' ";

  s7=s7 + 关键字段名[i].substring(关键字段名[i].lastIndexOf(".")+1,关键字段名[i].length()) + "='" + 关键字段值[i] + "' ";

} else {

  s1 = s1 + 关键字段名[i] + "='" + 关键字段值[i] + "' ";

  s7 = s7 + 关键字段名[i] + "='" + 关键字段值[i] + "' ";

}

if (i < 关键字段名.length - 1){

s1 = s1 + " and ";

s7 = s7 + " and ";

}

}

int n1=hs.size();   //当前SET集合中元素个数

hs.add(s6);

s3 = " where " + s7;

s1 = "";

s2 = " set ";

int k2=0;

for (k2=0;k2<导出表列名.length;k2++){   //导出表序号

                          for (int i = 0; i < 列数; i++) {    //源表序号

if (列名[i].equals(导出表列名[k2])){

                               s8=列名[i];

if (s8.indexOf(".")>0)

s8=s8.substring(s8.lastIndexOf(".")+1,s8.length());

if (model.getValueAt(selectedRow, i) == null)

当前字段值[i] = "";   //当前字段值[k2] = "";

else 当前字段值[i] = model.getValueAt(selectedRow, i).toString();

if (main1.数字数据类型.indexOf(","+列数据类型[i]+",")>=0) {

if (当前字段值[i].length() == 0)

当前字段值[i] = "0";

s1 = s1 + 当前字段值[i];

s2 = s2 + s8 + "=" + 当前字段值[i];

} else {

s1 = s1 + "'" + 当前字段值[i] + "'";

s2 = s2 + s8 + "='" + 当前字段值[i] + "'";

}

if (k2 < 导出表列名.length - 1) {

s1 = s1 + ",";

s2 = s2 + ",";

}

}

}

}

if (n1 != hs.size()) {  //新关键字在SET集合中不存在

s1 = "insert into " + 导出表名 +" ("+导出表列名1+") " + " values  (" + s1+ ")";

                                pstmt = con.prepareStatement(s1);

                                pstmt.execute();

} else if (k0==1)   //添加方式对于关键字重复的记录不录入，放弃修改

{

s1 = "update " + 导出表名 + s2 + s3;

                                pstmt = con.prepareStatement(s1);

                                pstmt.execute();

}

}

con.close();

} catch (Exception e2) {

e2.printStackTrace();

}

}

           }

           });

           

  JButton Button13 = new JButton(按钮集[4]);   //导出到txt文件

  if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",4,")>=0)){

      Button13.setBounds(按钮左边距,窗口高-80,按钮宽-5,20);    

      frame.add(Button13);    

                               按钮左边距=按钮左边距+按钮宽;

    }

        Button13.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

if (导出文件名.length() == 0)

导出文件名 = JOptionPane.showInputDialog("请输入导出文件名名称", "");

String[] options = new String[] { "每字段数据一行", "定长等长每记录一行",

"逗号分隔", "自定义符号分隔", "退出" };

int num = JOptionPane.showOptionDialog(null, "是否按每字段数据一行？",

"选择导出文件格式", JOptionPane.YES_NO_CANCEL_OPTION,

JOptionPane.INFORMATION_MESSAGE, null, options,

"覆盖原表数据");

if (options[num].trim().equals("退出"))

return;

else if (options[num].trim().equals("每字段数据一行")) {

try {

File file = new File(导出文件名);

if (!file.exists()) {

file.createNewFile();

}

char x1 = 10, x2 = 13;

FileOutputStream fs = new FileOutputStream(file);

for (int j1 = 0; j1 < 记录条数; j1++)

for (int j2 = 0; j2 < 表格列数; j2++) {

fs.write((表格数据[j1][j2] + x2).getBytes());

}

fs.close();// 释放资源

} catch (FileNotFoundException e1) {

e1.printStackTrace();

} catch (IOException e2) {

e2.printStackTrace();

}

}

else if (options[num].trim().equals("定长等长每记录一行")) {

try {

File file = new File(导出文件名);

if (!file.exists()) {

file.createNewFile();

}

FileOutputStream fs = new FileOutputStream(file);

for (int j1 = 0; j1 < 记录条数; j1++)

for (int j2 = 0; j2 < 表格列数; j2++) {

fs.write(表格数据[j1][j2].getBytes());

}

fs.close();// 释放资源

} catch (FileNotFoundException e1) {

e1.printStackTrace();

} catch (IOException e2) {

e2.printStackTrace();

}

} else if (options[num].trim().equals("逗号分隔")) {

try {

File file = new File(导出文件名);

if (!file.exists()) {

file.createNewFile();

}

int length = 0;

char x1 = 10, x2 = 13, x3 = '"', x4 = ',';

FileOutputStream fs = new FileOutputStream(file);

for (int j1 = 0; j1 < 记录条数; j1++) {

for (int j2 = 0; j2 < 表格列数; j2++)

if (j2 < (表格列数 - 1))

fs.write((x3 + 表格数据[j1][j2] + x3 + x4)

.getBytes());

else

fs.write((x3 + 表格数据[j1][j2] + x3)

.getBytes());

fs.write(("" + x1).getBytes());

}

fs.close();// 释放资源

} catch (FileNotFoundException e1) {

e1.printStackTrace();

} catch (IOException e2) {

e2.printStackTrace();

}

} else {

try {

File file = new File(导出文件名);

if (!file.exists()) {

file.createNewFile();

}

int length = 0;

char x1 = 10, x2 = 13, x3 = '"', x4 = ',';

String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符","");

FileOutputStream fs = new FileOutputStream(file);

for (int j1 = 0; j1 < 记录条数; j1++) {

for (int j2 = 0; j2 < 表格列数; j2++)

if (j2 < (表格列数 - 1))

fs.write((表格数据[j1][j2] + x5).getBytes());

else

fs.write(表格数据[j1][j2].getBytes());

fs.write(("" + x1).getBytes());

}

fs.close();

} catch (FileNotFoundException e1) {

e1.printStackTrace();

} catch (IOException e2) {

e2.printStackTrace();

}

}

       }

        });

        

        JButton Button14 = new JButton(按钮集[5]);   //导出到office文件

         if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",5,")>=0)){

          Button14.setBounds(按钮左边距,窗口高-80,按钮宽-5,20);    

             frame.add(Button14);   

                            按钮左边距=按钮左边距+按钮宽;

        }

       Button14.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

String[] options = new String[] { "导出到Word文件", "导出到Excel文件",

"导出到Pdf文件", "退出" };

int num = JOptionPane.showOptionDialog(null, "", "选择导出文件格式",

JOptionPane.YES_NO_CANCEL_OPTION,

JOptionPane.INFORMATION_MESSAGE, null, options,

"导出到Word文件");

if (options[num].trim().equals("退出"))

return;

else if (options[num].trim().equals("导出到Word文件")) {

final JFileChooser fc = new JFileChooser(".\\");

fc.showOpenDialog(null);

if (fc.getSelectedFile() != null) {

s1 = fc.getSelectedFile().toString();

s2 = "";

for (int i = 0; i < s1.length(); i++)

if (s1.substring(i, i + 1).equals("\\"))

s2 = s2 + "\\" + "\\";

else

s2 = s2 + s1.substring(i, i + 1);

}

导出文件名 = s2;

int p1 = 0, p2 = 0;

if (导出文件名.lastIndexOf(".doc") < 0) {

p1 = 导出文件名.lastIndexOf(".");

p2 = 导出文件名.lastIndexOf("\\\\");

if (p2 > p1) {

导出文件名 = 导出文件名 + ".doc";

导出文件名 = 导出文件名.replace("\\.", "\\.\\.");

} else {

导出文件名 = 导出文件名.substring(0, p1) + ".doc";

}

}

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 i = 0; i < 表格数据.length; i++) {

for (int j = 0; j < 列数; j++) {

if (表格数据[i][j] == null)

表格数据[i][j] = "";

Dispatch table = Dispatch.call(tables, "Item",

new Variant(1)).toDispatch();

Dispatch cell = Dispatch.call(table, "Cell",

new Variant(i + 1), new Variant(j + 1))

.toDispatch();

Dispatch.call(cell, "Select");

s1 = "" + 表格数据[i][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");

}

} else if (options[num].trim().equals("导出到Excel文件")) {

final JFileChooser fc = new JFileChooser(".\\");

fc.showOpenDialog(null);

if (fc.getSelectedFile() != null) {

s1 = fc.getSelectedFile().toString();

s2 = "";

for (int i = 0; i < s1.length(); i++)

if (s1.substring(i, i + 1).equals("\\"))

s2 = s2 + "\\" + "\\";

else

s2 = s2 + s1.substring(i, i + 1);

}

导出文件名 = s2;

int p1 = 0, p2 = 0;

if (导出文件名.lastIndexOf(".xls") < 0) {

p1 = 导出文件名.lastIndexOf(".");

p2 = 导出文件名.lastIndexOf("\\\\");

if (p2 > p1) {

导出文件名 = 导出文件名 + ".xls";

导出文件名 = 导出文件名.replace("\\.", "\\.\\.");

} else {

导出文件名 = 导出文件名.substring(0, p1) + ".xls";

}

}

HSSFWorkbook book = new HSSFWorkbook();

HSSFSheet 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 < 记录条数; j++) {

HSSFRow row = sheet.createRow(j);

for (int i = 0; i < colCount; i++) {

HSSFCell cell = row.createCell(i);

cell.setCellValue(new HSSFRichTextString(表格数据[j][i]));

}

}

try {

FileOutputStream fileO = new FileOutputStream(导出文件名);

book.write(fileO);

fileO.close();

} catch (Exception e1) {

e1.printStackTrace();

}

} else if (options[num].trim().equals("导出到Pdf文件")) {

final JFileChooser fc = new JFileChooser(".\\");

fc.showOpenDialog(null);

if (fc.getSelectedFile() != null) {

s1 = fc.getSelectedFile().toString();

s2 = "";

for (int i = 0; i < s1.length(); i++)

if (s1.substring(i, i + 1).equals("\\"))

s2 = s2 + "\\" + "\\";

else

s2 = s2 + s1.substring(i, i + 1);

}

导出文件名 = s2;

int p1 = 0, p2 = 0;

if (导出文件名.lastIndexOf(".pdf") < 0) {

p1 = 导出文件名.lastIndexOf(".");

p2 = 导出文件名.lastIndexOf("\\\\");

if (p2 > p1) {

导出文件名 = 导出文件名 + ".pdf";

导出文件名 = 导出文件名.replace("\\.", "\\.\\.");

} else {

导出文件名 = 导出文件名.substring(0, p1) + ".pdf";

}

}

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 k = 0; k < 列数据宽度[j]; k++)

s1 = s1 + "─";

if (j != 列数 - 1)

s1 = s1 + "┬";

}

s1 = s1 + "┐";

document.add(new Paragraph(s1, font));

String s4 = "", s5 = "";

float lengtg1 = 0;

for (int i = 0; i < 记录条数; i++) {

s1 = "│";

for (int j = 0; j < 表格数据[0].length; j++) {

s3 = "";

if (表格数据[i][j] == null)

表格数据[i][j] = " ";

s4 = 表格数据[i][j];

lengtg1 = 0;

for (int j1 = 0; j1 < 表格数据[i][j].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 < 记录条数 - 1) {

s1 = "├";

for (int j = 0; j < 列数; j++) {

for (int k = 0; k < 列数据宽度[j]; k++)

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 k = 0; k < 列数据宽度[j]; k++)

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();

}

} 

    });

       

        exitButton = new JButton(按钮集[6]);

        exitButton.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                System.exit(0);

        }

       });

       if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",6,")>=0)){

       exitButton.setBounds(按钮左边距,窗口高-80,按钮宽-5,20);   

       frame.add(exitButton);   

                                  按钮左边距=按钮左边距+按钮宽;

      }

     }

   } 

57.源码57，部件程序，对全表若干字段进行求和或求平均或求最大或最小或记录条数或标准偏差或填充标准偏差或统计方差或填充统计方差等数据统计部件。

/**

 * 程序文件名：dataStatistic1.java

 * 作者：程学先

 * 完成时间：2013年12月3日

 * 功能：对全表若干字段进行求和或求平均或求最大或最小或记录条数或标准偏差或填充标准偏差

 * 或统计方差或填充统计方差等，统计数据添加在数据表最后一行中。

 * 被调用语句：dataStatistic1.means(parameter)。

 * 必须提供的参数：“表名”、要求统计的字段“统计字段名集”、统计类型要求“统计项目类型”。

 * 可选择参数：要求显示的字段号表、按钮号表。

 * 本程序包括：统计、打印预览、打印、导出、退出等5个按钮。

 * 其中打印要求要求先利用程序printFormat1.java生成格式文件

 * 操作方法与注意事项：在“统计字段名集”处可以输入多个字段名，将对各字段分别统计。

 * 在“统计项目”处的参数只能从{求和、求平均、求最大、求最小、求记录数、求统计标准偏差stdev、

 * 求填充统计标准偏差stdevp、求统计方差var、求填充统计方差varp}中选择一个。

 * 本程序应用计算方法求有关统计值。

 * 可以联系代码表、字典表进行查询。

 * 如果涉及代码表，在生成菜单程序时，在填表名时，应当先在列表框中选主表，再依次选代码表。

 * 如果涉及字典表，将根据字典表给定的对应关系变换标签。

 * 要求在当前数据库中有一个表的名字为某某某字典表，

 * 即表名最后3个字是“字典表”，本程序将根据该表变换。

 * 要求该表中只有二个字段，第一个字段（命名为字段名）中内容为所查询的数据表中字段名，

 * 第二个字段（命名为标签名）内容为变换后的标签名。

*/

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.table.*;

import java.sql.*;

public class dataStatistic1 extends JFrame {

    static dataStatistic1 frame = new dataStatistic1(); 

    static String 表名; 

    static String 字典表名; 

    static String 表名表;

    static DefaultTableModel tableModel;  

    static JTable table;

    static JScrollPane scrollPane = new JScrollPane();  

     static String s1=""; 

    static ResultSet rs; 

    static int b=0,c=0; 

    static int 列数; 

    static String[][] 列名; 

    static String[] 列数据类型; 

    static int[] 列数据宽度; 

    static int 记录条数; 

    static String[][] 表格数据;// 存放表格数据的数;

    static String[][] 表格数据1;

    static String 统计字段;

    static String 字段号表;

    static String 统计要求;

    static int [] 统计字段号;

    static String 连接条件;

    static String 字段名字串;

    static String 按钮号表;

    static int 左边距=80;

    static Connection con; // 连接数据库

    static ResultSetMetaData rsmd3;

    static Statement sta3;

    static int 窗口宽 = 1000, 窗口高 = 600;//窗口高

static String [] 按钮集=null;

static String 要求按钮号表;

static int 按钮数=0,按钮宽=0;

 

public static void means(String[] parameter) {

frame = new dataStatistic1();

scrollPane = new JScrollPane();

窗口宽 = 1000;

窗口高 = 600;// 窗口高

String[] 按钮集01 = { "统       计", "打印预览", "打   印", "导       出","退            出" };

按钮集 = new String[按钮集01.length];

按钮数 = 0;

for (int i0 = 0; i0 < 按钮集01.length; i0++)

按钮集[i0] = 按钮集01[i0];

if (parameter[11].length() > 0) {

要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号

// 将中文分号、冒号、句号、英文分号统一为英文分号

要求按钮号表 = 要求按钮号表.replaceAll("；", ";");

要求按钮号表 = 要求按钮号表.replaceAll("。", ";");

要求按钮号表 = 要求按钮号表.replaceAll(":", ";");

要求按钮号表 = 要求按钮号表.replaceAll("：", ";");

if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求

String s601[] = 要求按钮号表.split(",");

要求按钮号表 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (s601[i01].indexOf(";") > 0) {

String s602[] = s601[i01].split(";");

按钮集[Integer.parseInt((s602[0]))] = s602[1];

要求按钮号表 = 要求按钮号表 + "," + s602[0];// 只留号，去更名

按钮数++;

} else {

要求按钮号表 = 要求按钮号表 + "," + s601[i01];// 只留号，原无更名

按钮数++;

}

}

} // 如果没有按钮更名要求，要求按钮号长度又大于0，保持原有摸样

else {

String s601[] = 要求按钮号表.split(",");

要求按钮号表 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (i01 == 0)

要求按钮号表 = s601[i01];

else

要求按钮号表 = 要求按钮号表 + "," + s601[i01];

按钮数++;

}

}

} else {

要求按钮号表 = ""; // 没输入要求按钮号，定全部按钮号

for (int i1 = 0; i1 < 按钮集.length; i1++) {

if (i1 == 0)

要求按钮号表 = 要求按钮号表 + i1;

else

要求按钮号表 = 要求按钮号表 + "," + i1;

按钮数++;

}

}

要求按钮号表 = "," + 要求按钮号表 + ",";

窗口宽 = main1.窗口宽;

窗口高 = main1.窗口高;

int m1, m2;

try {

if (parameter[17].length() == 0) {

m1 = 0;

m2 = 0;

} else {

m1 = Integer.parseInt(parameter[17]);// 宽度参数

m2 = Integer.parseInt(parameter[18]);

}

if (m1 > 0) {

if (m2 < 80) {

m1 = m1 * 10;

m2 = m2 * 10;

}

窗口宽 = m1;

窗口高 = m2;

}

} catch (Exception e2) {

}

frame = new dataStatistic1();

scrollPane = new JScrollPane();

窗口宽 = 1000;

窗口高 = 600;// 窗口高;

统计要求 = parameter[13];

表名 = parameter[4];

连接条件 = parameter[20];

字段名字串 = parameter[19];

if (字段名字串.lastIndexOf(",") == 字段名字串.length() - 1)

字段名字串 = 字段名字串.substring(0, 字段名字串.length() - 1);

表名表 = parameter[0];

字段号表 = parameter[8];

统计字段 = parameter[9];

按钮号表 = "," + parameter[11] + ",";

字典表名 = "";

String[] t1;

String s11 = 表名;

if (表名.indexOf(",") > 0) {

String[] s12 = 表名.split(",");

s11 = s12[0];

}

if (表名表.lastIndexOf(s11 + "字典表") > 0) {

t1 = 表名表.split(",");

for (int i = 0; i < t1.length; i++)

if (t1[i].lastIndexOf(s11 + "字典表") >= 0)

字典表名 = t1[i];

}

String[] l1;

String[] l3 = 字段名字串.split(",");

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 {

con = main1.getConn();// 连接数据库

sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s = "";

if (表名.lastIndexOf(",") > 0)

s = "select " + s1 + " from " + 表名 + " where " + 连接条件;

else

s = "select " + s1 + " from " + 表名;

ResultSet rs = sta3.executeQuery(s);

rsmd3 = rs.getMetaData();

列数 = rsmd3.getColumnCount(); // 获取列数

列名 = new String[2][列数]; // 定义列名数组

列数据类型 = new String[列数]; // 定义列字段类型数组

列数据宽度 = new int[列数]; // 定义列数据宽度

for (int i = 0; i < 列数; i++) {

列名[0][i] = rsmd3.getColumnName(i + 1); // 获取列名存到数组中

列名[1][i] = 列名[0][i];

列数据类型[i] = rsmd3.getColumnTypeName(i + 1);

列数据宽度[i] = rsmd3.getColumnDisplaySize(i + 1);

b++;

}

rs.last();

记录条数 = rs.getRow();

表格数据 = new String[记录条数][列数];

表格数据1 = new String[记录条数 + 1][列数];

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(); // 关闭查询结果集

sta3.close(); // 关闭连接

con.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "查询数据出错！");

}

s1 = "";

if (字典表名.length() > 0) {

try {

con = main1.getConn();

sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + 字典表名;

rs = sta3.executeQuery(s1);

ResultSetMetaData rsmd = rs.getMetaData();

int numberOfColumns = rsmd.getColumnCount(); // 记录数

String s4 = "";

String s5 = "";

int 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(); // 关闭查询结果集

con.close();

sta3.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "连接数据库出错！" + s1);

}

}

String[] s7 = 字段名字串.split(",");

String s4[];

s4 = 统计字段.split(",");

for (int i = 0; i < s4.length; i++)

s4[i] = s7[Integer.parseInt(s4[i])];

统计字段号 = new int[s4.length];

for (int i = 0; i < s4.length; i++) {

for (int j = 0; j < 列数; j++) {

if (s4[i].trim().equalsIgnoreCase(列名[0][j].trim()))

统计字段号[i] = j;

}

for (int j = 0; j < 记录条数; j++)

if ((表格数据[j][统计字段号[i]] == null)

|| (表格数据[j][统计字段号[i]].length() < 1))

表格数据[j][统计字段号[i]] = "0";

}

frame.setTitle("查询统计部件程序                                作者：程学先"); // 窗口标题

frame.setBounds(10, 10, 窗口宽 - 10, 窗口高 - 10); // 窗口位置大小

frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame.getContentPane().setLayout(null); // 关闭窗口布局管理器

final JPanel panel = new JPanel(false); // 定义面板

panel.setLayout(null); // 关闭面板布局管理器

panel.setBounds(20, 20, 窗口宽 - 50, 窗口高 - 20);

tableModel = new DefaultTableModel(表格数据, 列名[1]); // 创建表格模型

table = new JTable(tableModel);

table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

scrollPane.getViewport().add(table, null);

scrollPane.setBounds(30, 30, 窗口宽 - 100, 窗口高 - 200);

panel.add(scrollPane);

int j = 0;

if (按钮号表.length() < 3)

j = 5;

else

for (int i = 0; i < 5; i++)

if (按钮号表.lastIndexOf("," + i + ",") >= 0)

j = j + 1;

int 按钮宽 = (窗口宽 - 80) / 按钮数;

int 按钮左边距 = 5;

按钮号表 = 要求按钮号表;

JButton 统计 = new JButton(按钮集[0]);

统计.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

String[] 记录 = new String[列数];

double[] x0 = new double[列数];

double[][] x1 = new double[tableModel.getRowCount()][列数];

double[] x2 = new double[列数];

double[] x3 = new double[列数];

for (int i = 0; i < 列数; i++)

记录[i] = "";

if (("求最大,求最小,求记录数,求和,求平均").lastIndexOf(统计要求) >= 0) {

if (统计要求.trim().equals("求最小"))

for (int k = 0; k < 统计字段号.length; k++) { // 按统计字段

x2[统计字段号[k]] = Double.parseDouble(表格数据[0][统计字段号[k]]);

}

for (int i = 0; i < tableModel.getRowCount(); i++) {

for (int k = 0; k < 统计字段号.length; k++) { // 按表格

x1[i][统计字段号[k]] = Double.parseDouble(表格数据[i][统计字段号[k]]);

}

if (统计要求.trim().equals("求记录数"))

for (int k = 0; k < 统计字段号.length; k++) {

x2[统计字段号[k]] = tableModel.getRowCount();

}

else if (统计要求.trim().equals("求最大")) {

for (int k1 = 0; k1 < 统计字段号.length; k1++) {

if (x2[统计字段号[k1]] < x1[i][统计字段号[k1]])

x2[统计字段号[k1]] = x1[i][统计字段号[k1]];

}

}

else if (统计要求.trim().equals("求最小")) {

for (int k1 = 0; k1 < 统计字段号.length; k1++) {

if (x2[统计字段号[k1]] > x1[i][统计字段号[k1]])

x2[统计字段号[k1]] = x1[i][统计字段号[k1]];

}

}

else {

for (int k0 = 0; k0 < 统计字段号.length; k0++) {

x2[统计字段号[k0]] = x2[统计字段号[k0]]+ x1[i][统计字段号[k0]];

}

}

}

for (int k = 0; k < 统计字段号.length; k++) {

x0[统计字段号[k]] = x2[统计字段号[k]] / tableModel.getRowCount();

if (统计要求.trim().equals("求平均"))

x2[统计字段号[k]] = x0[统计字段号[k]];

}

for (int k1 = 0; k1 < 统计字段号.length; k1++) {

记录[统计字段号[k1]] = "" + x2[统计字段号[k1]];

}

tableModel.addRow(记录);

}

else { // 非基本统计

for (int k = 0; k < 统计字段号.length; k++) { // 按统计字段

x2[统计字段号[k]] = Double.parseDouble(表格数据[0][统计字段号[k]]);

}

for (int i = 0; i < tableModel.getRowCount(); i++) {

for (int k = 0; k < 统计字段号.length; k++) { // 按表格

x1[i][统计字段号[k]] = Double.parseDouble(表格数据[i][统计字段号[k]]);

}

}

for (int i = 0; i < tableModel.getRowCount(); i++)

for (int k1 = 0; k1 < 统计字段号.length; k1++) {

x2[统计字段号[k1]] = (x1[i][统计字段号[k1]] - x0[统计字段号[k1]])

* (x1[i][统计字段号[k1]] - x0[统计字段号[k1]]);

x3[统计字段号[k1]] = x3[统计字段号[k1]] + x2[统计字段号[k1]];

}

if ((统计要求.trim().equalsIgnoreCase("求统计标准偏差stdev"))

|| ((统计要求.trim().equalsIgnoreCase("求统计方差"))))

for (int k1 = 0; k1 < 统计字段号.length; k1++) {

x2[统计字段号[k1]] = Math.sqrt(x3[统计字段号[k1]]

/ (tableModel.getRowCount() - 1));

}

else if ((统计要求.trim().equalsIgnoreCase("求填充统计标准偏差stdevp"))

|| ((统计要求.trim().equalsIgnoreCase("求填充统计方差"))))

for (int k1 = 0; k1 < 统计字段号.length; k1++) {

x2[统计字段号[k1]] = Math.sqrt(x3[统计字段号[k1]]

/ tableModel.getRowCount());

}

if (((统计要求.trim().equalsIgnoreCase("求统计方差var")))

|| (统计要求.trim().equalsIgnoreCase("求填充统计方差varp")))

for (int k1 = 0; k1 < 统计字段号.length; k1++) {

x2[统计字段号[k1]] = x2[统计字段号[k1]] * x2[统计字段号[k1]];

}

for (int k1 = 0; k1 < 统计字段号.length; k1++)

记录[统计字段号[k1]] = "" + x2[统计字段号[k1]];

tableModel.addRow(记录);

}

for (int i = 0; i < tableModel.getRowCount(); i++)

for (int j = 0; j < 列数; j++)

if (tableModel.getValueAt(i, j) == null)

表格数据1[i][j] = " ";

else

表格数据1[i][j] = tableModel.getValueAt(i, j)

.toString().trim();

}

});

if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",0,") >= 0)) {

统计.setBounds(按钮左边距, 窗口高 - 150, 按钮宽, 20);

panel.add(统计);

按钮左边距 = 按钮左边距 + 按钮宽;

}

JButton 打印预览 = new JButton(按钮集[1]);

打印预览.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

dataPreview0.printView1(列名[1], 表格数据1, 列数据宽度, 表名);

}

});

if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",1,") >= 0)) {

打印预览.setBounds(按钮左边距, 窗口高 - 150, 按钮宽, 20);

panel.add(打印预览);

按钮左边距 = 按钮左边距 + 按钮宽;

}

JButton 打印 = new JButton(按钮集[2]);

打印.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

dataPrint0.printView1(列名[1], 表格数据1, 列数据宽度, 表名);

}

});

if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",2,") >= 0)) {

打印.setBounds(按钮左边距, 窗口高 - 150, 按钮宽, 20);

panel.add(打印);

按钮左边距 = 按钮左边距 + 按钮宽;

}

JButton 导出 = new JButton(按钮集[3]);

导出.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

for (int i = 0; i < 列名[1].length; i++)

dataTransfer0.Trans(列名[1], 列数据类型, 列数据宽度, "", 表格数据1, 表名);

}

});

if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",3,") >= 0)) {

导出.setBounds(按钮左边距, 窗口高 - 150, 按钮宽, 20);

panel.add(导出);

按钮左边距 = 按钮左边距 + 按钮宽;

}

JButton 退出 = new JButton(按钮集[4]);

退出.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

frame.setVisible(false);

frame.dispose();

}

});

if ((按钮号表.length() < 3) || (按钮号表.lastIndexOf(",4,") >= 0)) {

退出.setBounds(按钮左边距, 窗口高 - 150, 按钮宽, 20);

panel.add(退出);

按钮左边距 = 按钮左边距 + 按钮宽;

}

frame.getContentPane().add(panel, null);

frame.setVisible(true);

frame.getContentPane().add(panel, BorderLayout.SOUTH);

 }

     }

58.源码58，部件程序，分组统计。对全表按某些字段分组后对每组及全部数据的若干字段进行求和或求平均或求最大或最小或记录条数或标准偏差或填充标准偏差或统计方差或填充统计方差或ABC分类等分组数据统计部件。

/**

 * 程序文件名：dataStatistic2.java

 * 作者：程学先

 * 完成时间：2013年12月3日

 * 功能：分组统计。对全表按某些字段分组后对每组及全部数据的若干字段进行求和或求平均或求最大

 * 或最小或记录条数或标准偏差或填充标准偏差 或统计方差或填充统计方差等，

 * 统计数据添加在数据表每组后和最后一行中。

 * 被调用语句：dataStatistic2.means(parameter)。

 * 必须提供的参数：“表名”、要求统计的字段“统计字段名集”、统计类型要求“统计项目类型”、“分组字段名”。

 * 可选择参数：要求显示的字段号表、按钮号表。

 * 其中打印要求要求先利用程序printFormat1.java生成格式文件

 * 在“字统计字段名集”处可以输入多个字段名，为准备求和等统计的字段名。

 * 在“分组字段名”处可以输入多个字段名，为分组要求的字段名。

 * 在“统计项目”处的参数只能从{求和、求平均、求最大、求最小、求记录数、求平均偏差、求相对偏差、

 * 求统计标准偏差stdev、求填充统计标准偏差stdevp、求统计方差var、求填充统计方差varp、ABC分类}

 * 等11个选项中选择一个。

 * 本程序应用计算方法求有关统计值。

 * 可以联系代码表、字典表进行查询。

 * 如果涉及代码表，在生成菜单程序时，在填表名时，应当先在列表框中选主表，再依次选代码表。

 * 如果涉及字典表，将根据字典表给定的对应关系变换标签。

 * 要求在当前数据库中有一个表的名字为某某某字典表，

 * 即表名最后3个字是“字典表”，本程序将根据该表变换。

 * 要求该表中只有二个字段，第一个字段（命名为字段名）中内容为所查询的数据表中字段名，

 * 第二个字段（命名为标签名）内容为变换后的标签名。

 */

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.table.*;

import java.sql.*;

import java.util.ArrayList;

public class dataStatistic2 extends JFrame {

    static dataStatistic2 frame = new dataStatistic2(); 

    static dataStatistic2 frame1 = new dataStatistic2();

    static String 表名; 

    static String 字典表名;

    static String 表名表;

    static DefaultTableModel tableModel; 

    static ArrayList 小组平均=new ArrayList();

    static JTable table;

    static JScrollPane scrollPane = new JScrollPane();  

     static String s1="";  

    static ResultSet rs;  

    static int b=0,c=0; 

    static int 列数; 

    static String[][] 列名; 

    static String[] 列数据类型; 

    static int[] 列数据宽度; 

    static int 记录条数,记录条数1,分组个数,分组个数1; 

    static String[][] 表格数据;// 存放表格数据的数;

    static String[][] 表格数据1;

    static String[][] 表格数据2;  //存放ABC统计时表格数据

    static String [][] 记录1;

    static String [][] 记录4;   //存放ABC统计时分组数据

    //存放分组名字值串、每组第一个统计字段（k=0）小计、记录条数、ABC类型、每组小计占比、每组记录条数占比

    static String 统计字段;

    static String 分组字段;

    static int [] 分组字段号;

    static String 字段号表;

    static String 统计要求;

    static int [] 统计字段号;

    static String 连接条件;

    static String 字段名字串;

    static String 按钮号表,分类比例;

    static int 左边距=80;

     static Connection con; // 连接数据库

    static ResultSetMetaData rsmd3;

    static Statement sta3;

    static int 窗口宽 = 1000, 窗口高 = 600;//窗口高

static String [] 按钮集=null;

static String 要求按钮号表;

static int 按钮数=0,按钮宽=0;

public static void means(String [] parameter) {

frame = new dataStatistic2(); 

frame1 = new dataStatistic2();

小组平均=new ArrayList();

scrollPane = new JScrollPane();  

s1=""; b=0;c=0;左边距=80;

窗口宽 = 1000; 窗口高 = 600;

String [] 按钮集01={"统计","打印预览","打印","导出","退出"};

    按钮集=new String[按钮集01.length];

    按钮数=0;

    for (int i0=0;i0<按钮集01.length;i0++)

      按钮集[i0]= 按钮集01[i0];

if (parameter[11].length()>0){

要求按钮号表=parameter[11] ;// 需要显示的按钮的顺序号

            //将中文分号、冒号、句号、英文分号统一为英文分号

要求按钮号表=要求按钮号表.replaceAll("；",";");

要求按钮号表=要求按钮号表.replaceAll("。",";");

要求按钮号表=要求按钮号表.replaceAll(":",";");

要求按钮号表=要求按钮号表.replaceAll("：",";");

if (要求按钮号表.indexOf(";")>0){   //如果有按钮更名要求

String s601[]=要求按钮号表.split(",");

要求按钮号表="";

for (int i01=0;i01<s601.length;i01++){

if (s601[i01].indexOf(";")>0){

String s602[]=s601[i01].split(";");

按钮集[Integer.parseInt((s602[0]))]=s602[1];

要求按钮号表=要求按钮号表+","+s602[0];//只留号，去更名

按钮数++;

}

else {

要求按钮号表=要求按钮号表+","+s601[i01];//只留号，原无更名

按钮数++;

}

}

}   //如果没有按钮更名要求，要求按钮号长度又大于0，保持原有摸样

else {

String s601[]=要求按钮号表.split(",");

要求按钮号表="";

for (int i01=0;i01<s601.length;i01++){

           if (i01==0) 要求按钮号表=s601[i01];

           else 要求按钮号表=要求按钮号表+","+s601[i01];

           按钮数++;

   }

}

}

else {

要求按钮号表="";  //没输入要求按钮号，定全部按钮号

for (int i1=0;i1<按钮集.length;i1++){

if (i1==0) 要求按钮号表=要求按钮号表+i1;

else 要求按钮号表=要求按钮号表+","+i1;

按钮数++;

}

}

要求按钮号表=","+要求按钮号表+",";

窗口宽=main1.窗口宽;  窗口高=main1.窗口高;

int m1,m2;

try{

if (parameter[17].length()==0) {

m1=0;m2=0;

}

else {

m1=Integer.parseInt(parameter[17]) ;//宽度参数

m2=Integer.parseInt(parameter[18]) ;

}

if (m1>0){

if (m2<80){

m1=m1*10;

m2=m2*10;

}

   窗口宽=m1 ;

   窗口高=m2 ;

}

}catch(Exception e2){}

frame = new dataStatistic2();小组平均=new ArrayList();

frame1 = new dataStatistic2();

scrollPane = new JScrollPane();  

b=0;c=0;窗口宽 = 1000;窗口高 = 600;

    统计要求=parameter[13];

    表名=parameter[4];

    连接条件=parameter[20];

    字段名字串=parameter[19];

    分组字段=parameter[10];

      if (字段名字串.lastIndexOf(",")==字段名字串.length()-1 )

      字段名字串=字段名字串.substring(0,字段名字串.length()-1);

      表名表=parameter[0];

    字段号表=parameter[8];

    统计字段=parameter[9];

    按钮号表=","+parameter[11]+",";

    分类比例=parameter[14];

        字典表名="";

        String []t1;

String s11=表名;

    if (表名.indexOf(",")>0){

      String [] s12=表名.split(",");

      s11=s12[0];

      }

       if (表名表.lastIndexOf(s11+"字典表")>0){ 

        t1=表名表.split(",");

        for (int i=0;i<t1.length;i++)

       if (t1[i].lastIndexOf(s11+"字典表")>=0) 字典表名=t1[i];

       }

        String[] l1;

        String [] l3=字段名字串.split(",");

        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      

        { 

      con=main1.getConn();// 连接数据库

    sta3 = con.createStatement(

             ResultSet.TYPE_SCROLL_INSENSITIVE,   

             ResultSet.CONCUR_UPDATABLE);

    String s="";

    if (表名.lastIndexOf(",")>0)

        s="select "+s1+" from "+表名+" where "+连接条件;

    else

    s="select "+s1+" from "+表名;

    ResultSet rs=sta3.executeQuery(s);

             rsmd3 = rs.getMetaData();

            列数=rsmd3.getColumnCount();   //获取列数

            列名=new  String[2][列数];  //定义列名数组

       列数据类型 = new String[列数]; // 定义列字段类型数组

       列数据宽度 = new int[列数]; // 定义列数据宽度

       for (int i=0;i<列数;i++) { 

       列名[0][i] = rsmd3.getColumnName(i + 1); // 获取列名存到数组中

             列名[1][i]=列名[0][i];  

       列数据类型[i] = rsmd3.getColumnTypeName(i + 1); // 获取列数据类型名存到数组中

           列数据宽度[i] = rsmd3.getColumnDisplaySize(i + 1);

            }

       记录条数=0;   //记录条数

            rs.last(); 

            记录条数=rs.getRow();

            表格数据=new  String[记录条数][列数];  

            表格数据2=new  String[记录条数*2][列数+4]; 

            //对于ABC分类增加：记录条数、记录条数占比、和占比、分类名称等4列

            //ABC分类输出可能包括除数据外还要加小计等内容，考虑记录数留一倍容量

            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();     //关闭查询结果集

            sta3.close();     //关闭连接

            con.close();

        }catch(SQLException e){

    JOptionPane.showMessageDialog( null, "查询数据出错！"); 

        } 

    s1="";

if (字典表名.length()>0){  

  try { 

  con=main1.getConn();// 连接数据库

sta3 = con.createStatement(

         ResultSet.TYPE_SCROLL_INSENSITIVE,   

         ResultSet.CONCUR_UPDATABLE); 

s1 = "select * from " + 字典表名;

rs = sta3.executeQuery(s1);

                 ResultSetMetaData rsmd = rs.getMetaData();

                 int numberOfColumns=rsmd.getColumnCount();    

                String s14="";

                String s15="";

                int b=1;

                while (rs.absolute(b)) { 

                    b++;

                    s14=rs.getString(1).trim();    //字段名

                    s15=rs.getString(2).trim(); 

                    for (int j=0;j<列数;j++){

                        if (列名[0][j].trim().equalsIgnoreCase(s14.trim())){

                      列名[1][j]=s15;

                      break;

                      }

                        else if ((列名[0][j].trim()+",").indexOf("."+s14+",")>0){

                      列名[1][j]=列名[1][j].replace(s14,s15);

                  break;

                      }

                    }

                 }

                 rs.close();     //关闭查询结果集

                 con.close();

                 sta3.close();

} catch (SQLException e)

{

JOptionPane.showMessageDialog( null, "连接数据库出错！"+s1);

}

 }

String [] s71=字段名字串.split(","); 

       String s4 [];

    s4=统计字段.split(",");

    for (int i=0;i<s4.length;i++)   

    s4[i]=s71[Integer.parseInt(s4[i])];  

        统计字段号=new int[s4.length];

    for (int i=0;i<s4.length;i++)  {  

    for (int j=0;j<列数;j++){

    if (s4[i].trim().equals(列名[0][j].trim())) 统计字段号[i]=j;

    }

      for (int j=0;j<记录条数;j++)

      if ((表格数据[j][统计字段号[i]]==null)||

      (表格数据[j][统计字段号[i]].length()<1))

      表格数据[j][统计字段号[i]]="0";

    }

    String s5 [];

    s5=分组字段.split(",");

    分组字段号=new int[s5.length];

      for (int i=0;i<s5.length;i++) 

    for (int j=0;j<列数;j++){

    if (s5[i].trim().equalsIgnoreCase(列名[0][j].trim())) 分组字段号[i]=j;

    }

        记录4=new String[记录条数][6];//分组个数最大等于记录数

        for (int i=0;i<记录条数;i++)

        for (int j=0;j<6;j++)

        记录4[i][j]="";

         分组个数1=0;

    String s6="",s7="";

    记录条数1=0;

    String [] 记录=new String[列数];

    for (int i0=0;i0<记录条数-1;i0++){

    for (int i=0;i<记录条数-1-i0;i++){

    s6="";

    s7="";

    for (int j=0;j<s5.length;j++)

      s6=s6+表格数据[i][分组字段号[j]].trim();

    for (int j=0;j<s5.length;j++)

           s7=s7+表格数据[i+1][分组字段号[j]].trim();

    if (s6.compareTo(s7)>0)

    for (int k=0;k<列数;k++){  //分组字段排序

    记录[k]=表格数据[i][k];

    表格数据[i][k]=表格数据[i+1][k];

    表格数据[i+1][k]=记录[k];

    }

      }

    }

      frame.setTitle("查询统计部件程序                           作者：程学先");  //窗口标题

    frame.setBounds(10, 10,窗口宽-10,窗口高-10);    //窗口位置大小

     frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式

        frame.getContentPane().setLayout(null);    //关闭窗口布局管理器

        frame1.setTitle("     ABC分类表");

    frame1.setBounds(100, 10,窗口宽-10,窗口高-10);    //窗口位置大小

     frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // 设置窗体的默认关闭模式

        frame1.getContentPane().setLayout(null);    //关闭窗口布局管理器

        final JPanel panel = new JPanel(false);      //定义面板

        final JPanel panel1 = new JPanel(false);      //定义面板

        panel.setLayout(null);        //关闭面板布局管理器    

        panel.setBounds(20, 20,窗口宽-50,窗口高-20);

        panel1.setLayout(null);        //关闭面板布局管理器    

        panel1.setBounds(20, 20,窗口宽-50,窗口高-20);

    记录1=new String[0][列数];

        tableModel = new DefaultTableModel(表格数据,列名[1]); // 创建表格模型

        table = new JTable(tableModel); // 创建指定表格模型的表格

        table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);// 设置表格的选择模式为单选

        table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

       table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

       for(int i=0;i<列数;i++) {    //设置表格每列宽度

           TableColumn tc = table.getColumn(列名[1][i]);

           int g10=列名[1][i].length();

          if (列数据宽度[i]>g10) g10=列数据宽度[i];

           tc.setPreferredWidth(g10*20);

           tc.setMaxWidth(g10*20);

           tc.sizeWidthToFit();

      }

       scrollPane.getViewport().add(table, null); 

       scrollPane.setBounds(30, 30,窗口宽-100,窗口高-200);   

       panel.add(scrollPane);   

        int j=0;

        按钮号表=要求按钮号表;

        if (按钮号表.length()<3) j=5;  

        else  for (int i=0;i<5;i++)   

         if (按钮号表.lastIndexOf(","+i+",")>=0) j=j+1;

        int 按钮宽=(窗口宽-80)/按钮数;

        int 按钮左边距=5;

        

        JButton 统计 = new JButton(按钮集[0]);

        统计.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

            for (int i=tableModel.getRowCount()-1;i>=0;i--)

            tableModel.removeRow(i);   //从最后一行向前删除

               String [] 记录=new String[列数];

            String [] 记录2=new String[列数];

            String [] 记录3=new String[列数];

            double [] x0=new double [列数];

              double [] x1=new double [列数];

            double [] x2=new double [列数];

            double [] x3=new double [列数];

            double [] x4=new double [列数];

            double [][] y0;

              double [] y1=new double [列数];

            double [] y2=new double [列数];

            double [] y3=new double [列数];

            double [] y4=new double [列数];

            String s6="",s7="";

            int 小组起始号=0;

            double [] x=new double [列数]; 

            double [] y=new double [列数];  

            for (int i=0;i<列数;i++){

            记录2[i]="";

            记录3[i]="";

            }

            Double 总合计=0.0;

            int 总记录数=0;

     s6="";   

     for (int n0=0;n0<分组字段号.length;n0++){

        s6=s6+表格数据[0][分组字段号[n0]].trim();

     }

     for (int k=0;k<统计字段号.length;k++){ 

      x1[统计字段号[k]]=Double.parseDouble(表格数据[0][统计字段号[k]]); 

      y1[统计字段号[k]]=Double.parseDouble(表格数据[小组起始号][统计字段号[k]]);

      x2[统计字段号[k]]=0; 

      y2[统计字段号[k]]=0;

      x3[统计字段号[k]]=0; 

      y3[统计字段号[k]]=0;

      x4[统计字段号[k]]=0; 

      y4[统计字段号[k]]=0;

     }

     for (int n0=0;n0<列数;n0++){

      记录[n0]="";

     }

     for (int n=0;n<记录条数;n++) { 

                if (("求最大,求最小,求记录数,求和,求平均,求ABC分类").lastIndexOf(统计要求)>=0)

                 tableModel.addRow(表格数据[n]);

            for (int k=0;k<统计字段号.length;k++){

                  x[统计字段号[k]]=Double.parseDouble(表格数据[n][统计字段号[k]]);

               if (x[统计字段号[k]]<x1[统计字段号[k]]) x1[统计字段号[k]]=x[统计字段号[k]];

            if (x[统计字段号[k]]>x2[统计字段号[k]]) x2[统计字段号[k]]=x[统计字段号[k]];

            x3[统计字段号[k]]=x3[统计字段号[k]]+x[统计字段号[k]];

            x4[统计字段号[k]]++;

               if (x[统计字段号[k]]<y1[统计字段号[k]]) y1[统计字段号[k]]=x[统计字段号[k]];

            if (x[统计字段号[k]]>y2[统计字段号[k]]) y2[统计字段号[k]]=x[统计字段号[k]];

            y3[统计字段号[k]]=y3[统计字段号[k]]+x[统计字段号[k]];

            y4[统计字段号[k]]++;

            }

        s7="";

        String s8="";

              if(n<记录条数-1){

            for (int n1=0;n1<分组字段号.length;n1++){

            s7=s7+表格数据[n+1][分组字段号[n1]].trim();

            if (s8.length()==0)

            s8=s8+表格数据[n][分组字段号[n1]].trim();

            else s8=s8+","+表格数据[n][分组字段号[n1]].trim();

            }

                    if (! s6.trim().equalsIgnoreCase(s7.trim())) {

                   s6=s7;

                   for (int k=0;k<统计字段号.length;k++){

                    if (统计要求.trim().equals("求最小"))

                    记录[统计字段号[k]]=""+y1[统计字段号[k]];

                    else if (统计要求.trim().equals("求最大"))

                    记录[统计字段号[k]]=""+y2[统计字段号[k]];

                    else if (统计要求.trim().equals("求和"))

                    记录[统计字段号[k]]=""+y3[统计字段号[k]];

                           else if (统计要求.trim().equalsIgnoreCase("求ABC分类")){

                        记录[统计字段号[k]]=""+y3[统计字段号[k]];

                           }

                    else if (统计要求.trim().equals("求记录数"))

                    记录[统计字段号[k]]=""+(int)y4[统计字段号[k]];

                    else if (统计要求.trim().equals("求平均")){

                      记录[统计字段号[k]]=""+y3[统计字段号[k]]/y4[统计字段号[k]];

                      }

                    if (k==0) {

                    记录4[分组个数1][1]=y3[统计字段号[k]]+"";   //只保存第一个统计字段统计值k=0

                    记录4[分组个数1][2]=(int)y4[统计字段号[k]]+"";   //记录条数

                    记录4[分组个数1][0]=s8;

                    分组个数1++;

                    }

                    小组平均.add(y3[统计字段号[k]]/y4[统计字段号[k]]);

                   }

                   if (("求最大,求最小,求记录数,求和,求平均").lastIndexOf(统计要求)>=0)

                   记录[分组字段号[分组字段号.length-1]]=表格数据[n][分组字段号[分组字段号.length-1]].trim()+统计要求.substring(1,统计要求.length());

                   else if (("求ABC分类").lastIndexOf(统计要求)>=0)

                       记录[分组字段号[分组字段号.length-1]]=表格数据[n][分组字段号[分组字段号.length-1]].trim()+"分类";

                        if (("求最大,求最小,求记录数,求和,求平均,求ABC分类").lastIndexOf(统计要求)>=0)

                       tableModel.addRow(记录); 

                                                                  小组起始号=n+1;

                        for (int k=0;k<统计字段号.length;k++){  

                          y1[统计字段号[k]]=Double.parseDouble(表格数据[小组起始号][统计字段号[k]]);

                          y2[统计字段号[k]]=0; 

                          y3[统计字段号[k]]=0;  

                          y4[统计字段号[k]]=0; 

                         }

                         for (int n0=0;n0<列数;n0++){

                          记录[n0]="";

                         }

                 }

                  }

                }       

                   for (int k=0;k<统计字段号.length;k++){

                if (统计要求.trim().equals("求最小"))

                记录[统计字段号[k]]=""+y1[统计字段号[k]];

                else if (统计要求.trim().equals("求最大"))

                记录[统计字段号[k]]=""+y2[统计字段号[k]];

                else if (统计要求.trim().equals("求和"))

                记录[统计字段号[k]]=""+y3[统计字段号[k]];

                else if (统计要求.trim().equalsIgnoreCase("求ABC分类"))

                                       记录[统计字段号[k]]=""+y3[统计字段号[k]];

                else if (统计要求.trim().equals("求记录数"))

                记录[统计字段号[k]]=""+(int)y4[统计字段号[k]];

                else if (统计要求.trim().equals("求平均")){

                       记录[统计字段号[k]]=""+y3[统计字段号[k]]/y4[统计字段号[k]];

              }

                String s9="";

                for (int n1=0;n1<分组字段号.length;n1++){

                  if (s9.length()==0)

                s9=s9+表格数据[记录条数-1][分组字段号[n1]].trim();

                else s9=s9+","+表格数据[记录条数-1][分组字段号[n1]].trim();

                }

                if (k==0){

            记录4[分组个数1][1]=y3[统计字段号[k]]+"";   //只保存第一个统计字段统计值k=0

            记录4[分组个数1][2]=(int)y4[统计字段号[k]]+"";   //记录条数

            记录4[分组个数1][0]=s9;

                }

                小组平均.add(y3[统计字段号[k]]/y4[统计字段号[k]]);

               }

               记录[分组字段号[分组字段号.length-1]]=表格数据[记录条数-1][分组字段号[分组字段号.length-1]].trim()+统计要求.substring(1,统计要求.length());

               if (("求最大,求最小,求记录数,求和,求平均,求ABC分类").lastIndexOf(统计要求)>=0){

                   tableModel.addRow(记录); 

                   for (int k=0;k<统计字段号.length;k++){

                if (统计要求.trim().equals("求最小"))

                记录[统计字段号[k]]=""+x1[统计字段号[k]];

                else if (统计要求.trim().equals("求最大"))

                记录[统计字段号[k]]=""+x2[统计字段号[k]];

                else if (统计要求.trim().equals("求和"))

                记录[统计字段号[k]]=""+x3[统计字段号[k]];

                else if (统计要求.trim().equalsIgnoreCase("求ABC分类"))

                记录[统计字段号[k]]=""+x3[统计字段号[k]];

                else if (统计要求.trim().equals("求记录数"))

                记录[统计字段号[k]]=""+(int)x4[统计字段号[k]];

                else if (统计要求.trim().equals("求平均")){

                记录[统计字段号[k]]=""+x0[统计字段号[k]];

                    y4[统计字段号[k]]++;

                    x4[统计字段号[k]]++;

                }

                if (统计要求.trim().equals("求平均")){

            x0[统计字段号[k]]=x3[统计字段号[k]]/记录条数;  //x4[统计字段号[k]];

            记录[统计字段号[k]]=""+x0[统计字段号[k]];  

                }

                if (k==0) 总合计=Double.valueOf(记录[统计字段号[k]]);

               }

            }

                if (("求最大,求最小,求记录数,求和,求平均").lastIndexOf(统计要求)>=0){

                        记录[分组字段号[分组字段号.length-1]]="总"+统计要求.substring(1,统计要求.length());

              tableModel.addRow(记录);

                }

            else if (("求ABC分类").lastIndexOf(统计要求)>=0){

                     记录[分组字段号[分组字段号.length-1]]="总分类";

                    tableModel.addRow(记录);

               }

                y0=new double[小组平均.size()/统计字段号.length+1][统计字段号.length];

                int i1=0;

                for (int i=0;i<小组平均.size()/统计字段号.length;i++)

                for (int j=0;j<统计字段号.length;j++){

                y0[i][j]=Double.parseDouble(""+小组平均.get(i*统计字段号.length+j));

                }

                 int 组号=0;

              if (("求最大,求最小,求记录数,求和,求平均,求ABC分类").lastIndexOf(统计要求)<0){

                    for (int k1=0;k1<统计字段号.length;k1++){

                    x2[统计字段号[k1]]=0;

                    x3[统计字段号[k1]]=0;

                    y2[统计字段号[k1]]=0;

                    y3[统计字段号[k1]]=0;

                    x4[统计字段号[k1]]=0;

                    y4[统计字段号[k1]]=0;

                    }

                    s6="";  

                    for (int n0=0;n0<分组字段号.length;n0++){

                        s6=s6+表格数据[0][分组字段号[n0]].trim();

                    }

                  for (int n=0;n<记录条数;n++) { 

                       tableModel.addRow(表格数据[n]);  

                    for (int k=0;k<统计字段号.length;k++){

                        x[统计字段号[k]]=Math.abs(Double.parseDouble(表格数据[n][统计字段号[k]])-x0[统计字段号[k]]);

                        x2[统计字段号[k]]=x2[统计字段号[k]]+x[统计字段号[k]];

                        x3[统计字段号[k]]=x3[统计字段号[k]]+x[统计字段号[k]]*x[统计字段号[k]];

                        y[统计字段号[k]]=Math.abs(Double.parseDouble(表格数据[n][统计字段号[k]])-y0[组号][k]);

                    y2[统计字段号[k]]=y2[统计字段号[k]]+y[统计字段号[k]];

                        y3[统计字段号[k]]=y3[统计字段号[k]]+y[统计字段号[k]]*y[统计字段号[k]];

                        x4[统计字段号[k]]++;

                        y4[统计字段号[k]]++;

                    }

        s7="";

              if(n<记录条数-1) {

            for (int n1=0;n1<分组字段号.length;n1++)

            s7=s7+表格数据[n+1][分组字段号[n1]].trim();

                    if (! s6.equalsIgnoreCase(s7)) {

                    s6=s7;

                       for (int k=0;k<统计字段号.length;k++){

                    if (统计要求.trim().equals("求平均偏差"))

                    记录[统计字段号[k]]=""+y2[统计字段号[k]]/y4[统计字段号[k]];

                    else if (统计要求.trim().equals("求相对偏差"))

                    记录[统计字段号[k]]=""+y2[统计字段号[k]]/y4[统计字段号[k]]/y0[组号][k]*100;

                    else if (统计要求.trim().equalsIgnoreCase("求统计标准偏差stdev"))

                    记录[统计字段号[k]]=""+Math.sqrt(y3[统计字段号[k]]/(y4[统计字段号[k]]-1));

                    else if (统计要求.trim().equalsIgnoreCase("求填充统计标准偏差stdevp"))

                    记录[统计字段号[k]]=""+Math.sqrt(y3[统计字段号[k]]/y4[统计字段号[k]]);

                    else if (统计要求.trim().equalsIgnoreCase("求统计方差var"))

                    记录[统计字段号[k]]=""+y3[统计字段号[k]]/(y4[统计字段号[k]]-1);

                    else if (统计要求.trim().equalsIgnoreCase("求填充统计方差varp"))

                        记录[统计字段号[k]]=""+y3[统计字段号[k]]/y4[统计字段号[k]];

                       }

                   记录[分组字段号[分组字段号.length-1]]=表格数据[n][分组字段号[分组字段号.length-1]].trim()+统计要求.substring(1,统计要求.length());

                   tableModel.addRow(记录);

                                                                  组号++;

                    for (int n3=0;n3<列数;n3++){

                    记录3[n3]="";

                    y2[n3]=0;

                    y3[n3]=0;

                    y4[n3]=0;

                    }

            }

                }

              }

                   for (int k=0;k<统计字段号.length;k++){

                  if (统计要求.trim().equals("求平均偏差"))

                  记录[统计字段号[k]]=""+y2[统计字段号[k]]/y4[统计字段号[k]];

                  else if (统计要求.trim().equals("求相对偏差"))

                  记录[统计字段号[k]]=""+y2[统计字段号[k]]/y4[统计字段号[k]]/y0[组号][k]*100;

                  else if (统计要求.trim().equals("求统计标准偏差"))

                  记录[统计字段号[k]]=""+Math.sqrt(y3[统计字段号[k]]/(y4[统计字段号[k]]-1));

                  else if (统计要求.trim().equals("求填充统计标准偏差"))

                  记录[统计字段号[k]]=""+Math.sqrt(y3[统计字段号[k]]/y4[统计字段号[k]]);

                  else if (统计要求.trim().equals("求统计方差"))

                  记录[统计字段号[k]]=""+y3[统计字段号[k]]/(y4[统计字段号[k]]-1);

                  else if (统计要求.trim().equals("求填充统计方差"))

                      记录[统计字段号[k]]=""+y3[统计字段号[k]]/y4[统计字段号[k]];

                   }

                    tableModel.addRow(记录);

                   for (int k=0;k<统计字段号.length;k++){

                  if (统计要求.trim().equals("求平均偏差"))

                  记录[统计字段号[k]]=""+x2[统计字段号[k]]/x4[统计字段号[k]];

                  else if (统计要求.trim().equals("求相对偏差"))

                  记录[统计字段号[k]]=""+x2[统计字段号[k]]/x4[统计字段号[k]]/x0[统计字段号[k]]*100;

                  else if (统计要求.trim().equals("求统计标准偏差"))

                  记录[统计字段号[k]]=""+Math.sqrt(x3[统计字段号[k]]/(x4[统计字段号[k]]-1));

                  else if (统计要求.trim().equals("求填充统计标准偏差"))

                  记录[统计字段号[k]]=""+Math.sqrt(x3[统计字段号[k]]/x4[统计字段号[k]]);

                  else if (统计要求.trim().equals("求统计方差"))

                  记录[统计字段号[k]]=""+x3[统计字段号[k]]/(x4[统计字段号[k]]-1);

                  else if (统计要求.trim().equals("求填充统计方差"))

                      记录[统计字段号[k]]=""+x3[统计字段号[k]]/x4[统计字段号[k]];

                   }

                   记录[分组字段号[分组字段号.length-1]]="总"+统计要求.substring(1,统计要求.length());

                     tableModel.addRow(记录);

            }

           表格数据1=new  String[tableModel.getRowCount()][列数];  

            for (int i=0;i<tableModel.getRowCount();i++)

            for (int j=0;j<列数;j++){

                      if (tableModel.getValueAt(i,j)==null)

                     表格数据1[i][j]="";

                      else 

              表格数据1[i][j]=tableModel.getValueAt(i,j).toString().trim();

            }

            if (("求ABC分类").lastIndexOf(统计要求)>=0){

                String g0="";

            for (int i=0;i<=分组个数1;i++){

            for (int j=i;j<=分组个数1;j++){

            if (Double.parseDouble(记录4[j][1])>Double.parseDouble(记录4[i][1])){

            for (int k=0;k<6;k++){

            g0=记录4[i][k];

            记录4[i][k]=记录4[j][k];

            记录4[j][k]=g0;

            }

            }

            }

            }

            Double g1=0.0;   //某一类总值

            String g2[];

            if (分类比例.indexOf(",")>0)

            g2=分类比例.split(",");

            else g2=分类比例.split("，");

            String [] g3={"A","B","C","D","E","F","G","H","I","J"};

            int g4=0;   //计数

            Double g5[]=new Double[g2.length];

            总记录数=0;

            for (int i=0;i<g2.length;i++)

            g5[i]=Double.parseDouble(g2[i]);

                for (int i=0;i<=分组个数1;i++){

                g1=g1+Double.parseDouble(记录4[i][1]);

                记录4[i][3]=g3[g4];   //分类名称

                if (g1>(总合计*g5[g4]/100)){

                  g1=0.0;

                g4++;

                }

                总记录数=总记录数+Integer.parseInt(记录4[i][2]);

                }

               for (int i=0;i<=分组个数1;i++){

              记录4[i][4]=Double.parseDouble(记录4[i][1])/总合计*100+"";

                   记录4[i][4]=(记录4[i][4]+"        ").substring(0,6);

              记录4[i][5]=Double.parseDouble(记录4[i][2])*100/总记录数+"";

                   记录4[i][5]=(记录4[i][5]+"        ").substring(0,6);

               }

               String [] g6={"分组数据","小计值","记录条数","分类名称","小计占比","记录数占比"};

               DefaultTableModel tableModel1 = new DefaultTableModel(记录4,g6); // 创建表格模型

               JTable table1 = new JTable(tableModel1); // 创建指定表格模型的表格

               table1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);// 设置表格的选择模式为单选

               table1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

              table1.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

              for(int i=0;i<g6.length;i++) {    //设置表格每列宽度

                  TableColumn tc1 = table1.getColumn(g6[i]);

                  tc1.setPreferredWidth(10*8);

                  tc1.setMaxWidth(10*8);

                  tc1.sizeWidthToFit();

              }

              JScrollPane scrollPane1 = new JScrollPane(); 

              scrollPane1.getViewport().add(table1, null); 

              scrollPane1.setBounds(30, 30,窗口宽-100,窗口高-200);   

              panel1.add(scrollPane1);   

              frame1.getContentPane().add(panel1, null); 

              frame1.setVisible(true);  

          }

         }

    });

       if ((按钮号表.length()<3) || (按钮号表.lastIndexOf(",0,")>=0)){

       统计.setBounds(按钮左边距,窗口高-150,按钮宽,20); 

        panel.add(统计);  

                按钮左边距=按钮左边距+按钮宽;

      }

       JButton 打印预览 = new JButton(按钮集[1]);

        打印预览.addActionListener(new ActionListener() {

           public void actionPerformed(ActionEvent e) {

          dataPreview0.printView1(列名[1],表格数据1,列数据宽度,表名);

           }

       });

      if ((按钮号表.length()<3) || (按钮号表.lastIndexOf(",1,")>=0)){

      打印预览.setBounds(按钮左边距,窗口高-150,按钮宽,20);

    panel.add(打印预览); 

          按钮左边距=按钮左边距+按钮宽;

     }

      JButton 打印 = new JButton(按钮集[2]);

                  打印.addActionListener(new ActionListener() {

          public void actionPerformed(ActionEvent e) {    

          dataPrint0.printView1(列名[1],表格数据1,列数据宽度,表名);

        }

      });

     if ((按钮号表.length()<3) || (按钮号表.lastIndexOf(",2,")>=0)){

    打印.setBounds(按钮左边距,窗口高-150,按钮宽,20);  

    panel.add(打印); 

        按钮左边距=按钮左边距+按钮宽;

    }

     JButton 导出 = new JButton(按钮集[3]);

      导出.addActionListener(new ActionListener() {

         public void actionPerformed(ActionEvent e) {

        dataTransfer0.Trans(列名[1],列数据类型,列数据宽度,"",表格数据1,表名);

      }

     });

    if ((按钮号表.length()<3) || (按钮号表.lastIndexOf(",3,")>=0)){

    导出.setBounds(按钮左边距,窗口高-150,按钮宽,20); 

    panel.add(导出); 

        按钮左边距=按钮左边距+按钮宽;

   }

    JButton 退出 = new JButton(按钮集[4]);

       退出.addActionListener(new ActionListener() {

         public void actionPerformed(ActionEvent e) {

       frame.setVisible(false); 

       frame.dispose();

       frame1.setVisible(false); 

       frame1.dispose();

      }

     });

    if ((按钮号表.length()<3) || (按钮号表.lastIndexOf(",4,")>=0)){

    退出.setBounds(按钮左边距,窗口高-150,按钮宽,20);

    panel.add(退出); 

    按钮左边距=按钮左边距+按钮宽;

   }

     final String [] g6={"分组数据","小计值","记录条数","分类名称","小计占比","记录数占比"};

     final int [] g7={100,100,50,50,100,100};//"分组数据","小计值","记录条数","分类名称","小计占比","记录数占比"};

     final String [] g8={"char","Double","int","char","Double","Double"};

           按钮左边距=50;

    JButton 打印预览1 = new JButton("打印预览");

    打印预览1.addActionListener(new ActionListener() {

       public void actionPerformed(ActionEvent e) {

      dataPreview0.printView1(g6,记录4,g7,"ABC分类表");

       }

   });

  if ((按钮号表.length()<3) || (按钮号表.lastIndexOf(",1,")>=0)){

  打印预览1.setBounds(按钮左边距,窗口高-150,按钮宽,20);

    panel1.add(打印预览1); 

      按钮左边距=按钮左边距+按钮宽;

 }

  JButton 打印1 = new JButton("打   印");

   打印1.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent e) {    

      dataPrint0.printView1(g6,记录4,g7,"ABC分类表");

    }

  });

 if ((按钮号表.length()<3) || (按钮号表.lastIndexOf(",2,")>=0)){

打印1.setBounds(按钮左边距,窗口高-150,按钮宽,20);  

    panel1.add(打印1); 

    按钮左边距=按钮左边距+按钮宽;

}

 

 final int [] g9={20,20,6,6,20,20};//"分组数据","小计值","记录条数","分类名称","小计占比","记录数占比"};

 JButton 导出1 = new JButton("导       出");

  导出1.addActionListener(new ActionListener() {

     public void actionPerformed(ActionEvent e) {

    dataTransfer0.Trans(g6,g8,g9,"",记录4,"ABC分类表");

  }

   });

  if ((按钮号表.length()<3) || (按钮号表.lastIndexOf(",3,")>=0)){

导出1.setBounds(按钮左边距,窗口高-150,按钮宽,20); 

    panel1.add(导出1); 

    按钮左边距=按钮左边距+按钮宽;

   }

   frame.getContentPane().add(panel, null); 

   frame.setVisible(true);  

   frame.getContentPane().add(panel, BorderLayout.SOUTH);

   }

  }

版本2

56.源码56，部件程序，高度综合多表导出部件。包括多表数据排序、导出到数据库、导出到txt文件、导出到Office文件等数据导出部件。

     /** 

      * 程序文件名：dataTransfer18.java 

      * 作者：程学先  

      * 功能：高度综合多表导出部件。包括多表数据排序、导出到数据库、导出到txt文件、导出到Office文件等。 

      * 导出到数据库操作允许源表字段数多于目的表。包括覆盖、修改、添加三种方式。 

      * 覆盖方式将删除目的表原有数据。修改方式将修改关键字相同的记录，录入新关键字记录。 

      * 添加方式录入新关键字记录，对于关键字相同的老记录保持不变，而源表中相应记录不被导入目的表， 

      * 以防止出现关键字重复的情况。 

      * 完成日期：2018年5月22日 

      * 被调用语句：dataTransfer18.means(parameter); 

      * 必须提供的参数：数据“表名”。 

      * 可选择参数：“字段号表”、“要求按钮号表”、“打印格式文件名”。 

      * 如果是多字段，以英文逗号分隔。如果不要求导出到数据库，可以不给具体值。 

      * 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""； 

      * 否则写入所有将涉及的字段在表中的顺序后，号与号之间以英文逗号分隔。 

      * 本部件预设的按钮控件共5个，序号及按钮名：1排序、2接续排序、3导出到数据库、4导出到txt文件、5导出到office文件、6退出 

      * 在入口处通过“要求按钮号表”选择按钮以实现所需要的功能。 

      * 排序：要求先点击表格中某一列，将按本列数据从小到大对全表格数据排序。按本按钮后，标签变为还原，再按后恢复原表数据模样。 

      * 接续排序：在按“排序”按钮后本按钮激活，如果先点某一列，则会在上一次排序基础上对于上一排序列中值相同者按当前列继续排序。 

      * 导出到数据库：将当前显示数据导出到一个数据表中。将提问表名，输入表名后会在当前数据库中查是否存在该表？ 

      * 如果已经存在该表，会检查字段匹配情况。 

      * 如果完全匹配，则提问导入方式：1、删除原表数据，用新表覆盖。2、与原表数据关键字相同者用新数据覆盖，否则添加。 

      * 3、除关键字值有重复者外全部添加到原表尾，对于关键字重复的记录不录入，放弃修改。 

      * 如果不完全匹配，则先提问：是只导入匹配部分的数据，还是补充添加那些原表中不存在的字段后再导入。之后提问导入方式。 

      * 如果数据库中没有该表，将首先新建表，之后将表格中数据全部存到新表中。 

      * 导出到txt文件：将提问导出格式：1、每字段值一行导出。2、各字段按设定长度全部以字符串形式导出，每条记录一行，字段数据间无分隔。 

      * 3、每条记录一行，数字各类型数据以10进制数据形式表示；其他类型数据均以字符串形式表示，加双引号与逗号分隔。 

      * 4、提问分隔符，每条记录一行，各类型数据以自然形式表示，字符串类型数据也不加双引号，字段间加所输入的分隔符分隔。 

      * 分隔符可以由多个字符组成，例如：#### 

      * 导出到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 java.util.*; 

     import javax.sound.sampled.*; 

     import com.itextpdf.text.*; 

     import com.itextpdf.text.Font; 

     import com.itextpdf.text.pdf.*; 

     import org.apache.poi.hssf.usermodel.*; 

     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 dataTransfer18 extends JFrame { 

      private static JTable table;    

      static String variabl1275=main1.variabl1275; 

      static Connection con;    

      static String variabl1091=main1.variabl1091; 

      static String url;     

      static String variabl2603=main1.variabl2603;      

      static String variabl2429=""; 

      static String variabl1079=""; 

    static String variabl1873="";

      static String[] variabl1525=null;

      static String variabl1325=""; 

      static String[] variabl1787=null; 

      static int variabl2483=main1.variabl2483,variabl2503=main1.variabl2503;

         static int variabl2651=0;  

         static int variabl2113; 

         static String [] variabl2517;  

         static String variabl2049=""; 

         static String [] variabl1913;  

         static String [] variabl2411;   

         static String[] variabl1501; 

         static String[] variabl1169;    

         static int[] variabl1489,variabl1571;   

         static int[] variabl1119;  

      static int variabl1853=main1.variabl1853,variabl18531=0;   

      static String[][] variabl2197;

      static String[][] variabl1701;  

      static String [] variabl2405=null; 

      static String variabl1187; 

      static String variabl1153; 

      static JButton sortButton1,sortButton,printButton,exitButton; 

      static JButton variabl26391,variabl26392,variabl26393; 

      static String [][] variabl1753;  

      static String [][] variabl1631;  

      static int variabl1901=0,variabl1691=0,variabl1739=0,variabl1899=0; 

      static String [] variabl1507;  

      static String[] variabl1377; 

      static int[] variabl1287;   

      static int selectedRow=0; 

      static DefaultTableModel model; 

      static String [] rowValues=new String[variabl2113];   

      static String variabl1679="",variabl1463=""; 

      static String s1="",s2="",s3="";  

      static String[] variabl1425; 

      static PreparedStatement pstmt; 

      static Statement sta; 

      static int variabl2851=0,variabl2339=0; 

      static Set <String> hs=null; 

      

public static void means(String[] parameter) {

variabl1275 = main1.variabl1275;

variabl1091 = main1.variabl1091;

variabl2603 = parameter[4];

variabl2429 = parameter[0];

variabl1153 = parameter[8];

variabl1079 = parameter[15];

variabl1679 = "";

variabl1463 = "";

variabl2651 = main1.variabl2651;

variabl1853 = main1.variabl1853;

variabl18531 = 0;

variabl2049 = parameter[20];

variabl1325 = parameter[19];

variabl1787 = parameter[19].split(",");

hs = new HashSet();

main1.driver1();

String[] variabl240501 = { "排序", "接续排序", "打印", "导出到数据表", "导出到txt文件",

"导出到office文件", "退出" };

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) {

}

variabl1153 = parameter[8];

String[] s6 = variabl1325.split(",");

String s02 = "";

if (parameter[8].length() > 0) {

String[] variabl1735 = parameter[8].split(",");

variabl2517 = new String[variabl1735.length];

for (int i = 0; i < variabl1735.length; i++) {

variabl2517[i] = s6[Integer.parseInt(variabl1735[i])];

if (s02.length() > 0)

s02 = s02 + "," + variabl2517[i];

else

s02 = variabl2517[i];

}

variabl1325 = s02;

} else {

variabl2517 = new String[s6.length];

for (int i = 0; i < s6.length; i++) {

variabl2517[i] = s6[i];

if (s02.length() > 0)

s02 = s02 + "," + variabl2517[i];

else

s02 = variabl2517[i];

}

variabl1325 = s02;

}

variabl1901 = 0;

variabl1691 = 0;

variabl1739 = 0;

variabl1899 = 0;

selectedRow = 0;

rowValues = new String[variabl2113];

s1 = "";

s2 = "";

s3 = "";

dataTransfer18 frame = new dataTransfer18();

frame.setTitle("表格式显示部件之1                           作者：程学先");

frame.setBounds(10, 10, variabl2483, variabl2503);

frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

variabl1275 = parameter[1];

variabl1091 = parameter[3];

variabl2603 = parameter[4];

if (parameter[6].trim().length() > 0)

variabl1525 = parameter[6].split(",");

else

variabl1525 = new String[1];

variabl1287 = new int[variabl1525.length];

variabl1153 = parameter[8];

variabl1377 = new String[variabl1525.length];

for (int i = 0; i < variabl1525.length; i++) {

variabl1377[i] = "";

variabl1287[i] = 0;

}

con = main1.getConn();

try {

Statement sta = con.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

if (variabl2049.trim().length() > 0)

s1 = "select " + variabl1325 + " from " + variabl2603

+ " where " + variabl2049;

else

s1 = "select " + variabl1325 + " from " + variabl2603;

ResultSet rs = sta.executeQuery(s1);

rs.last();

variabl1853 = rs.getRow();

ResultSetMetaData rsmd = rs.getMetaData();

variabl2651 = rsmd.getColumnCount();

variabl2517 = new String[variabl2651];

variabl1501 = new String[variabl2651];

variabl1489 = new int[variabl2651];

variabl1571 = new int[variabl2651];

int[] variabl2345 = new int[variabl2651];

int b = -1, b0 = 0;

variabl1153 = "," + variabl1153 + ",";

while (b0 < variabl2651) {

if ((variabl1153.length() < 3)

|| (variabl1153.lastIndexOf("," + (b0 + 1) + ",") >= 0)) {

b = b + 1;

variabl2345[b] = b0;

}

variabl2517[b0] = rsmd.getColumnName(b0 + 1);

variabl1489[b0] = variabl1489[b0] = rsmd

.getColumnDisplaySize(b0 + 1);

if (variabl1489[b0] < variabl2517[b0].length())

variabl1489[b0] = variabl2517[b0].length();

if (variabl1489[b0] < variabl2517[b0].length())

variabl1489[b0] = variabl2517[b0].length();

if (variabl1489[b0] > 50)

variabl1489[b0] = 50;

variabl1571[b0] = rsmd.getScale(b0 + 1);

b0++;

}

variabl2113 = b + 1;

variabl1913 = new String[variabl2113];

variabl1169 = new String[variabl2113];

variabl1119 = new int[variabl2113];

b = 0;

while (b < variabl2113) {

variabl1913[b] = variabl2517[variabl2345[b]];

variabl1169[b] = variabl1501[variabl2345[b]];

variabl1119[b] = variabl1489[variabl2345[b]];

b++;

}

for (int j = 0; j < variabl1525.length; j++)

for (int i = 0; i < variabl2113; i++) {

if (variabl1525[j].trim().equals(variabl1913[i].trim())) {

variabl1287[j] = i;

break;

}

}

variabl2197 = new String[variabl1853][variabl2113];

rs.absolute(1);

int c = 0;

b = 0;

while (c < variabl1853) {

rs.absolute(c + 1);

while (b < variabl2113) {

variabl2197[c][b] = rs.getString(variabl2345[b] + 1);

b++;

}

c++;

b = 0;

}

rs.close();

sta.close();

} catch (Exception e1) {

e1.printStackTrace();

}

variabl1701 = new String[variabl1853][variabl2113];

variabl1187 = "," + variabl1187 + ",";

variabl2411 = new String[variabl2113];

int b = 0;

while (b < variabl2113) {

variabl2411[b] = variabl1913[b];

b++;

}

if (variabl1873.length() > 0) {

con = main1.getConn();

try {

Statement sta = con.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + variabl1873;

ResultSet rs = sta.executeQuery(s1);

while (rs.next()) {

String variabl2153 = rs.getString(1);

String variabl1755 = rs.getString(2);

b = 0;

while (b < variabl2113) {

if (variabl2411[b].equals(variabl2153)) {

variabl2411[b] = variabl1755;

break;

}

b++;

}

}

rs.close();

sta.close();

} catch (Exception e1) {

e1.printStackTrace();

}

}

final JScrollPane scrollPane = new JScrollPane();

scrollPane.setBounds(0, 0, variabl2483 - 100, variabl2503 - 100);

frame.setLayout(null);

frame.getContentPane().add(scrollPane, BorderLayout.CENTER);

model = new DefaultTableModel(variabl2197, variabl2411);

variabl1425 = new String[variabl2411.length];

final char x1 = 10, x2 = 13, x3 = '"', x4 = ',';

for (int c = 0; c < variabl1853; c++)

for (b = 0; b < variabl2113; b++)

variabl1701[c][b] = variabl2197[c][b];

table = new JTable(model);

table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

for (int i = 0; i < variabl2113; i++) {

TableColumn tc = table.getColumn(variabl2411[i]);

JTableHeader header = table.getTableHeader();

tc.setPreferredWidth(variabl1119[i] * 14);

tc.setMaxWidth(variabl1119[i] * 14);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

frame.setVisible(true);

table.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

selectedRow = table.getSelectedRow();

}

});

variabl1753 = new String[variabl1853][variabl2113 + 1];

variabl1631 = new String[variabl1853][variabl2113 + 1];

for (b = 0; b < variabl2113; b++) {

for (int c = 0; c < variabl1853; c++) {

if (variabl1701[c][b] == null)

variabl1753[c][b] = "";

else

variabl1753[c][b] = variabl1701[c][b];

}

if (main1.variabl1541.indexOf("," + variabl1169[b] + ",") >= 0) {

for (int c = 0; c < variabl1853; c++) {

variabl1753[c][b] = "0000000000" + variabl1753[c][b];

int k1 = variabl1753[c][b].lastIndexOf('.');

if (k1 == -1) {

k1 = variabl1753[c][b].length();

variabl1753[c][b] = variabl1753[c][b] + ".000000";

} else

variabl1753[c][b] = variabl1753[c][b] + "000000";

variabl1753[c][b] = variabl1753[c][b].substring(k1 - 10,

k1 + 1)

+ variabl1753[c][b].substring(k1 + 1, k1 + 6);

}

} else if (main1.variabl1541.indexOf("," + variabl1169[b] + ",") >= 0) {

for (int c = 0; c < variabl1853; c++) {

variabl1753[c][b] = "0000000000" + variabl1753[c][b];

variabl1753[c][b] = variabl1753[c][b]

.substring(variabl1753[c][b].length() - 10);

}

}

}

for (int c = 0; c < variabl1853; c++)

variabl1753[c][variabl2113] = "" + c;

for (int c = 0; c < variabl1853; c++)

for (b = 0; b < variabl2113 + 1; b++)

variabl1631[c][b] = variabl1753[c][b];

variabl1901 = 0;

variabl1691 = 0;

int variabl2339 = (variabl2483 - 20) / variabl2851;

int variabl1423 = 5;

sortButton = new JButton(variabl2405[0]);

sortButton.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

rowValues = new String[variabl2113];

if (sortButton.getText().trim().equals("排序")) {

if (table.getSelectedColumn() < 0)

JOptionPane.showMessageDialog(null,

"请先点击要排序的某一列，再按本按钮！");

else {

sortButton.setText("还原");

sortButton1.setEnabled(true);

variabl1899 = table.getSelectedColumn();

variabl1739 = table.getSelectedColumn();

}

String s;

int i, j, k = 0;

for (int c = 0; c < variabl1853; c++) {

for (i = 0; i < variabl1853 - c - 1; i++) {

if (variabl1753[i][variabl1739]

.compareTo(variabl1753[i + 1][variabl1739]) > 0)

for (j = 0; j <= variabl2113; j++) {

s = variabl1753[i][j];

variabl1753[i][j] = variabl1753[i + 1][j];

variabl1753[i + 1][j] = s;

}

}

}

model.setRowCount(0);

for (int c = 0; c < variabl1853; c++) {

int n = Integer.parseInt(variabl1753[c][variabl2113]);

for (int b = 0; b < variabl2113; b++) {

variabl2197[c][b] = variabl1701[n][b];

rowValues[b] = variabl1701[n][b];

}

model.addRow(rowValues);

}

} else {

sortButton.setText("排序");

sortButton1.setEnabled(false);

model.setRowCount(0);

for (int c = 0; c < variabl1853; c++) {

for (int b = 0; b < variabl2113; b++) {

rowValues[b] = variabl1701[c][b];

variabl1753[c][b] = variabl1631[c][b];

}

model.addRow(rowValues);

variabl1753[c][variabl2113] = variabl1631[c][variabl2113];

}

}

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",0,") >= 0)) {

sortButton.setBounds(variabl1423, variabl2503 - 80,

variabl2339 - 10, 20);

frame.add(sortButton);

variabl1423 = variabl1423 + variabl2339;

}

sortButton1 = new JButton(variabl2405[1]);

sortButton1.setEnabled(false);

sortButton1.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

variabl1739 = table.getSelectedColumn();

String s = "", s2 = variabl1753[0][variabl1899];

int n1 = 0, n2 = 0;

int i, j, k = 0;

for (int c = 0; c < variabl1853; c++) {

if ((c == variabl1853 - 1)

|| (s2.compareTo(variabl1753[c + 1][variabl1899]) != 0)) {

if (c < variabl1853 - 1)

s2 = variabl1753[c + 1][variabl1899];

n2 = c;

for (i = n1; i < n2; i++) {

for (j = n1; j < n2 + n1 - i; j++) {

if (variabl1753[j][variabl1739]

.compareTo(variabl1753[j + 1][variabl1739]) > 0)

for (k = 0; k <= variabl2113; k++) {

s = variabl1753[j][k];

variabl1753[j][k] = variabl1753[j + 1][k];

variabl1753[j + 1][k] = s;

}

}

}

n1 = n2 + 1;

}

}

variabl1899 = variabl1739;

model.setRowCount(0);

for (int c = 0; c < variabl1853; c++) {

int n = Integer.parseInt(variabl1753[c][variabl2113]);

for (int b = 0; b < variabl2113; b++) {

rowValues[b] = variabl1701[n][b];

}

model.addRow(rowValues);

}

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 0)) {

sortButton1.setBounds(variabl1423, variabl2503 - 80,

variabl2339 - 5, 20);

frame.add(sortButton1);

variabl1423 = variabl1423 + variabl2339;

}

JButton Button11 = new JButton(variabl2405[2]);

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 0)) {

Button11.setBounds(variabl1423, variabl2503 - 80, variabl2339 - 5,

20);

frame.add(Button11);

variabl1423 = variabl1423 + variabl2339;

}

Button11.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

try {

if (variabl1079.trim().length() == 0)

table.print();

else

dataPreview1.printView1(variabl2197, variabl1079);

} catch (Exception e1) {

JOptionPane.showMessageDialog(null, "打印失败！");

}

}

});

JButton Button12 = new JButton(variabl2405[3]);

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {

Button12.setBounds(variabl1423, variabl2503 - 80, variabl2339 - 5,

20);

frame.add(Button12);

variabl1423 = variabl1423 + variabl2339;

}

Button12.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int k = 0;

int k0 = 0;

if ((variabl1679 == null) || (variabl1679.length() == 0)) {

variabl1679 = JOptionPane.showInputDialog("请输入数据表名称", "");

}

k = 0;

if ((variabl1679 != null)

&& (("," + variabl2429 + ",").lastIndexOf(variabl1679) >= 0))

k = 1;

if (k == 0) {

if (variabl2049.trim().length() > 0)

s1 = "select " + variabl1325 + " into " + variabl1679

+ " from " + variabl2603 + " where "

+ variabl2049;

else

s1 = "select " + variabl1325 + " into " + variabl1679

+ " from " + variabl2603;

try {

con = main1.getConn();

if (!con.isClosed()) {

Statement rsmd = con.createStatement();

rsmd.executeUpdate(s1);

}

} catch (Exception e1) {

e1.printStackTrace();

}

return;

}

String[] variabl1381 = null;

String variabl13811 = "";

int[] variabl1131 = null;

int variabl1499 = 0;

con = main1.getConn();

s1 = "select * from " + variabl1679;

try {

Statement sta = con.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

ResultSet rs = sta.executeQuery(s1);

ResultSetMetaData rsmd = rs.getMetaData();

int variabl1461 = rsmd.getColumnCount();

variabl1381 = new String[variabl1461];

int b0 = 0;

while (b0 < variabl1461) {

variabl1381[b0] = rsmd.getColumnName(b0 + 1);

if (variabl13811.length() == 0)

variabl13811 = variabl13811 + variabl1381[b0];

else

variabl13811 = variabl13811 + "," + variabl1381[b0];

b0++;

}

rs.last();

int rows = rs.getRow();

String[][] s4 = new String[rows][variabl1461];

rs.absolute(1);

int i1 = 0;

String s6 = "";

while (i1 < rows) {

for (int j = 0; j < variabl1461; j++) {

s4[i1][j] = rs.getString(j + 1);

}

i1++;

rs.next();

}

for (int i = 0; i < rows; i++) {

for (int i2 = 0; i2 < variabl1287.length; i2++) {

for (int j = 0; j < variabl1461; j++) {

if (variabl1381[j]

.equals(variabl2517[variabl1287[i2]])) {

s6 = s6 + s4[i][j] + ",";

}

}

}

hs.add(s6);

s6 = "";

}

int k1 = 0;

String[] variabl1469 = new String[variabl1461];

int[] variabl1583 = new int[variabl1461];

variabl1131 = new int[variabl2113];

variabl1499 = 0;

String variabl25110 = "";

for (int i = 0; i < variabl2113; i++) {

k = 0;

for (int j = 0; j < variabl1461; j++) {

if (variabl1913[i].equals(variabl1381[j])) {

k = 1;

break;

}

}

if (k == 0) {

variabl1469[k1] = variabl1913[i];

variabl1583[k1] = i;

k1++;

} else {

variabl1131[variabl1499] = i;

variabl1499++;

}

}

String[] options = new String[] { "在导出表中增加这些字段",

"只导出同名字的字段值", "退出" };

int num = 0;

if (k1 > 0) {

num = JOptionPane.showOptionDialog(null,

"有些字段在导出目标表中不存在，请定处理方式？", "选择字段匹配方式",

JOptionPane.YES_NO_CANCEL_OPTION,

JOptionPane.INFORMATION_MESSAGE, null, options,

"只导出同名字的字段值");

if (options[num].trim().equals("退出"))

return;

if (options[num].trim().equals("在导出表中增加这些字段")) {

try {

con = main1.getConn();

if (!con.isClosed()) {

Statement rsmd1 = con.createStatement();

for (int i = 0; i < k1; i++) {

variabl25110 = variabl1169[variabl1583[i]];

s1 = "ALTER TABLE  " + variabl1679

+ "  ADD  " + variabl1469[i]

+ " " + variabl25110;

variabl13811 = variabl13811 + ","

+ variabl1469[i];

if (main1.variabl2511.indexOf(","

+ variabl25110 + ",") >= 0)

s1 = s1

+ "("

+ ("" + variabl1119[variabl1583[i]])

+ ")";

else if (main1.variabl1541.indexOf(","

+ variabl25110 + ",") >= 0)

s1 = s1

+ "("

+ ("" + variabl1119[variabl1583[i]])

+ ","

+ variabl1571[variabl1583[i]]

+ ")";

variabl1131[variabl1499] = variabl1583[i];

variabl1499++;

rsmd1.executeUpdate(s1);

}

for (int i = 0; i < variabl1499; i++) {

}

}

} catch (Exception e1) {

e1.printStackTrace();

}

}

}

rs.close();

sta.close();

} catch (Exception e1) {

e1.printStackTrace();

}

String[] options = new String[] { "覆盖原表数据", "替代原记录", "添加到原表尾",

"退出" };

int num = JOptionPane.showOptionDialog(null,

"是否复盖原表内容（原表数据将删除）？", "选择导出方式",

JOptionPane.YES_NO_CANCEL_OPTION,

JOptionPane.INFORMATION_MESSAGE, null, options,

"覆盖原表数据");

if (options[num].trim().equals("退出"))

return;

if (options[num].trim().equals("替代原记录"))

k0 = 1;

if (options[num].trim().equals("添加到原表尾"))

k0 = 2;

if (options[num].trim().equals("覆盖原表数据")) {

con = main1.getConn();

s1 = "delete from " + variabl1679;

try {

sta = con.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

pstmt = con.prepareStatement(s1);

pstmt.execute();

con.close();

sta.close();

} catch (Exception e2) {

e2.printStackTrace();

}

}

variabl1381 = variabl13811.split(",");

if (k0 == 0) {

String s3 = "(";

for (int i = 0; i < variabl1499; i++) {

s3 = s3 + variabl2517[variabl1131[i]];

if (i < variabl1499 - 1)

s3 = s3 + ",";

else

s3 = s3 + ")";

}

String sp = "";

int k1 = 0;

for (int j = 0; j < variabl1853; j++) {

s1 = "";

for (int i = 0; i < variabl1381.length; i++) {

for (k1 = 0; k1 < variabl2517.length; k1++) {

if (variabl2517[k1].equals(variabl1381[i]))

break;

}

sp = variabl2197[j][k1];

if (sp == null)

sp = "";

if (main1.variabl1545.indexOf("," + variabl1169[k1]

+ ",") >= 0) {

if (sp.length() == 0)

sp = "0";

s1 = s1 + sp;

} else {

s1 = s1 + "'" + sp + "'";

}

if (i < variabl1499 - 1)

s1 = s1 + ",";

}

s1 = "insert into " + variabl1679 + " (" + variabl13811

+ ") " + " values  (" + s1 + ")";

try {

con = main1.getConn();

pstmt = con.prepareStatement(s1);

pstmt.execute();

con.close();

} catch (Exception e2) {

e2.printStackTrace();

}

}

} else {

con = main1.getConn();

try {

s1 = "";

int j = 0;

String s6 = "", s7 = "", s8 = "";

for (int i1 = 0; i1 < variabl2197.length; i1++) {

selectedRow = i1;

s1 = "";

s7 = "";

s8 = "";

s6 = "";

for (int i = 0; i < variabl1525.length; i++) {

variabl1525[i] = variabl2517[variabl1287[i]];

variabl1377[i] = model.getValueAt(selectedRow,

variabl1287[i]).toString();

if ((variabl1377[i] == null)

|| (variabl1377[i].length() == 0)) {

JOptionPane.showMessageDialog(null,

"关键字数据欠缺！");

return;

}

s6 = s6 + variabl1377[i] + ",";

if (variabl1525[i].indexOf(".") > 0) {

s1 = s1 + variabl1525[i] + "='"

+ variabl1377[i] + "' ";

s7 = s7

+ variabl1525[i].substring(

variabl1525[i]

.lastIndexOf(".") + 1,

variabl1525[i].length())

+ "='" + variabl1377[i] + "' ";

} else {

s1 = s1 + variabl1525[i] + "='"

+ variabl1377[i] + "' ";

s7 = s7 + variabl1525[i] + "='"

+ variabl1377[i] + "' ";

}

if (i < variabl1525.length - 1) {

s1 = s1 + " and ";

s7 = s7 + " and ";

}

}

int n1 = hs.size();

hs.add(s6);

s3 = " where " + s7;

s1 = "";

s2 = " set ";

int k2 = 0;

for (k2 = 0; k2 < variabl1381.length; k2++) {

for (int i = 0; i < variabl2651; i++) {

if (variabl2517[i].equals(variabl1381[k2])) {

s8 = variabl2517[i];

if (s8.indexOf(".") > 0)

s8 = s8.substring(

s8.lastIndexOf(".") + 1,

s8.length());

if (model.getValueAt(selectedRow, i) == null)

variabl1425[i] = "";

else

variabl1425[i] = model.getValueAt(

selectedRow, i).toString();

if (main1.variabl1545.indexOf(","

+ variabl1501[i] + ",") >= 0) {

if (variabl1425[i].length() == 0)

variabl1425[i] = "0";

s1 = s1 + variabl1425[i];

s2 = s2 + s8 + "=" + variabl1425[i];

} else {

s1 = s1 + "'" + variabl1425[i]

+ "'";

s2 = s2 + s8 + "='"

+ variabl1425[i] + "'";

}

if (k2 < variabl1381.length - 1) {

s1 = s1 + ",";

s2 = s2 + ",";

}

}

}

}

if (n1 != hs.size()) {

s1 = "insert into " + variabl1679 + " ("

+ variabl13811 + ") " + " values  ("

+ s1 + ")";

pstmt = con.prepareStatement(s1);

pstmt.execute();

} else if (k0 == 1) {

s1 = "update " + variabl1679 + s2 + s3;

pstmt = con.prepareStatement(s1);

pstmt.execute();

}

}

con.close();

} catch (Exception e2) {

e2.printStackTrace();

}

}

}

});

JButton Button13 = new JButton(variabl2405[4]);

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 0)) {

Button13.setBounds(variabl1423, variabl2503 - 80, variabl2339 - 5,

20);

frame.add(Button13);

variabl1423 = variabl1423 + variabl2339;

}

Button13.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl1463.length() == 0)

variabl1463 = JOptionPane.showInputDialog("请输入导出文件名名称", "");

String[] options = new String[] { "每字段数据一行", "定长等长每记录一行",

"逗号分隔", "自定义符号分隔", "退出" };

int num = JOptionPane.showOptionDialog(null, "是否按每字段数据一行？",

"选择导出文件格式", JOptionPane.YES_NO_CANCEL_OPTION,

JOptionPane.INFORMATION_MESSAGE, null, options,

"覆盖原表数据");

if (options[num].trim().equals("退出"))

return;

else if (options[num].trim().equals("每字段数据一行")) {

try {

File file = new File(variabl1463);

if (!file.exists()) {

file.createNewFile();

}

char x1 = 10, x2 = 13;

FileOutputStream fs = new FileOutputStream(file);

for (int j1 = 0; j1 < variabl1853; j1++)

for (int j2 = 0; j2 < variabl2113; j2++) {

fs.write((variabl2197[j1][j2] + x2).getBytes());

}

fs.close();

} catch (FileNotFoundException e1) {

e1.printStackTrace();

} catch (IOException e2) {

e2.printStackTrace();

}

} else if (options[num].trim().equals("定长等长每记录一行")) {

try {

File file = new File(variabl1463);

if (!file.exists()) {

file.createNewFile();

}

FileOutputStream fs = new FileOutputStream(file);

for (int j1 = 0; j1 < variabl1853; j1++)

for (int j2 = 0; j2 < variabl2113; j2++) {

fs.write(variabl2197[j1][j2].getBytes());

}

fs.close();

} catch (FileNotFoundException e1) {

e1.printStackTrace();

} catch (IOException e2) {

e2.printStackTrace();

}

} else if (options[num].trim().equals("逗号分隔")) {

try {

File file = new File(variabl1463);

if (!file.exists()) {

file.createNewFile();

}

int length = 0;

char x1 = 10, x2 = 13, x3 = '"', x4 = ',';

FileOutputStream fs = new FileOutputStream(file);

for (int j1 = 0; j1 < variabl1853; j1++) {

for (int j2 = 0; j2 < variabl2113; j2++)

if (j2 < (variabl2113 - 1))

fs.write((x3 + variabl2197[j1][j2] + x3 + x4)

.getBytes());

else

fs.write((x3 + variabl2197[j1][j2] + x3)

.getBytes());

fs.write(("" + x1).getBytes());

}

fs.close();

} catch (FileNotFoundException e1) {

e1.printStackTrace();

} catch (IOException e2) {

e2.printStackTrace();

}

} else {

try {

File file = new File(variabl1463);

if (!file.exists()) {

file.createNewFile();

}

int length = 0;

char x1 = 10, x2 = 13, x3 = '"', x4 = ',';

String x5 = JOptionPane.showInputDialog("请输入字段与字段间分隔符",

"");

FileOutputStream fs = new FileOutputStream(file);

for (int j1 = 0; j1 < variabl1853; j1++) {

for (int j2 = 0; j2 < variabl2113; j2++)

if (j2 < (variabl2113 - 1))

fs.write((variabl2197[j1][j2] + x5)

.getBytes());

else

fs.write(variabl2197[j1][j2].getBytes());

fs.write(("" + x1).getBytes());

}

fs.close();

} catch (FileNotFoundException e1) {

e1.printStackTrace();

} catch (IOException e2) {

e2.printStackTrace();

}

}

}

});

JButton Button14 = new JButton(variabl2405[5]);

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",5,") >= 0)) {

Button14.setBounds(variabl1423, variabl2503 - 80, variabl2339 - 5,

20);

frame.add(Button14);

variabl1423 = variabl1423 + variabl2339;

}

Button14.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

String[] options = new String[] { "导出到Word文件", "导出到Excel文件",

"导出到Pdf文件", "退出" };

int num = JOptionPane.showOptionDialog(null, "", "选择导出文件格式",

JOptionPane.YES_NO_CANCEL_OPTION,

JOptionPane.INFORMATION_MESSAGE, null, options,

"导出到Word文件");

if (options[num].trim().equals("退出"))

return;

else if (options[num].trim().equals("导出到Word文件")) {

final JFileChooser fc = new JFileChooser(".\\");

fc.showOpenDialog(null);

if (fc.getSelectedFile() != null) {

s1 = fc.getSelectedFile().toString();

s2 = "";

for (int i = 0; i < s1.length(); i++)

if (s1.substring(i, i + 1).equals("\\"))

s2 = s2 + "\\" + "\\";

else

s2 = s2 + s1.substring(i, i + 1);

}

variabl1463 = s2;

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";

}

}

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 i = 0; i < variabl2197.length; i++) {

for (int j = 0; j < variabl2651; j++) {

if (variabl2197[i][j] == null)

variabl2197[i][j] = "";

Dispatch table = Dispatch.call(tables, "Item",

new Variant(1)).toDispatch();

Dispatch cell = Dispatch.call(table, "Cell",

new Variant(i + 1), new Variant(j + 1))

.toDispatch();

Dispatch.call(cell, "Select");

s1 = "" + variabl2197[i][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");

}

} else if (options[num].trim().equals("导出到Excel文件")) {

final JFileChooser fc = new JFileChooser(".\\");

fc.showOpenDialog(null);

if (fc.getSelectedFile() != null) {

s1 = fc.getSelectedFile().toString();

s2 = "";

for (int i = 0; i < s1.length(); i++)

if (s1.substring(i, i + 1).equals("\\"))

s2 = s2 + "\\" + "\\";

else

s2 = s2 + s1.substring(i, i + 1);

}

variabl1463 = s2;

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";

}

}

HSSFWorkbook book = new HSSFWorkbook();

HSSFSheet 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 < variabl1853; j++) {

HSSFRow row = sheet.createRow(j);

for (int i = 0; i < colCount; i++) {

HSSFCell cell = row.createCell(i);

cell.setCellValue(new HSSFRichTextString(

variabl2197[j][i]));

}

}

try {

FileOutputStream fileO = new FileOutputStream(

variabl1463);

book.write(fileO);

fileO.close();

} catch (Exception e1) {

e1.printStackTrace();

}

} else if (options[num].trim().equals("导出到Pdf文件")) {

final JFileChooser fc = new JFileChooser(".\\");

fc.showOpenDialog(null);

if (fc.getSelectedFile() != null) {

s1 = fc.getSelectedFile().toString();

s2 = "";

for (int i = 0; i < s1.length(); i++)

if (s1.substring(i, i + 1).equals("\\"))

s2 = s2 + "\\" + "\\";

else

s2 = s2 + s1.substring(i, i + 1);

}

variabl1463 = s2;

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";

}

}

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 k = 0; k < variabl1489[j]; k++)

s1 = s1 + "─";

if (j != variabl2651 - 1)

s1 = s1 + "┬";

}

s1 = s1 + "┐";

document.add(new Paragraph(s1, font));

String s4 = "", s5 = "";

float lengtg1 = 0;

for (int i = 0; i < variabl1853; i++) {

s1 = "│";

for (int j = 0; j < variabl2197[0].length; j++) {

s3 = "";

if (variabl2197[i][j] == null)

variabl2197[i][j] = " ";

s4 = variabl2197[i][j];

lengtg1 = 0;

for (int j1 = 0; j1 < variabl2197[i][j]

.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 < variabl1853 - 1) {

s1 = "├";

for (int j = 0; j < variabl2651; j++) {

for (int k = 0; k < variabl1489[j]; k++)

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 k = 0; k < variabl1489[j]; k++)

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();

}

}

});

exitButton = new JButton(variabl2405[6]);

exitButton.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

System.exit(0);

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",6,") >= 0)) {

exitButton.setBounds(variabl1423, variabl2503 - 80,

variabl2339 - 5, 20);

frame.add(exitButton);

variabl1423 = variabl1423 + variabl2339;

}

} 

        }  

57.源码57，部件程序，对全表若干字段进行求和或求平均或求最大或最小或记录条数或标准偏差或填充标准偏差或统计方差或填充统计方差等数据统计部件。

/** 

 * 程序文件名：dataStatistic1.java 

 * 作者：程学先 

 * 完成时间：2013年12月3日 

 * 功能：对全表若干字段进行求和或求平均或求最大或最小或记录条数或标准偏差或填充标准偏差 

 * 或统计方差或填充统计方差等，统计数据添加在数据表最后一行中。 

 * 被调用语句：dataStatistic1.means(parameter)。 

 * 必须提供的参数：“表名”、要求统计的字段“统计字段名集”、统计类型要求“统计项目类型”。 

 * 可选择参数：要求显示的字段号表、按钮号表。 

 * 本程序包括：统计、打印预览、打印、导出、退出等5个按钮。 

 * 其中打印要求要求先利用程序printFormat1.java生成格式文件 

 * 操作方法与注意事项：在“统计字段名集”处可以输入多个字段名，将对各字段分别统计。 

 * 在“统计项目”处的参数只能从{求和、求平均、求最大、求最小、求记录数、求统计标准偏差stdev、 

 * 求填充统计标准偏差stdevp、求统计方差var、求填充统计方差varp}中选择一个。 

 * 本程序应用计算方法求有关统计值。 

 * 可以联系代码表、字典表进行查询。 

 * 如果涉及代码表，在生成菜单程序时，在填表名时，应当先在列表框中选主表，再依次选代码表。 

 * 如果涉及字典表，将根据字典表给定的对应关系变换标签。 

 * 要求在当前数据库中有一个表的名字为某某某字典表， 

 * 即表名最后3个字是“字典表”，本程序将根据该表变换。 

 * 要求该表中只有二个字段，第一个字段（命名为字段名）中内容为所查询的数据表中字段名， 

 * 第二个字段（命名为标签名）内容为变换后的标签名。 

 */ 

     import java.awt.*; 

     import java.awt.event.*; 

     import javax.swing.*; 

     import javax.swing.table.*; 

     import java.sql.*; 

     public class dataStatistic1 extends JFrame { 

         static dataStatistic1 frame = new dataStatistic1();  

         static String variabl2603;  

         static String variabl1873;  

         static String variabl2429; 

         static DefaultTableModel tableModel;   

         static JTable table; 

         static JScrollPane scrollPane = new JScrollPane();   

          static String s1="";  

         static ResultSet rs;  

         static int b=0,c=0;  

         static int variabl2651;  

         static String[][] variabl2517;  

         static String[] variabl1501;  

         static int[] variabl1489;  

         static int variabl1853;  

         static String[][] variabl2197;

         static String[][] variabl21971; 

         static String variabl2093; 

         static String variabl1735; 

         static String variabl1987; 

         static int [] variabl1407; 

         static String variabl2049; 

         static String variabl1325; 

         static String variabl1779; 

         static int variabl2337=80; 

         static Connection con; 

         static ResultSetMetaData rsmd3; 

         static Statement sta3; 

         static int variabl2483 = 1000, variabl2503 = 600;

      static String [] variabl2405=null; 

      static String variabl1187; 

      static int variabl2851=0,variabl2339=0; 

       

      public static void means(String[] parameter) { 

      frame = new dataStatistic1(); 

      scrollPane = new JScrollPane(); 

      variabl2483 = 1000; 

      variabl2503 = 600;

      String[] variabl240501 = { "统       计", "打印预览", "打   印", "导       出","退            出" }; 

      variabl2405 = new String[variabl240501.length]; 

      variabl2851 = 0; 

      for (int i0 = 0; i0 < variabl240501.length; i0++) 

      variabl2405[i0] = variabl240501[i0]; 

      if (parameter[11].length() > 0) { 

      variabl1187 = parameter[11];

      variabl1187 = variabl1187.replaceAll("；", ";"); 

      variabl1187 = variabl1187.replaceAll("。", ";"); 

      variabl1187 = variabl1187.replaceAll(":", ";"); 

      variabl1187 = variabl1187.replaceAll("：", ";"); 

      if (variabl1187.indexOf(";") > 0) { 

      String s601[] = variabl1187.split(","); 

      variabl1187 = ""; 

      for (int i01 = 0; i01 < s601.length; i01++) { 

      if (s601[i01].indexOf(";") > 0) { 

      String s602[] = s601[i01].split(";"); 

      variabl2405[Integer.parseInt((s602[0]))] = s602[1]; 

      variabl1187 = variabl1187 + "," + s602[0];

      variabl2851++; 

      } else { 

      variabl1187 = variabl1187 + "," + s601[i01];

      variabl2851++; 

      } 

      } 

      } 

      else { 

      String s601[] = variabl1187.split(","); 

      variabl1187 = ""; 

      for (int i01 = 0; i01 < s601.length; i01++) { 

      if (i01 == 0) 

      variabl1187 = s601[i01]; 

      else 

      variabl1187 = variabl1187 + "," + s601[i01]; 

      variabl2851++; 

      } 

      } 

      } else { 

      variabl1187 = ""; 

      for (int i1 = 0; i1 < variabl2405.length; i1++) { 

      if (i1 == 0) 

      variabl1187 = variabl1187 + i1; 

      else 

      variabl1187 = variabl1187 + "," + i1; 

      variabl2851++; 

      } 

      } 

      variabl1187 = "," + variabl1187 + ","; 

      variabl2483 = main1.variabl2483; 

      variabl2503 = main1.variabl2503; 

      int m1, m2; 

      try { 

      if (parameter[17].length() == 0) { 

      m1 = 0; 

      m2 = 0; 

      } else { 

      m1 = Integer.parseInt(parameter[17]);

      m2 = Integer.parseInt(parameter[18]); 

      } 

      if (m1 > 0) { 

      if (m2 < 80) { 

      m1 = m1 * 10; 

      m2 = m2 * 10; 

      } 

      variabl2483 = m1; 

      variabl2503 = m2; 

      } 

      } catch (Exception e2) { 

      } 

      frame = new dataStatistic1(); 

      scrollPane = new JScrollPane(); 

      variabl2483 = 1000; 

      variabl2503 = 600;

      variabl1987 = parameter[13]; 

      variabl2603 = parameter[4]; 

      variabl2049 = parameter[20]; 

      variabl1325 = parameter[19]; 

      if (variabl1325.lastIndexOf(",") == variabl1325.length() - 1) 

      variabl1325 = variabl1325.substring(0, variabl1325.length() - 1); 

      variabl2429 = parameter[0]; 

      variabl1735 = parameter[8]; 

      variabl2093 = parameter[9]; 

      variabl1779 = "," + parameter[11] + ","; 

      variabl1873 = ""; 

      String[] t1; 

      String s11 = variabl2603; 

      if (variabl2603.indexOf(",") > 0) { 

      String[] s12 = variabl2603.split(","); 

      s11 = s12[0]; 

      } 

      if (variabl2429.lastIndexOf(s11 + "字典表") > 0) { 

      t1 = variabl2429.split(","); 

      for (int i = 0; i < t1.length; i++) 

      if (t1[i].lastIndexOf(s11 + "字典表") >= 0) 

      variabl1873 = t1[i]; 

      } 

      String[] l1; 

      String[] l3 = variabl1325.split(","); 

      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 { 

      con = main1.getConn();

      sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 

      ResultSet.CONCUR_UPDATABLE); 

      String s = ""; 

      if (variabl2603.lastIndexOf(",") > 0) 

      s = "select " + s1 + " from " + variabl2603 + " where " + variabl2049; 

      else 

      s = "select " + s1 + " from " + variabl2603; 

      ResultSet rs = sta3.executeQuery(s); 

      rsmd3 = rs.getMetaData(); 

      variabl2651 = rsmd3.getColumnCount(); 

      variabl2517 = new String[2][variabl2651]; 

      variabl1501 = new String[variabl2651]; 

      variabl1489 = new int[variabl2651]; 

      for (int i = 0; i < variabl2651; i++) { 

      variabl2517[0][i] = rsmd3.getColumnName(i + 1); 

      variabl2517[1][i] = variabl2517[0][i]; 

      variabl1501[i] = rsmd3.getColumnTypeName(i + 1); 

      variabl1489[i] = rsmd3.getColumnDisplaySize(i + 1); 

      b++; 

      } 

      rs.last(); 

      variabl1853 = rs.getRow(); 

      variabl2197 = new String[variabl1853][variabl2651]; 

      variabl21971 = new String[variabl1853 + 1][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(); 

      sta3.close(); 

      con.close(); 

      } catch (SQLException e) { 

      JOptionPane.showMessageDialog(null, "查询数据出错！"); 

      } 

      s1 = ""; 

      if (variabl1873.length() > 0) { 

      try { 

      con = main1.getConn(); 

      sta3 = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 

      ResultSet.CONCUR_UPDATABLE); 

      s1 = "select * from " + variabl1873; 

      rs = sta3.executeQuery(s1); 

      ResultSetMetaData rsmd = rs.getMetaData(); 

      int numberOfColumns = rsmd.getColumnCount(); 

      String s4 = ""; 

      String s5 = ""; 

      int 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(); 

      con.close(); 

      sta3.close(); 

      } catch (SQLException e) { 

      JOptionPane.showMessageDialog(null, "连接数据库出错！" + s1); 

      } 

      } 

      String[] s7 = variabl1325.split(","); 

      String s4[]; 

      s4 = variabl2093.split(","); 

      for (int i = 0; i < s4.length; i++) 

      s4[i] = s7[Integer.parseInt(s4[i])]; 

      variabl1407 = new int[s4.length]; 

      for (int i = 0; i < s4.length; i++) { 

      for (int j = 0; j < variabl2651; j++) { 

      if (s4[i].trim().equalsIgnoreCase(variabl2517[0][j].trim())) 

      variabl1407[i] = j; 

      } 

      for (int j = 0; j < variabl1853; j++) 

      if ((variabl2197[j][variabl1407[i]] == null) 

      || (variabl2197[j][variabl1407[i]].length() < 1)) 

      variabl2197[j][variabl1407[i]] = "0"; 

      } 

      frame.setTitle("查询统计部件程序                                作者：程学先"); 

      frame.setBounds(10, 10, variabl2483 - 10, variabl2503 - 10); 

      frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 

      frame.getContentPane().setLayout(null); 

      final JPanel panel = new JPanel(false); 

      panel.setLayout(null); 

      panel.setBounds(20, 20, variabl2483 - 50, variabl2503 - 20); 

      tableModel = new DefaultTableModel(variabl2197, variabl2517[1]); 

      table = new JTable(tableModel); 

      table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); 

      table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF); 

      scrollPane.getViewport().add(table, null); 

      scrollPane.setBounds(30, 30, variabl2483 - 100, variabl2503 - 200); 

      panel.add(scrollPane); 

      int j = 0; 

      if (variabl1779.length() < 3) 

      j = 5; 

      else 

      for (int i = 0; i < 5; i++) 

      if (variabl1779.lastIndexOf("," + i + ",") >= 0) 

      j = j + 1; 

      int variabl2339 = (variabl2483 - 80) / variabl2851; 

      int variabl1423 = 5; 

      variabl1779 = variabl1187; 

      JButton variabl2645 = new JButton(variabl2405[0]); 

      variabl2645.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

      String[] variabl2615 = new String[variabl2651]; 

      double[] x0 = new double[variabl2651]; 

      double[][] x1 = new double[tableModel.getRowCount()][variabl2651]; 

      double[] x2 = new double[variabl2651]; 

      double[] x3 = new double[variabl2651]; 

      for (int i = 0; i < variabl2651; i++) 

      variabl2615[i] = ""; 

      if (("求最大,variabl2493,求记录数,variabl2689,求平均").lastIndexOf(variabl1987) >= 0) { 

      if (variabl1987.trim().equals("求最小")) 

      for (int k = 0; k < variabl1407.length; k++) { 

      x2[variabl1407[k]] = Double.parseDouble(variabl2197[0][variabl1407[k]]); 

      } 

      for (int i = 0; i < tableModel.getRowCount(); i++) { 

      for (int k = 0; k < variabl1407.length; k++) { 

      x1[i][variabl1407[k]] = Double.parseDouble(variabl2197[i][variabl1407[k]]); 

      } 

      if (variabl1987.trim().equals("求记录数")) 

      for (int k = 0; k < variabl1407.length; k++) { 

      x2[variabl1407[k]] = tableModel.getRowCount(); 

      } 

      

      else if (variabl1987.trim().equals("求最大")) { 

      for (int k1 = 0; k1 < variabl1407.length; k1++) { 

      if (x2[variabl1407[k1]] < x1[i][variabl1407[k1]]) 

      x2[variabl1407[k1]] = x1[i][variabl1407[k1]]; 

      } 

      } 

      else if (variabl1987.trim().equals("求最小")) { 

      for (int k1 = 0; k1 < variabl1407.length; k1++) { 

      if (x2[variabl1407[k1]] > x1[i][variabl1407[k1]]) 

      x2[variabl1407[k1]] = x1[i][variabl1407[k1]]; 

      } 

      } 

      else { 

      for (int k0 = 0; k0 < variabl1407.length; k0++) { 

      x2[variabl1407[k0]] = x2[variabl1407[k0]]+ x1[i][variabl1407[k0]]; 

      } 

      } 

      } 

      for (int k = 0; k < variabl1407.length; k++) { 

      x0[variabl1407[k]] = x2[variabl1407[k]] / tableModel.getRowCount(); 

      if (variabl1987.trim().equals("求平均")) 

      x2[variabl1407[k]] = x0[variabl1407[k]]; 

      } 

      for (int k1 = 0; k1 < variabl1407.length; k1++) { 

      variabl2615[variabl1407[k1]] = "" + x2[variabl1407[k1]]; 

      } 

      tableModel.addRow(variabl2615); 

      } 

      else { 

      for (int k = 0; k < variabl1407.length; k++) { 

      x2[variabl1407[k]] = Double.parseDouble(variabl2197[0][variabl1407[k]]); 

      } 

      for (int i = 0; i < tableModel.getRowCount(); i++) { 

      for (int k = 0; k < variabl1407.length; k++) { 

      x1[i][variabl1407[k]] = Double.parseDouble(variabl2197[i][variabl1407[k]]); 

      } 

      } 

      for (int i = 0; i < tableModel.getRowCount(); i++) 

      for (int k1 = 0; k1 < variabl1407.length; k1++) { 

      x2[variabl1407[k1]] = (x1[i][variabl1407[k1]] - x0[variabl1407[k1]]) 

      * (x1[i][variabl1407[k1]] - x0[variabl1407[k1]]); 

      x3[variabl1407[k1]] = x3[variabl1407[k1]] + x2[variabl1407[k1]]; 

      } 

      if ((variabl1987.trim().equalsIgnoreCase("求统计标准偏差stdev")) 

      || ((variabl1987.trim().equalsIgnoreCase("求统计方差")))) 

      for (int k1 = 0; k1 < variabl1407.length; k1++) { 

      x2[variabl1407[k1]] = Math.sqrt(x3[variabl1407[k1]] 

      / (tableModel.getRowCount() - 1)); 

      } 

      else if ((variabl1987.trim().equalsIgnoreCase("求填充统计标准偏差stdevp")) 

      || ((variabl1987.trim().equalsIgnoreCase("求填充统计方差")))) 

      for (int k1 = 0; k1 < variabl1407.length; k1++) { 

      x2[variabl1407[k1]] = Math.sqrt(x3[variabl1407[k1]] 

      / tableModel.getRowCount()); 

      } 

      

      if (((variabl1987.trim().equalsIgnoreCase("求统计方差var"))) 

      || (variabl1987.trim().equalsIgnoreCase("求填充统计方差varp"))) 

      for (int k1 = 0; k1 < variabl1407.length; k1++) { 

      x2[variabl1407[k1]] = x2[variabl1407[k1]] * x2[variabl1407[k1]]; 

      } 

      for (int k1 = 0; k1 < variabl1407.length; k1++) 

      variabl2615[variabl1407[k1]] = "" + x2[variabl1407[k1]]; 

      

      tableModel.addRow(variabl2615); 

      } 

      for (int i = 0; i < tableModel.getRowCount(); i++) 

      for (int j = 0; j < variabl2651; j++) 

      if (tableModel.getValueAt(i, j) == null) 

      variabl21971[i][j] = " "; 

      else 

      variabl21971[i][j] = tableModel.getValueAt(i, j) 

      .toString().trim(); 

      } 

      }); 

      if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",0,") >= 0)) { 

      variabl2645.setBounds(variabl1423, variabl2503 - 150, variabl2339, 20); 

      panel.add(variabl2645); 

      variabl1423 = variabl1423 + variabl2339; 

      } 

      

      JButton variabl2091 = new JButton(variabl2405[1]); 

      variabl2091.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

      dataPreview0.printView1(variabl2517[1], variabl21971, variabl1489, variabl2603); 

      } 

      }); 

      if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",1,") >= 0)) { 

      variabl2091.setBounds(variabl1423, variabl2503 - 150, variabl2339, 20); 

      panel.add(variabl2091); 

      variabl1423 = variabl1423 + variabl2339; 

      } 

      

      JButton variabl2617 = new JButton(variabl2405[2]); 

      variabl2617.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

      dataPrint0.printView1(variabl2517[1], variabl21971, variabl1489, variabl2603); 

      } 

      }); 

      if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",2,") >= 0)) { 

      variabl2617.setBounds(variabl1423, variabl2503 - 150, variabl2339, 20); 

      panel.add(variabl2617); 

      variabl1423 = variabl1423 + variabl2339; 

      } 

      

      JButton variabl2639 = new JButton(variabl2405[3]); 

      variabl2639.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

      for (int i = 0; i < variabl2517[1].length; i++) 

      dataTransfer0.Trans(variabl2517[1], variabl1501, variabl1489, "", variabl21971, variabl2603); 

      } 

      }); 

      if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",3,") >= 0)) { 

      variabl2639.setBounds(variabl1423, variabl2503 - 150, variabl2339, 20); 

      panel.add(variabl2639); 

      variabl1423 = variabl1423 + variabl2339; 

      } 

      

      JButton variabl2599 = new JButton(variabl2405[4]); 

      variabl2599.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

      frame.setVisible(false); 

      frame.dispose(); 

      } 

      }); 

      if ((variabl1779.length() < 3) || (variabl1779.lastIndexOf(",4,") >= 0)) { 

      variabl2599.setBounds(variabl1423, variabl2503 - 150, variabl2339, 20); 

      panel.add(variabl2599); 

      variabl1423 = variabl1423 + variabl2339; 

      } 

      frame.getContentPane().add(panel, null); 

      frame.setVisible(true); 

      frame.getContentPane().add(panel, BorderLayout.SOUTH); 

       } 

          } 

58.源码58，部件程序，分组统计。对全表按某些字段分组后对每组及全部数据的若干字段进行求和或求平均或求最大或最小或记录条数或标准偏差或填充标准偏差或统计方差或填充统计方差或ABC分类等分组数据统计部件。

/** 

 * 程序文件名：dataStatistic2.java 

 * 作者：程学先 

 * 完成时间：2013年12月3日 

 * 功能：分组统计。对全表按某些字段分组后对每组及全部数据的若干字段进行求和或求平均或求最大 

 * 或最小或记录条数或标准偏差或填充标准偏差 或统计方差或填充统计方差等， 

 * 统计数据添加在数据表每组后和最后一行中。 

 * 被调用语句：dataStatistic2.means(parameter)。 

 * 必须提供的参数：“表名”、要求统计的字段“统计字段名集”、统计类型要求“统计项目类型”、“分组字段名”。 

 * 可选择参数：要求显示的字段号表、按钮号表。 

 * 其中打印要求要求先利用程序printFormat1.java生成格式文件 

 * 在“字统计字段名集”处可以输入多个字段名，为准备求和等统计的字段名。 

 * 在“分组字段名”处可以输入多个字段名，为分组要求的字段名。 

 * 在“统计项目”处的参数只能从{求和、求平均、求最大、求最小、求记录数、求平均偏差、求相对偏差、 

 * 求统计标准偏差stdev、求填充统计标准偏差stdevp、求统计方差var、求填充统计方差varp、ABC分类} 

 * 等11个选项中选择一个。 

 * 本程序应用计算方法求有关统计值。 

 * 可以联系代码表、字典表进行查询。 

 * 如果涉及代码表，在生成菜单程序时，在填表名时，应当先在列表框中选主表，再依次选代码表。 

 * 如果涉及字典表，将根据字典表给定的对应关系变换标签。 

 * 要求在当前数据库中有一个表的名字为某某某字典表， 

 * 即表名最后3个字是“字典表”，本程序将根据该表变换。 

 * 要求该表中只有二个字段，第一个字段（命名为字段名）中内容为所查询的数据表中字段名， 

 * 第二个字段（命名为标签名）内容为变换后的标签名。 

 */ 

     import java.awt.*; 

     import java.awt.event.*; 

     import javax.swing.*; 

     import javax.swing.table.*; 

     import java.sql.*; 

     import java.util.ArrayList; 

     public class dataStatistic2 extends JFrame { 

         static dataStatistic2 frame = new dataStatistic2();  

         static dataStatistic2 frame1 = new dataStatistic2(); 

         static String variabl2603;  

         static String variabl1873; 

         static String variabl2429; 

         static DefaultTableModel tableModel;  

         static ArrayList variabl1895=new ArrayList(); 

         static JTable table; 

         static JScrollPane scrollPane = new JScrollPane();   

          static String s1="";   

         static ResultSet rs;   

         static int b=0,c=0;  

         static int variabl2651;  

         static String[][] variabl2517;  

         static String[] variabl1501;  

         static int[] variabl1489;  

         static int variabl1853,variabl18531,分组个数,分组个数1;  

         static String[][] variabl2197;

         static String[][] variabl21971; 

         static String[][] variabl21972;  

         static String [][] variabl26151; 

         static String [][] variabl26154;   

         static String variabl2093; 

         static String variabl1677; 

         static int [] variabl1495; 

         static String variabl1735; 

         static String variabl1987; 

         static int [] variabl1407; 

         static String variabl2049; 

         static String variabl1325; 

         static String variabl1779,分类比例; 

         static int variabl2337=80; 

          static Connection con; 

         static ResultSetMetaData rsmd3; 

         static Statement sta3; 

         static int variabl2483 = 1000, variabl2503 = 600;

      static String [] variabl2405=null; 

      static String variabl1187; 

      static int variabl2851=0,variabl2339=0; 

      

     public static void means(String [] parameter) { 

      frame = new dataStatistic2();  

      frame1 = new dataStatistic2(); 

      variabl1895=new ArrayList(); 

      scrollPane = new JScrollPane();   

      s1=""; b=0;c=0;variabl2337=80; 

      variabl2483 = 1000; variabl2503 = 600; 

      String [] variabl240501={"统计","打印预览","打印","导出","退出"}; 

         variabl2405=new String[variabl240501.length]; 

         variabl2851=0; 

         for (int i0=0;i0<variabl240501.length;i0++) 

           variabl2405[i0]= variabl240501[i0]; 

      if (parameter[11].length()>0){ 

      variabl1187=parameter[11] ;

      variabl1187=variabl1187.replaceAll("；",";"); 

      variabl1187=variabl1187.replaceAll("。",";"); 

      variabl1187=variabl1187.replaceAll(":",";"); 

      variabl1187=variabl1187.replaceAll("：",";"); 

      if (variabl1187.indexOf(";")>0){   

      String s601[]=variabl1187.split(","); 

      variabl1187=""; 

      for (int i01=0;i01<s601.length;i01++){ 

      if (s601[i01].indexOf(";")>0){ 

      String s602[]=s601[i01].split(";"); 

      variabl2405[Integer.parseInt((s602[0]))]=s602[1]; 

      variabl1187=variabl1187+","+s602[0];

      variabl2851++; 

      } 

      else { 

      variabl1187=variabl1187+","+s601[i01];

      variabl2851++; 

      } 

      } 

      }   

      else { 

      String s601[]=variabl1187.split(","); 

      variabl1187=""; 

      for (int i01=0;i01<s601.length;i01++){ 

                if (i01==0) variabl1187=s601[i01]; 

                else variabl1187=variabl1187+","+s601[i01]; 

                variabl2851++; 

         } 

      } 

      } 

      else { 

      variabl1187="";  

      for (int i1=0;i1<variabl2405.length;i1++){ 

      if (i1==0) variabl1187=variabl1187+i1; 

      else variabl1187=variabl1187+","+i1; 

      variabl2851++; 

      } 

      } 

      variabl1187=","+variabl1187+","; 

      variabl2483=main1.variabl2483;  variabl2503=main1.variabl2503; 

      int m1,m2; 

      try{ 

      if (parameter[17].length()==0) { 

      m1=0;m2=0; 

      } 

      else { 

      m1=Integer.parseInt(parameter[17]) ;

      m2=Integer.parseInt(parameter[18]) ; 

      } 

      if (m1>0){ 

      if (m2<80){ 

      m1=m1*10; 

      m2=m2*10; 

      } 

         variabl2483=m1 ; 

         variabl2503=m2 ; 

      } 

      }catch(Exception e2){} 

      frame = new dataStatistic2();variabl1895=new ArrayList(); 

      frame1 = new dataStatistic2(); 

      scrollPane = new JScrollPane();   

      b=0;c=0;variabl2483 = 1000;variabl2503 = 600; 

          variabl1987=parameter[13]; 

          variabl2603=parameter[4]; 

          variabl2049=parameter[20]; 

          variabl1325=parameter[19]; 

          variabl1677=parameter[10]; 

            if (variabl1325.lastIndexOf(",")==variabl1325.length()-1 ) 

            variabl1325=variabl1325.substring(0,variabl1325.length()-1); 

          variabl2429=parameter[0]; 

          variabl1735=parameter[8]; 

          variabl2093=parameter[9]; 

          variabl1779=","+parameter[11]+","; 

          分类比例=parameter[14]; 

             variabl1873=""; 

             String []t1; 

      String s11=variabl2603; 

          if (variabl2603.indexOf(",")>0){ 

          String [] s12=variabl2603.split(","); 

          s11=s12[0]; 

          } 

             if (variabl2429.lastIndexOf(s11+"字典表")>0){  

              t1=variabl2429.split(","); 

              for (int i=0;i<t1.length;i++) 

             if (t1[i].lastIndexOf(s11+"字典表")>=0) variabl1873=t1[i]; 

             } 

             String[] l1; 

             String [] l3=variabl1325.split(","); 

             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       

             {  

          con=main1.getConn();

          sta3 = con.createStatement( 

                  ResultSet.TYPE_SCROLL_INSENSITIVE,    

                  ResultSet.CONCUR_UPDATABLE); 

          String s=""; 

          if (variabl2603.lastIndexOf(",")>0) 

              s="select "+s1+" from "+variabl2603+" where "+variabl2049; 

          else 

          s="select "+s1+" from "+variabl2603; 

          ResultSet rs=sta3.executeQuery(s); 

                  rsmd3 = rs.getMetaData(); 

                 variabl2651=rsmd3.getColumnCount();   

                 variabl2517=new  String[2][variabl2651];  

             variabl1501 = new String[variabl2651]; 

             variabl1489 = new int[variabl2651]; 

             for (int i=0;i<variabl2651;i++) {  

             variabl2517[0][i] = rsmd3.getColumnName(i + 1); 

                 variabl2517[1][i]=variabl2517[0][i];   

             variabl1501[i] = rsmd3.getColumnTypeName(i + 1); 

                 variabl1489[i] = rsmd3.getColumnDisplaySize(i + 1); 

                 } 

             variabl1853=0;   

                 rs.last();  

                 variabl1853=rs.getRow(); 

                 variabl2197=new  String[variabl1853][variabl2651];   

                 variabl21972=new  String[variabl1853*2][variabl2651+4];  

                 

                 

                 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();     

                 sta3.close();     

                 con.close(); 

             }catch(SQLException e){ 

          JOptionPane.showMessageDialog( null, "查询数据出错！");  

             }  

         s1=""; 

      if (variabl1873.length()>0){   

        try {  

        con=main1.getConn();

      sta3 = con.createStatement( 

               ResultSet.TYPE_SCROLL_INSENSITIVE,    

               ResultSet.CONCUR_UPDATABLE);  

      s1 = "select * from " + variabl1873; 

      rs = sta3.executeQuery(s1); 

                      ResultSetMetaData rsmd = rs.getMetaData(); 

                      int numberOfColumns=rsmd.getColumnCount();     

                     String s14=""; 

                     String s15=""; 

                     int b=1; 

                     while (rs.absolute(b)) {  

                         b++; 

                         s14=rs.getString(1).trim();    

                         s15=rs.getString(2).trim();  

                         for (int j=0;j<variabl2651;j++){ 

                             if (variabl2517[0][j].trim().equalsIgnoreCase(s14.trim())){ 

                          variabl2517[1][j]=s15; 

                          break; 

                          } 

                             else if ((variabl2517[0][j].trim()+",").indexOf("."+s14+",")>0){ 

                          variabl2517[1][j]=variabl2517[1][j].replace(s14,s15); 

                      break; 

                          } 

                         } 

                      } 

                      rs.close();     

                      con.close(); 

                      sta3.close(); 

      } catch (SQLException e) 

      { 

      JOptionPane.showMessageDialog( null, "连接数据库出错！"+s1); 

      } 

       } 

      String [] s71=variabl1325.split(",");  

            String s4 []; 

          s4=variabl2093.split(","); 

          for (int i=0;i<s4.length;i++)    

          s4[i]=s71[Integer.parseInt(s4[i])];   

             variabl1407=new int[s4.length]; 

          for (int i=0;i<s4.length;i++)  {   

          for (int j=0;j<variabl2651;j++){ 

          if (s4[i].trim().equals(variabl2517[0][j].trim())) variabl1407[i]=j; 

          } 

          for (int j=0;j<variabl1853;j++) 

          if ((variabl2197[j][variabl1407[i]]==null)|| 

          (variabl2197[j][variabl1407[i]].length()<1)) 

          variabl2197[j][variabl1407[i]]="0"; 

          } 

          String s5 []; 

          s5=variabl1677.split(","); 

          variabl1495=new int[s5.length]; 

          for (int i=0;i<s5.length;i++)  

          for (int j=0;j<variabl2651;j++){ 

          if (s5[i].trim().equalsIgnoreCase(variabl2517[0][j].trim())) variabl1495[i]=j; 

          } 

             variabl26154=new String[variabl1853][6];

             for (int i=0;i<variabl1853;i++) 

              for (int j=0;j<6;j++) 

              variabl26154[i][j]=""; 

              分组个数1=0; 

          String s6="",s7=""; 

          variabl18531=0; 

          String [] variabl2615=new String[variabl2651]; 

          for (int i0=0;i0<variabl1853-1;i0++){ 

          for (int i=0;i<variabl1853-1-i0;i++){ 

          s6=""; 

          s7=""; 

          for (int j=0;j<s5.length;j++) 

            s6=s6+variabl2197[i][variabl1495[j]].trim(); 

          for (int j=0;j<s5.length;j++) 

                 s7=s7+variabl2197[i+1][variabl1495[j]].trim(); 

          if (s6.compareTo(s7)>0) 

          for (int k=0;k<variabl2651;k++){  

          variabl2615[k]=variabl2197[i][k]; 

          variabl2197[i][k]=variabl2197[i+1][k]; 

          variabl2197[i+1][k]=variabl2615[k]; 

          } 

          } 

          } 

          frame.setTitle("查询统计部件程序                           作者：程学先");  

          frame.setBounds(10, 10,variabl2483-10,variabl2503-10);    

         frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 

             frame.getContentPane().setLayout(null);    

             frame1.setTitle("     ABC分类表"); 

          frame1.setBounds(100, 10,variabl2483-10,variabl2503-10);    

         frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 

             frame1.getContentPane().setLayout(null);    

             final JPanel panel = new JPanel(false);      

             final JPanel panel1 = new JPanel(false);      

             panel.setLayout(null);        

             panel.setBounds(20, 20,variabl2483-50,variabl2503-20); 

             panel1.setLayout(null);        

             panel1.setBounds(20, 20,variabl2483-50,variabl2503-20); 

          variabl26151=new String[0][variabl2651]; 

             tableModel = new DefaultTableModel(variabl2197,variabl2517[1]); 

             table = new JTable(tableModel); 

             table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

             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]); 

                int g10=variabl2517[1][i].length(); 

               if (variabl1489[i]>g10) g10=variabl1489[i]; 

                tc.setPreferredWidth(g10*20); 

                tc.setMaxWidth(g10*20); 

                tc.sizeWidthToFit(); 

           } 

            scrollPane.getViewport().add(table, null);  

            scrollPane.setBounds(30, 30,variabl2483-100,variabl2503-200);    

            panel.add(scrollPane);    

             int j=0; 

             variabl1779=variabl1187; 

             if (variabl1779.length()<3) j=5;   

             else  for (int i=0;i<5;i++)    

             if (variabl1779.lastIndexOf(","+i+",")>=0) j=j+1; 

             int variabl2339=(variabl2483-80)/variabl2851; 

             int variabl1423=5; 

              

             JButton variabl2645 = new JButton(variabl2405[0]); 

              variabl2645.addActionListener(new ActionListener() { 

                 public void actionPerformed(ActionEvent e) { 

                  for (int i=tableModel.getRowCount()-1;i>=0;i--) 

                  tableModel.removeRow(i);   

                     String [] variabl2615=new String[variabl2651]; 

                  String [] variabl26152=new String[variabl2651]; 

                  String [] variabl26153=new String[variabl2651]; 

                  double [] x0=new double [variabl2651]; 

                  double [] x1=new double [variabl2651]; 

                  double [] x2=new double [variabl2651]; 

                  double [] x3=new double [variabl2651]; 

                  double [] x4=new double [variabl2651]; 

                  double [][] y0; 

                  double [] y1=new double [variabl2651]; 

                  double [] y2=new double [variabl2651]; 

                  double [] y3=new double [variabl2651]; 

                  double [] y4=new double [variabl2651]; 

                  String s6="",s7=""; 

                  int variabl1523=0; 

                  double [] x=new double [variabl2651];  

                  double [] y=new double [variabl2651];   

                  for (int i=0;i<variabl2651;i++){ 

                  variabl26152[i]=""; 

                  variabl26153[i]=""; 

                  } 

                  Double 总合计=0.0; 

                  int 总记录数=0; 

          s6="";    

          for (int n0=0;n0<variabl1495.length;n0++){ 

              s6=s6+variabl2197[0][variabl1495[n0]].trim(); 

          } 

          for (int k=0;k<variabl1407.length;k++){  

            x1[variabl1407[k]]=Double.parseDouble(variabl2197[0][variabl1407[k]]);  

            y1[variabl1407[k]]=Double.parseDouble(variabl2197[variabl1523][variabl1407[k]]); 

            x2[variabl1407[k]]=0;  

            y2[variabl1407[k]]=0; 

            x3[variabl1407[k]]=0;  

            y3[variabl1407[k]]=0; 

            x4[variabl1407[k]]=0;  

            y4[variabl1407[k]]=0; 

          } 

          for (int n0=0;n0<variabl2651;n0++){ 

          variabl2615[n0]=""; 

          } 

          for (int n=0;n<variabl1853;n++) {  

                     if (("求最大,variabl2493,求记录数,variabl2689,variabl2295,求ABC分类").lastIndexOf(variabl1987)>=0) 

                       tableModel.addRow(variabl2197[n]); 

                  for (int k=0;k<variabl1407.length;k++){ 

                      x[variabl1407[k]]=Double.parseDouble(variabl2197[n][variabl1407[k]]); 

                   if (x[variabl1407[k]]<x1[variabl1407[k]]) x1[variabl1407[k]]=x[variabl1407[k]]; 

                  if (x[variabl1407[k]]>x2[variabl1407[k]]) x2[variabl1407[k]]=x[variabl1407[k]]; 

                  x3[variabl1407[k]]=x3[variabl1407[k]]+x[variabl1407[k]]; 

                  x4[variabl1407[k]]++; 

                   if (x[variabl1407[k]]<y1[variabl1407[k]]) y1[variabl1407[k]]=x[variabl1407[k]]; 

                  if (x[variabl1407[k]]>y2[variabl1407[k]]) y2[variabl1407[k]]=x[variabl1407[k]]; 

                  y3[variabl1407[k]]=y3[variabl1407[k]]+x[variabl1407[k]]; 

                  y4[variabl1407[k]]++; 

                } 

              s7=""; 

              String s8=""; 

                    if(n<variabl1853-1){ 

                  for (int n1=0;n1<variabl1495.length;n1++){ 

                  s7=s7+variabl2197[n+1][variabl1495[n1]].trim(); 

                  if (s8.length()==0) 

                  s8=s8+variabl2197[n][variabl1495[n1]].trim(); 

                  else s8=s8+","+variabl2197[n][variabl1495[n1]].trim(); 

                  } 

                         if (! s6.trim().equalsIgnoreCase(s7.trim())) { 

                         s6=s7; 

                         for (int k=0;k<variabl1407.length;k++){ 

                          if (variabl1987.trim().equals("求最小")) 

                          variabl2615[variabl1407[k]]=""+y1[variabl1407[k]]; 

                          else if (variabl1987.trim().equals("求最大")) 

                          variabl2615[variabl1407[k]]=""+y2[variabl1407[k]]; 

                          else if (variabl1987.trim().equals("求和")) 

                          variabl2615[variabl1407[k]]=""+y3[variabl1407[k]]; 

                               else if (variabl1987.trim().equalsIgnoreCase("求ABC分类")){ 

                            variabl2615[variabl1407[k]]=""+y3[variabl1407[k]]; 

                               } 

                          else if (variabl1987.trim().equals("求记录数")) 

                          variabl2615[variabl1407[k]]=""+(int)y4[variabl1407[k]]; 

                          else if (variabl1987.trim().equals("求平均")){ 

                          variabl2615[variabl1407[k]]=""+y3[variabl1407[k]]/y4[variabl1407[k]]; 

                          } 

                          if (k==0) { 

                          variabl26154[分组个数1][1]=y3[variabl1407[k]]+"";   

                          variabl26154[分组个数1][2]=(int)y4[variabl1407[k]]+"";   

                          variabl26154[分组个数1][0]=s8; 

                          分组个数1++; 

                          } 

                          variabl1895.add(y3[variabl1407[k]]/y4[variabl1407[k]]); 

                         } 

                         if (("求最大,variabl2493,求记录数,variabl2689,求平均").lastIndexOf(variabl1987)>=0) 

                         variabl2615[variabl1495[variabl1495.length-1]]=variabl2197[n][variabl1495[variabl1495.length-1]].trim()+variabl1987.substring(1,variabl1987.length()); 

                         else if (("求ABC分类").lastIndexOf(variabl1987)>=0) 

                             variabl2615[variabl1495[variabl1495.length-1]]=variabl2197[n][variabl1495[variabl1495.length-1]].trim()+"分类"; 

                             if (("求最大,variabl2493,求记录数,variabl2689,variabl2295,求ABC分类").lastIndexOf(variabl1987)>=0) 

                             tableModel.addRow(variabl2615);  

                                                                       variabl1523=n+1; 

                             for (int k=0;k<variabl1407.length;k++){   

                                y1[variabl1407[k]]=Double.parseDouble(variabl2197[variabl1523][variabl1407[k]]); 

                                y2[variabl1407[k]]=0;  

                                y3[variabl1407[k]]=0;   

                              y4[variabl1407[k]]=0;  

                              } 

                              for (int n0=0;n0<variabl2651;n0++){ 

                              variabl2615[n0]=""; 

                              } 

                       } 

                      } 

                     }        

                       for (int k=0;k<variabl1407.length;k++){ 

                      if (variabl1987.trim().equals("求最小")) 

                      variabl2615[variabl1407[k]]=""+y1[variabl1407[k]]; 

                      else if (variabl1987.trim().equals("求最大")) 

                      variabl2615[variabl1407[k]]=""+y2[variabl1407[k]]; 

                      else if (variabl1987.trim().equals("求和")) 

                      variabl2615[variabl1407[k]]=""+y3[variabl1407[k]]; 

                      else if (variabl1987.trim().equalsIgnoreCase("求ABC分类")) 

                                             variabl2615[variabl1407[k]]=""+y3[variabl1407[k]]; 

                      else if (variabl1987.trim().equals("求记录数")) 

                      variabl2615[variabl1407[k]]=""+(int)y4[variabl1407[k]]; 

                      else if (variabl1987.trim().equals("求平均")){ 

                           variabl2615[variabl1407[k]]=""+y3[variabl1407[k]]/y4[variabl1407[k]]; 

                  } 

                    String s9=""; 

                      for (int n1=0;n1<variabl1495.length;n1++){ 

                      if (s9.length()==0) 

                      s9=s9+variabl2197[variabl1853-1][variabl1495[n1]].trim(); 

                      else s9=s9+","+variabl2197[variabl1853-1][variabl1495[n1]].trim(); 

                      } 

                      if (k==0){ 

                  variabl26154[分组个数1][1]=y3[variabl1407[k]]+"";   

                  variabl26154[分组个数1][2]=(int)y4[variabl1407[k]]+"";   

                  variabl26154[分组个数1][0]=s9; 

                      } 

                    variabl1895.add(y3[variabl1407[k]]/y4[variabl1407[k]]); 

                   } 

                   variabl2615[variabl1495[variabl1495.length-1]]=variabl2197[variabl1853-1][variabl1495[variabl1495.length-1]].trim()+variabl1987.substring(1,variabl1987.length()); 

                     if (("求最大,variabl2493,求记录数,variabl2689,variabl2295,求ABC分类").lastIndexOf(variabl1987)>=0){ 

                         tableModel.addRow(variabl2615);  

                       for (int k=0;k<variabl1407.length;k++){ 

                      if (variabl1987.trim().equals("求最小")) 

                      variabl2615[variabl1407[k]]=""+x1[variabl1407[k]]; 

                      else if (variabl1987.trim().equals("求最大")) 

                      variabl2615[variabl1407[k]]=""+x2[variabl1407[k]]; 

                      else if (variabl1987.trim().equals("求和")) 

                      variabl2615[variabl1407[k]]=""+x3[variabl1407[k]]; 

                      else if (variabl1987.trim().equalsIgnoreCase("求ABC分类")) 

                      variabl2615[variabl1407[k]]=""+x3[variabl1407[k]]; 

                      else if (variabl1987.trim().equals("求记录数")) 

                      variabl2615[variabl1407[k]]=""+(int)x4[variabl1407[k]]; 

                      else if (variabl1987.trim().equals("求平均")){ 

                      variabl2615[variabl1407[k]]=""+x0[variabl1407[k]]; 

                          y4[variabl1407[k]]++; 

                          x4[variabl1407[k]]++; 

                      } 

                      if (variabl1987.trim().equals("求平均")){ 

                  x0[variabl1407[k]]=x3[variabl1407[k]]/variabl1853;  

                  variabl2615[variabl1407[k]]=""+x0[variabl1407[k]];   

                      } 

                      if (k==0) 总合计=Double.valueOf(variabl2615[variabl1407[k]]); 

                     } 

                 } 

                    if (("求最大,variabl2493,求记录数,variabl2689,求平均").lastIndexOf(variabl1987)>=0){ 

                              variabl2615[variabl1495[variabl1495.length-1]]="总"+variabl1987.substring(1,variabl1987.length()); 

                    tableModel.addRow(variabl2615); 

                    } 

                  else if (("求ABC分类").lastIndexOf(variabl1987)>=0){ 

                         variabl2615[variabl1495[variabl1495.length-1]]="总分类"; 

                         tableModel.addRow(variabl2615); 

                   } 

                     y0=new double[variabl1895.size()/variabl1407.length+1][variabl1407.length]; 

                     int i1=0; 

                     for (int i=0;i<variabl1895.size()/variabl1407.length;i++) 

                      for (int j=0;j<variabl1407.length;j++){ 

                      y0[i][j]=Double.parseDouble(""+variabl1895.get(i*variabl1407.length+j)); 

                      } 

                      int variabl2543=0; 

                    if (("求最大,variabl2493,求记录数,variabl2689,variabl2295,求ABC分类").lastIndexOf(variabl1987)<0){ 

                         for (int k1=0;k1<variabl1407.length;k1++){ 

                          x2[variabl1407[k1]]=0; 

                          x3[variabl1407[k1]]=0; 

                          y2[variabl1407[k1]]=0; 

                          y3[variabl1407[k1]]=0; 

                          x4[variabl1407[k1]]=0; 

                          y4[variabl1407[k1]]=0; 

                         } 

                         s6="";   

                         for (int n0=0;n0<variabl1495.length;n0++){ 

                            s6=s6+variabl2197[0][variabl1495[n0]].trim(); 

                         } 

                        for (int n=0;n<variabl1853;n++) {  

                             tableModel.addRow(variabl2197[n]);   

                        for (int k=0;k<variabl1407.length;k++){ 

                              x[variabl1407[k]]=Math.abs(Double.parseDouble(variabl2197[n][variabl1407[k]])-x0[variabl1407[k]]); 

                              x2[variabl1407[k]]=x2[variabl1407[k]]+x[variabl1407[k]]; 

                              x3[variabl1407[k]]=x3[variabl1407[k]]+x[variabl1407[k]]*x[variabl1407[k]]; 

                              y[variabl1407[k]]=Math.abs(Double.parseDouble(variabl2197[n][variabl1407[k]])-y0[variabl2543][k]); 

                        y2[variabl1407[k]]=y2[variabl1407[k]]+y[variabl1407[k]]; 

                              y3[variabl1407[k]]=y3[variabl1407[k]]+y[variabl1407[k]]*y[variabl1407[k]]; 

                              x4[variabl1407[k]]++; 

                              y4[variabl1407[k]]++; 

                        } 

              s7=""; 

                    if(n<variabl1853-1) { 

                  for (int n1=0;n1<variabl1495.length;n1++) 

                  s7=s7+variabl2197[n+1][variabl1495[n1]].trim(); 

                         if (! s6.equalsIgnoreCase(s7)) { 

                          s6=s7; 

                           for (int k=0;k<variabl1407.length;k++){ 

                          if (variabl1987.trim().equals("求平均偏差")) 

                          variabl2615[variabl1407[k]]=""+y2[variabl1407[k]]/y4[variabl1407[k]]; 

                          else if (variabl1987.trim().equals("求相对偏差")) 

                          variabl2615[variabl1407[k]]=""+y2[variabl1407[k]]/y4[variabl1407[k]]/y0[variabl2543][k]*100; 

                          else if (variabl1987.trim().equalsIgnoreCase("求统计标准偏差stdev")) 

                          variabl2615[variabl1407[k]]=""+Math.sqrt(y3[variabl1407[k]]/(y4[variabl1407[k]]-1)); 

                          else if (variabl1987.trim().equalsIgnoreCase("求填充统计标准偏差stdevp")) 

                          variabl2615[variabl1407[k]]=""+Math.sqrt(y3[variabl1407[k]]/y4[variabl1407[k]]); 

                          else if (variabl1987.trim().equalsIgnoreCase("求统计方差var")) 

                          variabl2615[variabl1407[k]]=""+y3[variabl1407[k]]/(y4[variabl1407[k]]-1); 

                          else if (variabl1987.trim().equalsIgnoreCase("求填充统计方差varp")) 

                              variabl2615[variabl1407[k]]=""+y3[variabl1407[k]]/y4[variabl1407[k]]; 

                           } 

                       variabl2615[variabl1495[variabl1495.length-1]]=variabl2197[n][variabl1495[variabl1495.length-1]].trim()+variabl1987.substring(1,variabl1987.length()); 

                       tableModel.addRow(variabl2615); 

                                                                       variabl2543++; 

                          for (int n3=0;n3<variabl2651;n3++){ 

                          variabl26153[n3]=""; 

                          y2[n3]=0; 

                          y3[n3]=0; 

                          y4[n3]=0; 

                          } 

                  } 

                     } 

                  } 

                         for (int k=0;k<variabl1407.length;k++){ 

                      if (variabl1987.trim().equals("求平均偏差")) 

                      variabl2615[variabl1407[k]]=""+y2[variabl1407[k]]/y4[variabl1407[k]]; 

                      else if (variabl1987.trim().equals("求相对偏差")) 

                      variabl2615[variabl1407[k]]=""+y2[variabl1407[k]]/y4[variabl1407[k]]/y0[variabl2543][k]*100; 

                      else if (variabl1987.trim().equals("求统计标准偏差")) 

                      variabl2615[variabl1407[k]]=""+Math.sqrt(y3[variabl1407[k]]/(y4[variabl1407[k]]-1)); 

                      else if (variabl1987.trim().equals("求填充统计标准偏差")) 

                      variabl2615[variabl1407[k]]=""+Math.sqrt(y3[variabl1407[k]]/y4[variabl1407[k]]); 

                      else if (variabl1987.trim().equals("求统计方差")) 

                      variabl2615[variabl1407[k]]=""+y3[variabl1407[k]]/(y4[variabl1407[k]]-1); 

                      else if (variabl1987.trim().equals("求填充统计方差")) 

                          variabl2615[variabl1407[k]]=""+y3[variabl1407[k]]/y4[variabl1407[k]]; 

                         } 

                         tableModel.addRow(variabl2615); 

                         for (int k=0;k<variabl1407.length;k++){ 

                      if (variabl1987.trim().equals("求平均偏差")) 

                      variabl2615[variabl1407[k]]=""+x2[variabl1407[k]]/x4[variabl1407[k]]; 

                      else if (variabl1987.trim().equals("求相对偏差")) 

                      variabl2615[variabl1407[k]]=""+x2[variabl1407[k]]/x4[variabl1407[k]]/x0[variabl1407[k]]*100; 

                      else if (variabl1987.trim().equals("求统计标准偏差")) 

                      variabl2615[variabl1407[k]]=""+Math.sqrt(x3[variabl1407[k]]/(x4[variabl1407[k]]-1)); 

                      else if (variabl1987.trim().equals("求填充统计标准偏差")) 

                      variabl2615[variabl1407[k]]=""+Math.sqrt(x3[variabl1407[k]]/x4[variabl1407[k]]); 

                      else if (variabl1987.trim().equals("求统计方差")) 

                      variabl2615[variabl1407[k]]=""+x3[variabl1407[k]]/(x4[variabl1407[k]]-1); 

                      else if (variabl1987.trim().equals("求填充统计方差")) 

                          variabl2615[variabl1407[k]]=""+x3[variabl1407[k]]/x4[variabl1407[k]]; 

                         } 

                         variabl2615[variabl1495[variabl1495.length-1]]="总"+variabl1987.substring(1,variabl1987.length()); 

                          tableModel.addRow(variabl2615); 

                 } 

                variabl21971=new  String[tableModel.getRowCount()][variabl2651];   

                for (int i=0;i<tableModel.getRowCount();i++) 

                  for (int j=0;j<variabl2651;j++){ 

                           if (tableModel.getValueAt(i,j)==null) 

                           variabl21971[i][j]=""; 

                           else  

                  variabl21971[i][j]=tableModel.getValueAt(i,j).toString().trim(); 

                  } 

                if (("求ABC分类").lastIndexOf(variabl1987)>=0){ 

                     String g0=""; 

                for (int i=0;i<=分组个数1;i++){ 

                  for (int j=i;j<=分组个数1;j++){ 

                if (Double.parseDouble(variabl26154[j][1])>Double.parseDouble(variabl26154[i][1])){ 

                for (int k=0;k<6;k++){ 

                g0=variabl26154[i][k]; 

                variabl26154[i][k]=variabl26154[j][k]; 

                variabl26154[j][k]=g0; 

                } 

                } 

                } 

                } 

                Double g1=0.0;   

                String g2[]; 

                if (分类比例.indexOf(",")>0) 

                g2=分类比例.split(","); 

                else g2=分类比例.split("，"); 

                String [] g3={"A","B","C","D","E","F","G","H","I","J"}; 

                int g4=0;   

                Double g5[]=new Double[g2.length]; 

                总记录数=0; 

                  for (int i=0;i<g2.length;i++) 

                g5[i]=Double.parseDouble(g2[i]); 

                     for (int i=0;i<=分组个数1;i++){ 

                      g1=g1+Double.parseDouble(variabl26154[i][1]); 

                      variabl26154[i][3]=g3[g4];   

                      if (g1>(总合计*g5[g4]/100)){ 

                      g1=0.0; 

                      g4++; 

                      } 

                      总记录数=总记录数+Integer.parseInt(variabl26154[i][2]); 

                     } 

                    for (int i=0;i<=分组个数1;i++){ 

                    variabl26154[i][4]=Double.parseDouble(variabl26154[i][1])/总合计*100+""; 

                        variabl26154[i][4]=(variabl26154[i][4]+"        ").substring(0,6); 

                    variabl26154[i][5]=Double.parseDouble(variabl26154[i][2])*100/总记录数+""; 

                        variabl26154[i][5]=(variabl26154[i][5]+"        ").substring(0,6); 

                    } 

                    String [] g6={"分组数据","小计值","记录条数","分类名称","小计占比","记录数占比"}; 

                    DefaultTableModel tableModel1 = new DefaultTableModel(variabl26154,g6); 

                    JTable table1 = new JTable(tableModel1); 

                    table1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

                    table1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF); 

                   table1.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION); 

                   for(int i=0;i<g6.length;i++) {    

                       TableColumn tc1 = table1.getColumn(g6[i]); 

                       tc1.setPreferredWidth(10*8); 

                       tc1.setMaxWidth(10*8); 

                       tc1.sizeWidthToFit(); 

                   } 

                   JScrollPane scrollPane1 = new JScrollPane();  

                   scrollPane1.getViewport().add(table1, null);  

                   scrollPane1.setBounds(30, 30,variabl2483-100,variabl2503-200);    

                   panel1.add(scrollPane1);    

                   frame1.getContentPane().add(panel1, null);  

                   frame1.setVisible(true);   

                } 

              } 

         }); 

            if ((variabl1779.length()<3) || (variabl1779.lastIndexOf(",0,")>=0)){ 

             variabl2645.setBounds(variabl1423,variabl2503-150,variabl2339,20);  

              panel.add(variabl2645);   

                    variabl1423=variabl1423+variabl2339; 

           } 

      

            JButton variabl2091 = new JButton(variabl2405[1]); 

            variabl2091.addActionListener(new ActionListener() { 

                public void actionPerformed(ActionEvent e) { 

                dataPreview0.printView1(variabl2517[1],variabl21971,variabl1489,variabl2603); 

                } 

            }); 

           if ((variabl1779.length()<3) || (variabl1779.lastIndexOf(",1,")>=0)){ 

            variabl2091.setBounds(variabl1423,variabl2503-150,variabl2339,20); 

          panel.add(variabl2091);  

                variabl1423=variabl1423+variabl2339; 

          } 

      

           JButton variabl2617 = new JButton(variabl2405[2]); 

                       variabl2617.addActionListener(new ActionListener() { 

               public void actionPerformed(ActionEvent e) {     

              dataPrint0.printView1(variabl2517[1],variabl21971,variabl1489,variabl2603); 

            } 

           }); 

          if ((variabl1779.length()<3) || (variabl1779.lastIndexOf(",2,")>=0)){ 

          variabl2617.setBounds(variabl1423,variabl2503-150,variabl2339,20);   

          panel.add(variabl2617);  

              variabl1423=variabl1423+variabl2339; 

         } 

      

          JButton variabl2639 = new JButton(variabl2405[3]); 

          variabl2639.addActionListener(new ActionListener() { 

              public void actionPerformed(ActionEvent e) { 

              dataTransfer0.Trans(variabl2517[1],variabl1501,variabl1489,"",variabl21971,variabl2603); 

            } 

          }); 

         if ((variabl1779.length()<3) || (variabl1779.lastIndexOf(",3,")>=0)){ 

          variabl2639.setBounds(variabl1423,variabl2503-150,variabl2339,20);  

          panel.add(variabl2639);  

              variabl1423=variabl1423+variabl2339; 

        } 

      

         JButton variabl2599 = new JButton(variabl2405[4]); 

            variabl2599.addActionListener(new ActionListener() { 

              public void actionPerformed(ActionEvent e) { 

             frame.setVisible(false);  

             frame.dispose(); 

             frame1.setVisible(false);  

             frame1.dispose(); 

            } 

          }); 

         if ((variabl1779.length()<3) || (variabl1779.lastIndexOf(",4,")>=0)){ 

          variabl2599.setBounds(variabl1423,variabl2503-150,variabl2339,20); 

          panel.add(variabl2599);  

          variabl1423=variabl1423+variabl2339; 

        } 

          final String [] g6={"分组数据","小计值","记录条数","分类名称","小计占比","记录数占比"}; 

          final int [] g7={100,100,50,50,100,100};

          final String [] g8={"char","Double","int","char","Double","Double"}; 

                variabl1423=50; 

         JButton variabl20911 = new JButton("打印预览"); 

        variabl20911.addActionListener(new ActionListener() { 

            public void actionPerformed(ActionEvent e) { 

            dataPreview0.printView1(g6,variabl26154,g7,"ABC分类表"); 

            } 

        }); 

       if ((variabl1779.length()<3) || (variabl1779.lastIndexOf(",1,")>=0)){ 

        variabl20911.setBounds(variabl1423,variabl2503-150,variabl2339,20); 

          panel1.add(variabl20911);  

            variabl1423=variabl1423+variabl2339; 

      } 

      

       JButton variabl26171 = new JButton("打   印"); 

        variabl26171.addActionListener(new ActionListener() { 

           public void actionPerformed(ActionEvent e) {     

          dataPrint0.printView1(g6,variabl26154,g7,"ABC分类表"); 

        } 

       }); 

      if ((variabl1779.length()<3) || (variabl1779.lastIndexOf(",2,")>=0)){ 

      variabl26171.setBounds(variabl1423,variabl2503-150,variabl2339,20);   

          panel1.add(variabl26171);  

          variabl1423=variabl1423+variabl2339; 

     } 

       

      final int [] g9={20,20,6,6,20,20};

      JButton variabl26391 = new JButton("导       出"); 

      variabl26391.addActionListener(new ActionListener() { 

          public void actionPerformed(ActionEvent e) { 

          dataTransfer0.Trans(g6,g8,g9,"",variabl26154,"ABC分类表"); 

        } 

        }); 

       if ((variabl1779.length()<3) || (variabl1779.lastIndexOf(",3,")>=0)){ 

      variabl26391.setBounds(variabl1423,variabl2503-150,variabl2339,20);  

          panel1.add(variabl26391);  

          variabl1423=variabl1423+variabl2339; 

        } 

        frame.getContentPane().add(panel, null);  

        frame.setVisible(true);   

        frame.getContentPane().add(panel, BorderLayout.SOUTH); 

        } 

       } 

      

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

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