版本1

104.源码104，实验程序，仅供参考。读取数据表中的二个数字类型数据字段数据应用公式法寻求拟合最好的函数。本程序尝试用一元一次函数：y=a+bx、 一元多项式函数：y=a1+a2x+a3x2+……、指数函数：y=a+bex、正弦函数：y=a+bsin(x)等对一组实验数据进行尝试性拟合，找出一个函数式使按式计算值域测试数据的拟合误差最小。

/*

 * 程序文件名：dataMining1.java

 * 作者：程学先

 * 功能：实验程序，读取数据表中的二个数字类型数据字段数据应用公式法寻求拟合最好的函数。

 * 本程序尝试用一元一次函数：y=a+bx、 一元多项式函数：y=a1+a2x+a3x2+……、

 * 指数函数：y=a+bex、正弦函数：y=a+bsin(x)

 * 等对一组实验数据进行尝试性拟合，找出一个函数式使按式计算值域测试数据的拟合误差最小。

 * 测试用实验数据除多元一次函数外，均二列数据。

 * 数据第一列数据为纵坐标Y数据，第2列数据为横坐标X数据。

 * 拟合完成后显示拟合函数式，显示拟合图形。

 * 并且提供文本框允许输入x值，之后点击“预测”按钮，可预测y的值。

 * 拟合结束后显示实验数据

 * 调用： dataMining1(); 

 */

 

import java.awt.BasicStroke;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Insets;

import java.awt.List;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableColumn;

import javax.swing.table.TableModel;

 

public class dataMining1 extends JFrame {

   private static final long serialVersionUID = 3672837897457785750L;

   static dataMining1 frame1 = new dataMining1();

   static double[] 纵向数据;

   static double[] 横向数据;

   static double 纵向最大值 = 0, 纵向最小值 = 0;

   static double 横向最大值 = 0, 横向最小值 = 0;

   static int 窗口宽度 = 1340, 窗口高度 = 700;

   static String 回归方程1 = "";

   static Graphics g;

   static Graphics2D g2;

   static Insets inset;

   static int 左边 = 100, 到顶 = 窗口高度;

   private static JTable table;

   static String 表名;

   static int 窗口宽 = 1400;

   static String[][] 记录1;

   static int 表格列号1, 表格列号2;

   static Object[][] 表格数据;

   static List list1 = new List();

   static JTextField fa0, fa1, fa2, fa3, fb1, ja10, ja15, ja16, ja17, ja18,

        ja19;

   static JLabel fl5, fl6, fl7, fl8, fl9, fl10;

   static JButton Button0;

   static JTextArea jta1;

   private static Connection cont4;

   private static Statement stat4;

   private static ResultSetMetaData rsmdt4;

   private static ResultSet rs;

   static String[] 列名;

   static int 记录条数, 列数, 当前列号;

   static String[] 列数据类型;

   private static int[] 列数据宽度;

   private static String[][] 表格数据0;

   private static String 连接条件 = "";

   private static String 字段名表 = "";

 

   public static void 显示数据表格() {

     JScrollPane scrollPane = new JScrollPane();

     scrollPane.setBounds(10, 10, 窗口宽 - 60, 窗口高度 - 100);

     TableModel model = new DefaultTableModel(表格数据, 列名);

     table = new JTable(model);

     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

      table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

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

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

        tc.setPreferredWidth(100);

        tc.setMaxWidth(100);

        tc.sizeWidthToFit();

     }

     scrollPane.setViewportView(table);

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

     inset = frame1.getInsets();

     return;

   }

 

   public static void 显示数据表格1() {

     列数据宽度[0] = 列数据宽度[0] + 6;

     列数据宽度[1] = 列数据宽度[1] + 6;

     JScrollPane scrollPane = new JScrollPane();

     scrollPane.setBounds(10, 10, 窗口宽 - 60, 窗口高度 - 100);

     TableModel model = new DefaultTableModel(表格数据, 列名);

     table = new JTable(model);

     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

      table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

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

        TableColumn tc = table.getColumn(列名[i1]);

        tc.setPreferredWidth(20);

        tc.setMaxWidth(20);

        tc.sizeWidthToFit();

     }

     scrollPane.setViewportView(table);

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

     inset = frame1.getInsets();

   }

   static void means(String parameter[]) {

     frame1 = new dataMining1();

      frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

     frame1.setTitle(" 公式法数据分析               作者：程学先       ");

     frame1.setBounds(10, 10, 窗口宽度, 窗口高度 + 50);

     frame1.setLayout(null);

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

     String 字段名字串 = parameter[19];

     String y坐标 = parameter[8]; // Y坐标号，限一个字段号

     if (y坐标.indexOf(",") > 0)

        y坐标 = y坐标.substring(0, y坐标.indexOf(","));

     String x坐标 = parameter[9]; // X坐标号，限一个字段号

     if (x坐标.indexOf(",") > 0)

        x坐标 = x坐标.substring(0, x坐标.indexOf(","));

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

        连接条件 = " where " + parameter[20];

     else

        连接条件 = "";

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

     String[] s2 = (y坐标 + "," + x坐标).split(",");

     字段名表 = "";

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

        if (i == 0)

           字段名表 = s1[Integer.parseInt(s2[i])];

        else

           字段名表 = 字段名表 + "," + s1[Integer.parseInt(s2[i])];

     数据表查询数据(表名);

     calc01.纵向最大值 = 0;

     calc01.纵向最小值 = 0;

     calc01.横向最大值 = 0;

     calc01.横向最小值 = 0;

     calc01.纵向分段数 = 20;

     calc01.横向分段数 = 10;

     纵向最大值 = 0;

     纵向最小值 = 0;

     横向最大值 = 0;

     横向最小值 = 0;

     记录1 = new String[记录条数][表格数据[0].length];

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

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

           记录1[i][j] = 表格数据[i][j].toString();

        }

     if (记录1[0].length < 3)

        显示数据表格();

     JLabel fl0 = new JLabel("纵向字段名");

     frame1.add(fl0);

     fa0 = new JTextField(列名[0], 20);

     frame1.add(fa0);

     fl0.setBounds(310, 窗口高度 - 80, 80, 20);

     fa0.setBounds(390, 窗口高度 - 80, 80, 20);

     fa0.addFocusListener(new FocusAdapter() {

        public void focusGained(final FocusEvent arg0) {

           当前列号 = 0;

        }

     });

 

     JLabel fl2 = new JLabel("横向字段名");

     frame1.add(fl2);

     fa2 = new JTextField(列名[1], 20);

     frame1.add(fa2);

     fl2.setBounds(470, 窗口高度 - 80, 80, 20);

     fa2.setBounds(550, 窗口高度 - 80, 80, 20);

     fa2.addFocusListener(new FocusAdapter() {

        public void focusGained(final FocusEvent arg0) {

           当前列号 = 2;

        }

     });

     JLabel fl4 = new JLabel("计算过程");

     fl4.setBounds(1100, 窗口高度 - 90, 80, 30);

     frame1.add(fl4);

     jta1 = new JTextArea();

     frame1.add(jta1);

     jta1.setBounds(1000, 40, 310, 560);

     fl5 = new JLabel("x1=");

     frame1.add(fl5);

     ja15 = new JTextField();

     frame1.add(ja15);

     fl5.setBounds(30, 窗口高度 - 55, 30, 20);

     ja15.setBounds(60, 窗口高度 - 55, 100, 20);

     fl6 = new JLabel("x2=");

     frame1.add(fl6);

     ja16 = new JTextField();

     frame1.add(ja16);

     fl6.setBounds(160, 窗口高度 - 55, 30, 20);

     ja16.setBounds(190, 窗口高度 - 55, 100, 20);

     fl7 = new JLabel("x3=");

     frame1.add(fl7);

     ja17 = new JTextField();

     frame1.add(ja17);

     fl7.setBounds(290, 窗口高度 - 55, 30, 20);

     ja17.setBounds(320, 窗口高度 - 55, 100, 20);

     fl8 = new JLabel("x4=");

     frame1.add(fl8);

     ja18 = new JTextField();

     frame1.add(ja18);

     fl8.setBounds(420, 窗口高度 - 55, 30, 20);

     ja18.setBounds(450, 窗口高度 - 55, 100, 20);

     fl9 = new JLabel("y=");

     frame1.add(fl9);

     ja19 = new JTextField();

     frame1.add(ja19);

     fl9.setBounds(550, 窗口高度 - 55, 30, 20);

     ja19.setBounds(580, 窗口高度 - 55, 100, 20);

     fl10 = new JLabel("拟合误差");

     frame1.add(fl10);

     ja10 = new JTextField();

     frame1.add(ja10);

     fl10.setBounds(680, 窗口高度 - 55, 60, 20);

     ja10.setBounds(740, 窗口高度 - 55, 100, 20);

 

     Button0 = new JButton("预测y值");

     Button0.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           try {

             double z01 = Double.parseDouble(ja15.getText());

             double yyy1 = 0;

             if (calc01.选中序号 == 1) { // 一元线性回归

                yyy1 = calc01.系数[0] + calc01.系数[1] * z01;

                ja19.setText((yyy1 + "      ").substring(0, 6));

             } else if (calc01.选中序号 == 5) { // 指数函数拟合

                yyy1 = calc01.系数[0] + calc01.系数[1] * Math.exp(z01);

                ja19.setText((yyy1 + "      ").substring(0, 6));

             } else if (calc01.选中序号 == 6) { // 正弦拟合

                yyy1 = calc01.系数[0] + calc01.系数[1] * Math.sin(z01);

                ja19.setText((yyy1 + "      ").substring(0, 6));

             } else if (calc01.选中序号 == 10) { // 多元回归

                z01 = Double.parseDouble(ja15.getText());

                yyy1 = calc01.系数[0] + calc01.系数[1] * z01;

                if ((calc01.系数[2] != 0) && (ja16.getText() != null)) {

                   double z02 = Double.parseDouble(ja16.getText());

                   yyy1 = yyy1 + calc01.系数[2] * z02;

                }

                if ((calc01.系数[3] != 0) && (ja17.getText() != null)) {

                   double z03 = Double.parseDouble(ja16.getText());

                   yyy1 = yyy1 + calc01.系数[3] * z03;

                }

                if ((calc01.系数[4] != 0) && (ja18.getText() != null)) {

                   double z04 = Double.parseDouble(ja16.getText());

                   yyy1 = yyy1 + calc01.系数[4] * z04;

                }

                ja19.setText((yyy1 + "      ").substring(0, 6));

             } else { // 曲线拟合

                yyy1 = 0;

                z01 = Double.parseDouble(ja15.getText());

                yyy1 = calc01.系数[0] + calc01.系数[1] * z01 + calc01.系数[2]

                      * z01 * z01;

                ja19.setText((yyy1 + "      ").substring(0, 6));

             }

           } catch (Exception e2) {

           }

        }

     });

     Button0.setBounds(850, 窗口高度 - 55, 120, 20);

     frame1.add(Button0);

     Button0.setVisible(false);

     fl5.setVisible(false);

     fl6.setVisible(false);

     fl7.setVisible(false);

     fl8.setVisible(false);

     fl9.setVisible(false);

     fl10.setVisible(false);

     ja15.setVisible(false);

     ja16.setVisible(false);

     ja17.setVisible(false);

     ja18.setVisible(false);

     ja19.setVisible(false);

     ja10.setVisible(false);

 

     final JButton Button1 = new JButton("计算并显示图表");

     Button1.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           if (记录1[0].length > 2) {

             calc01.选中序号 = 10;

             calc01.多元回归(记录1);

           } else {

             纵向数据 = new double[记录条数];

             横向数据 = new double[记录条数];

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

                纵向数据[i] = Double.parseDouble(表格数据[i][0].toString());

                横向数据[i] = Double.parseDouble(表格数据[i][1].toString());

             }

             calc01.calc011();

           }

           Button0.setVisible(true);

           fl5.setVisible(true);

           ja15.setVisible(true);

           fl9.setVisible(true);

           ja19.setVisible(true);

           ja10.setVisible(true);

           fl10.setVisible(true);

        }

     });

     Button1.setBounds(680, 窗口高度 - 80, 170, 20);

     frame1.add(Button1);

 

     final JButton Button2 = new JButton("退出");

     Button2.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           calc01.frame2.setVisible(false);

           calc01.frame2.dispose();

           frame1.setVisible(false);

           frame1.dispose();

           System.exit(0);

        }

     });

     Button2.setBounds(850, 窗口高度 - 80, 120, 20);

     frame1.add(Button2);

     frame1.setVisible(true);

   }

 

   static void 数据表查询数据(String 数据表名) {

     int c = 0;

     int b = 0;

     String s1 = "";

     try {

        cont4 = main1.getConn();

        stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

             ResultSet.CONCUR_UPDATABLE);

        s1 = "select " + 字段名表 + "  from " + 数据表名 + 连接条件;

        rs = stat4.executeQuery(s1);

        rsmdt4 = rs.getMetaData();

        列数 = rsmdt4.getColumnCount();

        列名 = new String[列数];

        列数据类型 = new String[列数];

        列数据宽度 = new int[列数];

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

           列名[i1] = rsmdt4.getColumnName(i1 + 1);

           列数据类型[i1] = rsmdt4.getColumnTypeName(i1 + 1);

           列数据宽度[i1] = rsmdt4.getColumnDisplaySize(i1 + 1);

        }

        rs.last();

        记录条数 = rs.getRow();

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

        int t = 1;

        while (c < 记录条数) {

           rs.absolute(c + 1);

           while (b < 列数) {

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

             if ((main1.数字数据类型.lastIndexOf("," + 列数据类型[b] + ",")) > 0)

                if ((表格数据0[c][b] == null)

                      || (表格数据0[c][b].trim().length() == 0))

                   表格数据0[c][b] = "0";

                else if (表格数据0[c][b] == null)

                   表格数据0[c][b] = "";

             double x0 = Double.parseDouble(表格数据0[c][b].toString());

             if ((x0 > 0.00001) || (x0 < -0.00001))

                t = 0;

             b++;

           }

           if (t == 1) {

             break;

           }

           c++;

           b = 0;

           t = 1;

        }

        记录条数 = c;

        rs.close();

        stat4.close();

        cont4.close();

     } catch (SQLException e1) {

        JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

     }

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

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

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

           表格数据[i1][j1] = 表格数据0[i1][j1];

   }

}

 

class calc01 extends JFrame {

   private static final long serialVersionUID = 1L;

   static calc01 frame2 = new calc01();

   static Graphics g;

   static double[] 纵向数据, 横向数据;

   static int 记录条数;

   static int 窗口宽度 = 1000, 窗口高度 = 700;

   static double 纵向最大值 = 0, 纵向最小值, 横向最大值 = 0, 横向最小值;

   static int 纵向分段数 = 20, 横向分段数 = 10;

   static String 回归方程1;

   static int 可用高度, 方次数, 变量数;

   static double 纵向坐标单位数据;

   static double 纵向单位数据长度; // 乘系数后值

   static int Y线左边距 = 60, w0 = 0, h0 = 0;

   static int Y线到顶距 = 60;

   static double 横向坐标单位数据; // 乘系数后值

   static double 横向单位数据长度; // 乘系数后值

   static double x和1 = 0, y和1 = 0, xy和1 = 0, x平方和1 = 0;

   static double x平均1 = 0, y平均1 = 0, Lxx1 = 0, Lxy1 = 0;

   static double yyy;

   static double xxx;

   static double 拟合误差 = 0, 选中序号 = 0;

   static double[] 系数 = new double[20];

   static void calc011() {

     calc01 frame2 = new calc01();

      frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

     frame2.setBounds(10, 10, 1000, 窗口高度 - 50);

     frame2.setVisible(true);

   }

 

   public void paint(Graphics g1) {

     记录条数 = dataMining1.记录条数;

     纵向数据 = new double[记录条数];

     横向数据 = new double[记录条数];

     纵向最小值 = dataMining1.纵向数据[0];

     横向最小值 = dataMining1.横向数据[0];

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

        纵向数据[i] = dataMining1.纵向数据[i];

        横向数据[i] = dataMining1.横向数据[i];

        if (纵向数据[i] > 纵向最大值)

           纵向最大值 = 纵向数据[i];

        if (纵向数据[i] < 纵向最小值)

           纵向最小值 = 纵向数据[i];

        if (横向数据[i] > 横向最大值)

           横向最大值 = 横向数据[i];

        if (横向数据[i] < 横向最小值)

           横向最小值 = 横向数据[i];

     }

     g1.setColor(Color.WHITE); // 白色

     g1.fillRect(0, 0, getWidth(), getHeight()); // 清空画面

     g = g1;

     brokenLine(); // 调用下面方法画图

   }

 

   static void brokenLine() { // 画图方法

     g.setColor(Color.BLACK); // 黑色

     可用高度 = 窗口高度 - 200;

     double 可用宽度 = 窗口宽度 - 100;

     double 纵向单位象素点数 = 可用高度 / (纵向最大值 - 纵向最小值); // 根据纵向数据确定单位数据的象素点数

     double 横向单位象素点数 = 可用宽度 / (横向最大值 - 横向最小值); // 根据横向数据确定单位数据的象素点数

     纵向坐标单位数据 = (double) ((纵向最大值 - 纵向最小值)) / (纵向分段数); // 每段数据差值

     纵向单位数据长度 = (double) (可用高度) / (纵向最大值 - 纵向最小值); // 乘系数后值

     Y线左边距 = 60;

     Y线到顶距 = 60;

     横向坐标单位数据 = (double) ((横向最大值 - 横向最小值)) / (横向分段数); // 每段数据差值

     横向单位数据长度 = (double) ((窗口宽度 - 200)) / (横向最大值 - 横向最小值); // 乘系数后值

     double[] 纵向单位数据 = new double[纵向分段数 + 1];

     纵向单位数据[0] = 纵向最小值;

     for (int i = 1; i < 纵向分段数 + 1; i++) {

        纵向单位数据[i] = 纵向单位数据[i - 1] + (纵向最大值 - 纵向最小值) / 纵向分段数;

     }

     double[] 横向单位数据 = new double[横向分段数 + 1];

     横向单位数据[0] = 横向最小值;

     for (int i = 1; i < 横向分段数 + 1; i++) {

        横向单位数据[i] = 横向单位数据[i - 1] + (横向最大值 - 横向最小值) / 横向分段数;

     }

     选中序号 = 1;

     一元回归();

     曲线拟合(2);

     曲线拟合(3);

     曲线拟合(4);

     最小二乘(2);

     最小二乘(3);

     最小二乘(4);

     指数函数();

     正弦函数();

     Graphics2D g2 = (Graphics2D) g;

     g2.setStroke(new BasicStroke(2f));

     g.drawLine(Y线左边距, Y线到顶距 - 10, Y线左边距, 可用高度 + Y线到顶距 + 5);// 纵坐标线

     g.drawLine(Y线左边距, Y线到顶距 - 15, Y线左边距 - 3, Y线到顶距);// 纵向箭头短线

     g.drawLine(Y线左边距, Y线到顶距 - 15, Y线左边距 + 2, Y线到顶距);// 纵向箭头短线

     g.setColor(Color.RED);

    g.drawString(dataMining1.fa0.getText(), Y线左边距 + 10, Y线到顶距 - 5); // 纵坐标列名

     int x = 0, y = 0;

     w0 = 5;

     h0 = 5;

     double y2, z1;

     y2 = ((y平均1 - Lxy1 * x平均1 / Lxx1) + (Lxy1 / Lxx1) * 横向最大值) - 纵向最小值;// 乘系数后值

     y2 = 可用高度 + Y线到顶距 - y2 * 纵向单位数据长度;// 乘系数后值

     g.setColor(Color.RED);

     double xx1 = 横向最小值;// 乘系数后值

     double xx2 = 横向最大值;// 乘系数后值

     double yy1 = (y平均1 - Lxy1 * x平均1 / Lxx1) + (Lxy1 / Lxx1 * xx1); // 乘系数前值

     double yy2 = (y平均1 - Lxy1 * x平均1 / Lxx1) + (Lxy1 / Lxx1 * xx2); // 乘系数前值

     xx1 = (xx1 - 横向最小值) * 横向单位数据长度 + Y线左边距;

     xx2 = (xx2 - 横向最小值) * 横向单位数据长度 + Y线左边距;

     yy1 = (yy1 - 纵向最小值) * 纵向单位数据长度;

     yy2 = (yy2 - 纵向最小值) * 纵向单位数据长度;

     yy1 = 可用高度 + Y线到顶距 - yy1;

     yy2 = 可用高度 + Y线到顶距 - yy2;

     String z0;

     for (int i = 0; i < 纵向分段数; i++) {

        z1 = 纵向单位数据[i + 1];

        z0 = z1 + "        ";

        z0 = z0.substring(0, 6);

        x = Y线左边距 - 40;

        y = Y线到顶距 * 2 + 可用高度- (int) (Y线左边距 + (i + 1)

             * 纵向单位数据长度 * 纵向坐标单位数据);

        g.setColor(Color.RED);

        g.drawString(z0, x, y); // 纵坐标标签

        g.setColor(Color.BLACK);

        g.drawLine(x + 35, y, x + 45, y); // 纵向单位点短线

     }

     if (((纵向最大值 > 0) && (纵向最大值 * 纵向最小值 >= 0))

           || ((纵向最大值 <= 0) && (纵向最小值 < 0))) { // 如果纵向最大值域最小值同号或最小值为0

        g.drawLine(x, Y线到顶距 + 可用高度, x + 窗口宽度 - 80, Y线到顶距 + 可用高度); // 横向坐标延长线

       g.drawLine(x + 窗口宽度 - 100, Y线到顶距 + 可用高度 - 3, x + 窗口宽度 - 80, Y线到顶距

             + 可用高度); // 横向箭头短线

       g.drawLine(x + 窗口宽度 - 100, Y线到顶距 + 可用高度 + 3, x + 窗口宽度 - 80, Y线到顶距

             + 可用高度); // 横向箭头短线

        g.setColor(Color.RED);

        g.drawString(dataMining1.fa2.getText(), x + 窗口宽度 - 120, Y线到顶距

             + 可用高度 - 20); // 横向坐标列名

        for (int i = 0; i < 横向分段数; i++) {

           g.setColor(Color.RED);

           z1 = 横向单位数据[i + 1];

           z0 = z1 + "        ";

           z0 = z0.substring(0, 6);

           x = (int) (Y线左边距 + (i + 1) * 横向单位数据长度 * 横向坐标单位数据);

           y = Y线到顶距 + 可用高度 + 6;

           g.drawString(z0, x, y + 10); // 纵向单位数据[i]

           g.setColor(Color.BLACK);

           g.drawLine(x, y - 10, x, y - 5); // 横向单位点短线

        }

     } else {

        int 横坐标0位置 = (int) (可用高度 + Y线到顶距 - (0 - 纵向最小值) * 纵向单位数据长度);

        g.drawLine(x, 横坐标0位置, x + 窗口宽度 - 80, 横坐标0位置); // 横向坐标延长线

        g.drawLine(x + 窗口宽度 - 100, 横坐标0位置 - 3, x + 窗口宽度 - 80, 横坐标0位置); // 横向箭头短线

        g.drawLine(x + 窗口宽度 - 100, 横坐标0位置 + 3, x + 窗口宽度 - 80, 横坐标0位置); // 横向箭头短线

        g.setColor(Color.RED);

        g.drawString(dataMining1.fa2.getText(), x + 窗口宽度 - 120 + 20,

             横坐标0位置 - 20); // 横向坐标列名

        for (int i = 0; i < 横向分段数; i++) {

           g.setColor(Color.RED);

           z1 = ((i + 1) * 横向坐标单位数据 + 横向最小值);

           z0 = z1 + "        ";

           z0 = z0.substring(0, 6);

           x = (int) (Y线左边距 + (i + 1) * 横向单位数据长度 * 横向坐标单位数据);

           y = 横坐标0位置 + 6;

           g.drawString(z0, x, y + 10); // 横向单位标签

           g.setColor(Color.BLACK);

           g.drawLine(x, y - 10, x, y - 5); // 横向单位点短线

        }

     }

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

        yyy = (纵向数据[i] - 纵向最小值) * 纵向单位数据长度;

        yyy = 可用高度 + Y线到顶距 - yyy;

        xxx = (横向数据[i] - 横向最小值) * 横向单位数据长度 + Y线左边距;// 打点

        g.fillOval((int) xxx, (int) yyy, w0, h0); // 打所有测试数据坐标点

     }

     g.setColor(Color.RED);

     double yyy1 = 0, xxx1, yyy2, xxx2, yyy3, xxx3;

     xxx1 = 横向最小值;

     变量数 = 1;

     if (选中序号 == 1)

        yyy1 = 系数[0] + 系数[1] * xxx1;

     else if (选中序号 == 5)

        yyy1 = 系数[0] + 系数[1] * Math.exp(xxx1);

     else if (选中序号 == 6)

        yyy1 = 系数[0] + 系数[1] * Math.sin(xxx1);

     else {

        for (int i4 = 0; i4 < 6; i4++) {

           yyy1 = yyy1 + 系数[i4] * Math.pow(xxx1, i4);

           if (系数[i4] != 0)

             变量数 = i4;

        }

     }

     yyy3 = (yyy1 - 纵向最小值) * 纵向单位数据长度;

     yyy3 = 可用高度 + Y线到顶距 - yyy3;

     xxx3 = (xxx1 - 横向最小值) * 横向单位数据长度 + Y线左边距;

     int 递增系数 = 200;

     for (int i = 1; i < 递增系数; i++) { // 画拟合线，横坐标每次递增200分之一

        xxx = xxx1 + (横向最大值 - 横向最小值) / 递增系数;

        if (选中序号 == 1)

           yyy = 系数[0] + 系数[1] * xxx;

        else if (选中序号 == 5)

           yyy = 系数[0] + 系数[1] * Math.exp(xxx);

        else if (选中序号 == 6)

           yyy = 系数[0] + 系数[1] * Math.sin(xxx);

        else {

           yyy = 0;

           for (int i4 = 0; i4 < 系数.length; i4++) {

             yyy = yyy + 系数[i4] * Math.pow(xxx, i4);

           }

        }

        xxx2 = xxx;

        yyy2 = yyy;

        yyy = (yyy - 纵向最小值) * 纵向单位数据长度;

        yyy = 可用高度 + Y线到顶距 - yyy;

        xxx = (xxx - 横向最小值) * 横向单位数据长度 + Y线左边距;

        g.drawLine((int) xxx3, (int) yyy3, (int) xxx, (int) yyy); // 打所有测试数据坐标点

        xxx1 = xxx2;

        yyy1 = yyy2;

        xxx3 = xxx;

        yyy3 = yyy;

     }

     g.drawString(回归方程1, 100, 可用高度 + 100);

   }

 

   public static void 一元回归() {

     // 以下计算回归曲线

     x和1 = 0;

     y和1 = 0;

     xy和1 = 0;

     x平方和1 = 0;

     x平均1 = 0;

     y平均1 = 0;

     Lxx1 = 0;

     Lxy1 = 0;

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

        x和1 = x和1 + 横向数据[i];

        y和1 = y和1 + 纵向数据[i];

        xy和1 = xy和1 + 横向数据[i] * 纵向数据[i];

        x平方和1 = x平方和1 + 横向数据[i] * 横向数据[i];

 

        yyy = (纵向数据[i] - 纵向最小值) * 纵向单位数据长度;

        yyy = 可用高度 + Y线到顶距 - yyy;

        xxx = (横向数据[i] - 横向最小值) * 横向单位数据长度 + Y线左边距;

     }

     x平均1 = x和1 / 记录条数;

     y平均1 = y和1 / 记录条数;

     Lxx1 = x平方和1 - x和1 * x和1 / 记录条数;

     Lxy1 = xy和1 - x和1 * y和1 / 记录条数;

     String v1 = ((y平均1 - Lxy1 * x平均1 / Lxx1) + "      ").substring(0, 6);

     String v2 = ((Lxy1 / Lxx1) + "      ").substring(0, 6);

     回归方程1 = "回归方程1=" + "Y=" + v1 + "+" + v2 + "x";

     char x1 = 13, x22 = 10;

     String 显示 = "  x和=" + x和1 + x1 + x22;

     显示 = 显示 + "  y和=" + y和1 + x1 + x22;

     显示 = 显示 + "  xy和=" + xy和1 + x1 + x22;

     显示 = 显示 + "  x平方和=" + x平方和1 + x1 + x22;

     显示 = 显示 + "  x平均=" + x和1 / 记录条数 + x1 + x22;

     显示 = 显示 + "  y平均=" + y和1 / 记录条数 + x1 + x22;

     显示 = 显示 + " Lxx=x平方和-x和*x和/记录条数=" + (x平方和1 - x和1 * x和1 / 记录条数) + x1

           + x22;

     显示 = 显示 + " Lxy=xy和-x和*y和/记录条数=" + (xy和1 - x和1 * y和1 / 记录条数) + x1 + x22;

     显示 = 显示 + " Y=(y平均-Lxy*x平均/Lxx)+(Lxy/Lxx)*x" + x1 + x22;

     double a = y和1 / 记录条数 - (xy和1 - x和1 * y和1 / 记录条数) * x和1 / 记录条数

           / (x平方和1 - x和1 * x和1 / 记录条数);

     double b = (xy和1 - x和1 * y和1 / 记录条数) / (x平方和1 - x和1 * x和1 / 记录条数);

     if (Lxy1 / Lxx1 > 0)

        显示 = 显示 + "  =" + (y平均1 - Lxy1 * x平均1 / Lxx1) + "+" + (Lxy1 / Lxx1)

             + "*x";

     else

        显示 = 显示 + "  =" + (y平均1 - Lxy1 * x平均1 / Lxx1) + (Lxy1 / Lxx1)

             + "*x";

     dataMining1.jta1.setText(显示.trim());

     double c = 0;

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

        c = c + (纵向数据[i] - (a + b * 横向数据[i]))

             * (纵向数据[i] - (a + b * 横向数据[i]));

     }

     拟合误差 = Math.sqrt(c);

     dataMining1.ja10.setText((拟合误差 + "").substring(0, 6));

     系数[0] = a;

     系数[1] = b;

   }

 

   public static void 最小二乘(int 方次数) {

     try {

        double[] X = new double[横向数据.length];

        double[] Y = new double[横向数据.length];

        for (int i1 = 0; i1 < 横向数据.length; i1++) {

           X[i1] = 横向数据[i1];

           Y[i1] = 纵向数据[i1];

        }

        int mm = X.length;

        int m = mm - 1;// 为方便观察使用m

        double bel[] = new double[方次数];

        double alp[] = new double[方次数 + 1];

        double A[] = new double[方次数 + 1];// A存放多项式系数，范围A[0]~A[n]

        double error;// 误差平方和

        double err[] = new double[m + 1];// 记录个点误差

        double sum[] = new double[m + 1];// 记录个点拟合值

        double my_sum = 0;

        double S1[] = new double[m + 1];// S1存放前一次多项式的值，范围为S1[0]~S1[m]

        double S0[] = new double[m + 1];// S0存放前两次多项式的值，范围为S0[0]~S0[m]

        double SS[] = new double[m + 1];// 用于交换

        double AU = 0, AL = 0, alp_L = 0, alp_U = 0, bel_U = 0, bel_L = 0;

        double sum_temp[] = new double[m + 1];

        my_sum = 0;

        double my_sumtemp = 0;

        boolean flag = true;

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

           AU += Y[i];

           AL++;

           alp_L++;

           alp_U += X[i];

           S0[i] = 1;

        }

        A[0] = AU / AL;

        bel_L = AL;

        alp[1] = alp_U / alp_L;

        my_sum += A[0] * 1;

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

           sum[i] += A[0] * 1;

        }

        AU = 0;

        AL = 0;

        alp_L = 0;

        alp_U = 0;

        bel_U = 0;// 变量清零

        double temp = 0;

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

           temp = (X[i] - alp[1]);

           S1[i] = temp;

           AU += Y[i] * temp;

           AL += temp * temp;

           alp_U += X[i] * temp * temp;

        }

        alp_L = AL;

        A[1] = AU / AL;

        alp[2] = alp_U / alp_L;

        bel_U = AL;

        bel[1] = bel_U / bel_L;

        my_sum += A[1] * (X[1] - alp[1]);

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

           sum[i] += A[1] * (X[i] - alp[1]);

        }

        int n = 方次数;

        for (int j = 3; j <= n; j++) {

           AU = 0;

           AL = 0;

           alp_L = 0;

           alp_U = 0;

          bel_U = 0;

           bel_L = 0;// 每次计算变量清零

           for (int ii = 0; ii <= m; ii++) {

             SS[ii] = S1[ii];

           }

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

             sum_temp[i] = (X[i] - alp[j - 1]) * S1[0] - bel[j - 2]

                   * S0[0];

           }

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

             if (flag) {

                my_sumtemp = (X[1] - alp[j - 1]) * S1[0] - bel[j - 2]

                      * S0[0];

             }

             bel_L = bel_L + S1[i] * S1[i];

             S1[i] = (X[i] - alp[j - 1]) * S1[i] - bel[j - 2] * S0[i];

             alp_L = alp_L + S1[i] * S1[i];

             alp_U = alp_U + X[i] * S1[i] * S1[i];

             S0[i] = SS[i];

             AU = AU + Y[i] * S1[i];

             flag = false;

           }

           flag = true;

           bel_U = alp_L;

           AL = alp_L;

           alp[j] = alp_U / alp_L;

           bel[j - 1] = bel_U / bel_L;

           A[j - 1] = AU / AL;

           my_sum += A[j - 1] * my_sumtemp;

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

             sum[i] += A[j - 1] * sum_temp[i];

           }

        }

        AU = 0;

        AL = 0;

        alp_L = 0;

        alp_U = 0;

        bel_U = 0;

        bel_L = 0;// 变量清零

        for (int ii = 0; ii <= m; ii++) {

           SS[ii] = S1[ii];

        }

        flag = true;

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

           sum_temp[i] = (X[i] - alp[n]) * S1[0] - bel[n - 1] * S0[0];

        }

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

           if (flag) {

             my_sumtemp = (X[1] - alp[n]) * S1[0] - bel[n - 1] * S0[0];

           }

           S1[i] = (X[i] - alp[n]) * S1[i] - bel[n - 1] * S0[i];

           AL = AL + S1[i] * S1[i];

           S0[i] = SS[i];

           AU = AU + Y[i] * S1[i];

           flag = false;

        }

        A[n] = AU / AL;

        my_sum += A[n] * my_sumtemp;

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

           sum[i] += A[n] * sum_temp[i];

        }

        String sk = "";

        String sk1 = "";

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

           A[i] = A[i] * Math.pow(10, (i - 2));

           sk1 = (A[i] + "      ").substring(0, 6);

           if ((i == 0) && (A[i] != 0))

             sk = sk + sk1;

           if ((i == 1) && (A[i] != 0))

             sk = sk + "+" + sk1 + "x";

           if ((i == 2) && (A[i] != 0))

             sk = sk + "+" + sk1 + "x^2";

           if ((i == 3) && (A[i] != 0))

             sk = sk + "+" + sk1 + "x^3";

           if ((i == 4) && (A[i] != 0))

             sk = sk + "+" + sk1 + "x^4";

        }

        double xc = 0, xc1 = 0;

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

           xc1 = ((A[0] + A[1] * 横向数据[i1] + A[2] * 横向数据[i1] * 横向数据[i1]

                + A[3] * 横向数据[i1] * 横向数据[i1] * 横向数据[i1] + A[4]

                * 横向数据[i1] * 横向数据[i1] * 横向数据[i1] * 横向数据[i1]));

           xc = xc + (纵向数据[i1] - xc1) * (纵向数据[i1] - xc1);

        }

        xc = Math.sqrt(xc);

        if (xc < 拟合误差) {

           拟合误差 = xc;

           dataMining1.ja10.setText((拟合误差 + "").substring(0, 6));

           回归方程1 = sk;

           选中序号 = 3; // 3表示正交多项式拟合

           for (int i3 = 0; i3 < A.length; i3++)

             系数[i3] = A[i3];

        }

     } catch (Exception e2) {

     }

   }

 

   public static void 曲线拟合(int 方次数) {

     try {

        int i = 0;

        double[] a = new double[6], dt = new double[3];

        double[] x = new double[横向数据.length];

        double[] y = new double[横向数据.length];

        for (int i1 = 0; i1 < 横向数据.length; i1++) {

           x[i1] = 横向数据[i1];

           y[i1] = 纵向数据[i1];

        }

        int n = x.length; // 数据个数

        int m = 方次数;

        int j = 0, k = 0;

        double z = 0.0, p = 0.0, c = 0.0, g = 0.0, q = 0.0, d1 = 0.0, d2 = 0.0;

        double[] s = new double[20], t = new double[20], b = new double[20];

        for (i = 0; i <= m - 1; i++)

           a[i] = 0.0;

        if (m > n)

           m = n;

        if (m > 20)

           m = 20;

        z = 0.0;

        for (i = 0; i <= n - 1; i++) {

           z = z + x[i] / (1.0 * n);

        }

        b[0] = 1.0;

        d1 = 1.0 * n;

        p = 0.0;

        c = 0.0;

        for (i = 0; i <= n - 1; i++) {

           p = p + (x[i] - z);

           c = c + y[i];

        }

        c = c / d1;

        p = p / d1;

        a[0] = c * b[0];

        if (m > 1) {

           t[1] = 1.0;

           t[0] = -p;

           d2 = 0.0;

           c = 0.0;

           g = 0.0;

           for (i = 0; i <= n - 1; i++) {

             q = x[i] - z - p;

             d2 = d2 + q * q;

             c = c + y[i] * q;

             g = g + (x[i] - z) * q * q;

           }

           c = c / d2;

           p = g / d2;

           q = d2 / d1;

           d1 = d2;

           a[1] = c * t[1];

           a[0] = c * t[0] + a[0];

        }

        for (j = 2; j <= m - 1; j++) {

           s[j] = t[j - 1];

           s[j - 1] = -p * t[j - 1] + t[j - 2];

           if (j >= 3)

             for (k = j - 2; k >= 1; k--)

                s[k] = -p * t[k] + t[k - 1] - q * b[k];

           s[0] = -p * t[0] - q * b[0];

           d2 = 0.0;

           c = 0.0;

           g = 0.0;

           for (i = 0; i <= n - 1; i++) {

             q = s[j];

             for (k = j - 1; k >= 0; k--)

                q = q * (x[i] - z) + s[k];

             d2 = d2 + q * q;

             c = c + y[i] * q;

             g = g + (x[i] - z) * q * q;

           }

           c = c / d2;

           p = g / d2;

           q = d2 / d1;

           d1 = d2;

           a[j] = c * s[j];

           t[j] = s[j];

           for (k = j - 1; k >= 0; k--) {

             a[k] = c * s[k] + a[k];

             b[k] = t[k];

             t[k] = s[k];

           }

        }

        dt[0] = 0.0;

        dt[1] = 0.0;

        dt[2] = 0.0;

        for (i = 0; i <= n - 1; i++) {

           q = a[m - 1];

           for (k = m - 2; k >= 0; k--)

             q = a[k] + q * (x[i] - z);

           p = q - y[i];

           if (Math.abs(p) > dt[2])

             dt[2] = Math.abs(p);

           dt[0] = dt[0] + p * p;

           dt[1] = dt[1] + Math.abs(p);

        }

        String sk = "", sk1 = "";

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

           a[i] = a[i] * Math.pow(10, (i + 1 - 方次数));

           sk1 = (a[i] + "      ").substring(0, 6);

           if ((i == 0) && (a[i] != 0))

             sk = sk + sk1;

           if ((i == 1) && (a[i] != 0))

             sk = sk + "+" + sk1 + "x";

           if ((i == 2) && (a[i] != 0))

             sk = sk + "+" + sk1 + "x^2";

           if ((i == 3) && (a[i] != 0))

             sk = sk + "+" + sk1 + "x^3";

           if ((i == 4) && (a[i] != 0))

             sk = sk + "+" + sk1 + "x^4";

        }

        double xc = 0, xc1 = 0;

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

           xc1 = ((a[0] + a[1] * 横向数据[i1] + a[2] * 横向数据[i1] * 横向数据[i1]

                + a[3] * 横向数据[i1] * 横向数据[i1] * 横向数据[i1] + a[4]

                * 横向数据[i1] * 横向数据[i1] * 横向数据[i1] * 横向数据[i1]));

           xc = xc + (纵向数据[i1] - xc1) * (纵向数据[i1] - xc1);

        }

        xc = Math.sqrt(xc);

        if (xc < 拟合误差) {

           拟合误差 = xc;

           回归方程1 = "y=" + sk;

           dataMining1.ja10.setText((拟合误差 + "").substring(0, 6));

           选中序号 = 4; // 4表示曲线拟合

           for (int i3 = 0; i3 < a.length; i3++)

             系数[i3] = a[i3];

        }

     } catch (Exception e2) {

     }

   }

 

   public static void 指数函数() {

     String sk = "";

     try {

        double[] x1 = new double[横向数据.length];

        double[] y1 = new double[横向数据.length];

        for (int i1 = 0; i1 < 横向数据.length; i1++) {

           x1[i1] = 横向数据[i1];

           y1[i1] = 纵向数据[i1];

        }

        int n = x1.length;

        double x[] = new double[x1.length];

        double y[] = new double[x1.length];

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

           x[i] = Math.exp(x1[i]);

           y[i] = y1[i];

        }

        double[] a = new double[2];

        double[] dt = new double[6];

        int i;

        double xx, yy, e, f, q, u, p, umax, umin, s;

        xx = 0.0;

        yy = 0.0;

        for (i = 0; i <= n - 1; i++) {

           xx = xx + x[i] / n;

           yy = yy + y[i] / n;

        }

        e = 0.0;

        f = 0.0;

        for (i = 0; i <= n - 1; i++) {

           q = x[i] - xx;

           e = e + q * q;

           f = f + q * (y[i] - yy);

        }

        a[1] = f / e;

        a[0] = yy - a[1] * xx;

        q = 0.0;

        u = 0.0;

        p = 0.0;

        umax = 0.0;

        umin = 1.0e+30;

        sk = ((a[0] + "      ").substring(0, 6) + "+"

             + (a[1] + "      ").substring(0, 6) + "*e^x");

        for (i = 0; i <= n - 1; i++) {

           s = a[1] * x[i] + a[0];

           q = q + (y[i] - s) * (y[i] - s);

           p = p + (s - yy) * (s - yy);

           e = Math.abs(y[i] - s);

           if (e > umax)

             umax = e;

           if (e < umin)

             umin = e;

           u = u + e / n;

        }

        dt[1] = Math.sqrt(q / n);

        dt[0] = q;

        dt[2] = p;

        dt[3] = umax;

        dt[4] = umin;

        dt[5] = u;

        double xc = 0, xc1 = 0;

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

           xc1 = a[0] + a[1] * Math.exp(横向数据[i1]);

           xc = xc + (纵向数据[i1] - xc1) * (纵向数据[i1] - xc1);

        }

        xc = Math.sqrt(xc);

        if (xc < 拟合误差) {

           拟合误差 = xc;

           选中序号 = 5; // 5表示指数函数拟合

           回归方程1 = "y=" + sk;

           系数[0] = a[0];

           系数[1] = a[1];

           dataMining1.ja10.setText((拟合误差 + "").substring(0, 6));

        }

     } catch (Exception e2) {

     }

   }

 

   public static void 正弦函数() { //6表示正弦函数拟合

     String sk = "";

     try {

        double[] x1 = new double[横向数据.length];

        double[] y1 = new double[横向数据.length];

        for (int i1 = 0; i1 < 横向数据.length; i1++) {

           x1[i1] = 横向数据[i1];

           y1[i1] = 纵向数据[i1];

        }

        double x[] = new double[x1.length];

        double y[] = new double[x1.length];

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

           x[i] = Math.sin(x1[i]);

           y[i] = y1[i];

        }

        int n = x.length;

        double[] a = new double[2];

        double[] dt = new double[6];

        int i;

        double xx, yy, e, f, q, u, p, umax, umin, s;

        xx = 0.0;

        yy = 0.0;

        for (i = 0; i <= n - 1; i++) {

           {

             xx = xx + x[i] / n;

             yy = yy + y[i] / n;

           }

        }

        e = 0.0;

        f = 0.0;

        for (i = 0; i <= n - 1; i++) {

           q = x[i] - xx;

           e = e + q * q;

           f = f + q * (y[i] - yy);

        }

        a[1] = f / e;

        a[0] = yy - a[1] * xx;

        q = 0.0;

        u = 0.0;

        p = 0.0;

        umax = 0.0;

        umin = 1.0e+30;

        sk = "y=" + (a[0] + "      ").substring(0, 6) + "+"

             + (a[1] + "      ").substring(0, 6) + "*sin(x)";

        for (i = 0; i <= n - 1; i++) {

           s = a[1] * x[i] + a[0];

           q = q + (y[i] - s) * (y[i] - s);

           p = p + (s - yy) * (s - yy);

           e = Math.abs(y[i] - s);

           if (e > umax)

             umax = e;

           if (e < umin)

             umin = e;

           u = u + e / n;

        }

        dt[1] = Math.sqrt(q / n);

        dt[0] = q;

        dt[2] = p;

        dt[3] = umax;

        dt[4] = umin;

        dt[5] = u;

        double xc = 0, xc1 = 0;

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

           xc1 = a[0] + a[1] * Math.sin(横向数据[i1]);

           xc = xc + (纵向数据[i1] - xc1) * (纵向数据[i1] - xc1);

        }

        xc = Math.sqrt(xc);

        if (xc < 拟合误差) {

           拟合误差 = xc;

           回归方程1 = sk;

           选中序号 = 6; // 6表示正弦函数拟合

           系数[0] = a[0];

           系数[1] = a[1];

           dataMining1.ja10.setText((拟合误差 + "").substring(0, 6));

        }

     } catch (Exception e2) {

     }

   }

 

   public static void 多元回归(String[][] 记录1) {

     try {

        double[][] source = new double[记录1.length][记录1[0].length];

        for (int i1 = 0; i1 < 记录1.length; i1++) {

           for (int j1 = 0; j1 < 记录1[0].length; j1++) {

             source[i1][j1] = Double.parseDouble(记录1[i1][j1]);

           }

        }

        int rowNum = source.length + 1;

        int colNum = source[0].length + 1;

        double[] mean = new double[colNum - 1];// 每列均值

        double[] dev = new double[colNum - 1];// 每列方差

        double[][] sp = new double[colNum - 1][colNum - 1];// 离差阵

        double[][] r = new double[colNum - 1][colNum - 1];// 相关系数矩阵

        ArrayList<String> choose = new ArrayList<String>();// 被选中的自变量

        for (int i = 0; i < colNum - 1; i++) {

           double[] listdouble = getdoublebycolumn(source, i);

           double sum = 0;

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

             sum += listdouble[j];

           mean[i] = sum / listdouble.length;

        }

        for (int i = 0; i < colNum - 1; i++) {

           double[] listdouble = getdoublebycolumn(source, i);

           double sum = 0;

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

             sum += Math.pow((listdouble[j] - mean[i]), 2);

           dev[i] = (double) Math.sqrt(sum / listdouble.length);

        }

        for (int i = 0; i < colNum - 1; i++) {

 

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

             sp[i][j] = 0;

             for (int k = 0; k < rowNum - 1; k++)

                sp[i][j] += (source[k][i] - mean[i])

                      * (source[k][j] - mean[j]);

             sp[j][i] = sp[i][j];

           }

        }

        for (int i = 0; i < colNum - 1; i++) {

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

             r[i][j] = (double) (sp[i][j] / Math.sqrt(sp[i][i]

                   * sp[j][j]));

             r[j][i] = r[i][j];

           }

        }

        double F_in = 3.280;

        double F_out = 3.280;

        for (int k = 0; k < colNum - 2; k++) {

           double[] u = new double[colNum - 2];

           for (int i = 0; i < colNum - 2; i++) {

             u[i] = r[colNum - 2][i] * r[colNum - 2][i] / r[i][i];

           }

           double Q = r[colNum - 2][colNum - 2];// 剩余平方和

           int min_index = getMinIndex(u, choose);

           double[][] r3 = new double[colNum - 1][colNum - 1];

           double pF_out = u[min_index]

                / (Q / (rowNum - 1 - choose.size() - 1));

          if (!(Math.abs(pF_out) > F_out)) {

             choose.remove(min_index + "");

             r = trans(r, min_index, colNum);

             break;

           }

           for (String in : choose) {

             int ii = Integer.parseInt(in);

             u[ii] = 0;

           }

           int index = getMaxIndex(u);

           double pF = u[index]

                / ((r[colNum - 2][colNum - 2] - u[index]) / ((rowNum - 1)

                      - choose.size() - 1 - 1));

           double[][] r2 = new double[colNum - 1][colNum - 1];

           if (pF > F_in) {

             choose.add(index + "");

             r = trans(r, index, colNum);

           }

        }

        double[] b = new double[choose.size()];

        int bi = 0;

        for (String in : choose) {

           int ii = Integer.parseInt(in);

           b[bi] = r[ii][colNum - 2] * dev[colNum - 2] / dev[ii];

           bi++;

        }

        double b0 = mean[colNum - 2];

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

           b0 -= b[i] * mean[Integer.parseInt(choose.get(i))];

        }

        系数[0] = b0;

        String ans = "y=" + (b0 + "       ").substring(0, 6) + "+";

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

           int iii = Integer.parseInt(choose.get(i)) + 1;

           if (i < b.length - 1) {

             ans += (b[i] + "       ").substring(0, 6) + "x" + iii + "+";

             系数[iii] = b[i];

           } else {

             ans += (b[i] + "       ").substring(0, 6) + "x" + iii;

             系数[iii] = b[i];

           }

        }

        double rr = (double) Math.sqrt(1 - r[colNum - 2][colNum - 2]);

        double ssy = 0, ssy1 = 0, xc = 0;

        for (int i = 0; i < rowNum - 1; i++) {

           ssy += (source[i][colNum - 2] - mean[colNum - 2])

                * (source[i][colNum - 2] - mean[colNum - 2]);

           ssy1 = source[i][colNum - 2];

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

             ssy1 = ssy1 - b[j] * source[i][j];

           }

           xc = xc + ssy1 * ssy1;

        }

        double d = (double) Math.sqrt(r[colNum - 2][colNum - 2] * ssy

             / rowNum - 1 - choose.size() - 1);

        xc = Math.sqrt(xc);

        char x1 = 10, x2 = 13;

        if (系数[1] != 0) {

           dataMining1.fl6.setVisible(true);

           dataMining1.ja16.setVisible(true);

        }

        if (系数[2] != 0) {

           dataMining1.fl7.setVisible(true);

           dataMining1.ja17.setVisible(true);

        }

        if (系数[3] != 0) {

           dataMining1.fl8.setVisible(true);

           dataMining1.ja18.setVisible(true);

        }

        JOptionPane.showMessageDialog(null, "回归方程：" + ans + x1 + x2

             + "实验数据标准误差: " + (xc + "       ").substring(0, 6));

     } catch (Exception e2) {

     }

   }

 

   public static double[] getdoublebycolumn(double[][] strarray, int column) {

     int rowlength = strarray.length;

     int columnlength = strarray[0].length;

     double[] templist = new double[rowlength];

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

        templist[i] = (strarray[i][column]);

     }

     return templist;

   }

 

   public static int getMaxIndex(double[] pu) {

     int index = 0;

     double max = 0;

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

        if (Math.abs(pu[i]) >= max) {

           index = i;

           max = Math.abs(pu[i]);

        }

     }

     return index;

   }

 

   public static int getMinIndex(double[] pu, ArrayList<String> pchoose) {

     int index = 0;

     double min = 1;

     for (String in : pchoose) {

        int ii = Integer.parseInt(in);

        if (Math.abs(pu[ii]) <= min) {

           index = ii;

           min = Math.abs(pu[ii]);

        }

     }

     return index;

 

   }

 

   public static double[][] trans(double[][] pr, int pindex, int pcol) {

     double[][] r2 = new double[pcol - 1][pcol - 1];

     for (int i = 0; i < pcol - 1; i++)

        for (int j = 0; j < pcol - 1; j++) {

           if (i == pindex && j == pindex)

             r2[i][j] = 1 / pr[i][j];

           else if (i == pindex && j != pindex)

             r2[i][j] = pr[i][j] / pr[i][i];

           else if (i != pindex && j == pindex)

             r2[i][j] = -pr[i][j] / pr[j][j];

           else {

             r2[i][j] = pr[i][j] - pr[i][pindex] * pr[pindex][j]

                   / pr[pindex][pindex];

           }

        }

     return r2;

      }

     }

105.源码105，实验程序，仅供参考。读取纯文本文件二数据表中的数据进行Apriori关联分析。

/*

 * 程序文件名：dataMining2.java

 * 作者：程学先

 * 功能：实验程序，读取纯文本文件二数据表中的数据进行Apriori关联分析。

 * 其中每行一项共一列数据，可以有多个元素，用逗号分隔

 * 例如：某字段数据:

 * 牛奶,啤酒,可口可乐

 * 牛奶,白糖,面包,盐

 * ………………

 * “自动测试频繁集”按钮，从最小支持度=0.05开始

 * 直到0.9每间隔0.05测试一组频繁集显示

 * 对于初学者，不容易确定最小支持度，有了这一功能，就能比较容易找自己所需

 * 可再重新输入最小支持度，点击“显示频繁集”按钮，精确找到所需要的频繁集。

 * 调用：dataMining2();

 */

import java.awt.BorderLayout;

import java.awt.Component;

import java.awt.Insets;

import java.awt.List;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.Arrays;

import java.util.HashSet;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableColumn;

import javax.swing.table.TableModel;

 

public class dataMining2 extends JFrame {

   static int 窗口宽度=1340,窗口高度=600;

    static Insets inset;

    static int 左边=100,到顶=窗口高度;

   private static JTable table;  

   static String 表名;   

    static String [] sk;

   static int 窗口宽=1400,窗口高=600;

   static int  表格列号1,表格列号2;

   static Object[][] 表格数据;

    static List list1 = new List();

    static JTextField fa0,fa1,fa2,fa3,fb1;

    static HashSet<String> set1 = new HashSet<String>(); 

    static TableModel model;

    static JScrollPane scrollPane;

    static double 最小支持度=0;

    static int 项集数=1,元素数=1,元素数1=1;

    static  int 元素个数=set1.size();

    static  int 元素个数2=set1.size(); 

    static  String [] 元素0=null;

    static  String 元素[]=set1.toArray(new String[0]);

    static  String 元素1[]=set1.toArray(new String[0]);

    static  String 元素2[]=set1.toArray(new String[0]);

    static  int 元素次数[]=new int[元素.length];

    static  dataMining2 frame1=new dataMining2();

    static  JButton Button0 = new JButton("显示数据表格");

    static  JButton Button1 = new JButton("显示频繁集");

    static  JButton Button2 = new JButton("自动测试频繁集");

    static  String 频繁集="",频繁集1="";

    static  char x1=10,x2=13;

    static  int 结束标志=0,结束标志1=0;

    static JTextArea jta1;

   private static Connection cont4;

   private static Statement stat4;

   private static ResultSetMetaData rsmdt4;

   private static ResultSet rs;

   static String [] 列名;

    static int 记录条数,列数,当前列号;

    static String [] 列数据类型;

   private static int[] 列数据宽度;

   private static String[][] 表格数据0;

   private static String 连接条件 = "";

   private static String 字段名表 = "";

   

    public static void 显示频繁集1(double 最小支持) {

    最小支持度=最小支持;

    fa0.setText((最小支持度+0.005+"    ").substring(0,4));

    int 元素次数[]=new int[元素.length];

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

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

         if ((","+表格数据[j][1]+",").indexOf(","+元素[i]+",")>=0){

            元素次数[i]++;

         }

      }

    元素1=new String[元素.length];

    元素2=new String[元素.length];

    String [] 元素6=new String[元素.length];

     频繁集="1项集："; 

     int 元素个数0=0;

     for (int i=0;i<元素.length;i++) {  //保存一项集

      元素2[i]=元素[i];       //保存所有单个元素

      if (((元素次数[i]+0.0)/记录条数)>=最小支持度){

      频繁集=频繁集+"{"+元素[i]+":"+元素次数[i]+"}";

      元素6[元素个数0]=元素[i];

      元素个数0++;

      }

     }

    jta1.setText(" 频繁集="+频繁集);

    if (元素个数==0)  结束标志1=1;

       p1(2,元素个数0,元素6);  //以下从2项集开始计算，带过去单个元素

       jta1.setText(" 频繁集="+频繁集);

        char x1=10;x2=13;

        频繁集1=频繁集1+x1+x2+"最小支持度="+((最小支持+0.005)+"    ").substring(0,4)+x1+x2+频繁集;

    }

   

     public static void 显示数据表格1() {

           scrollPane = new JScrollPane();

          scrollPane.setBounds(10,10,700,窗口高-100); 

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

          table = new JTable(model);

           table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

           table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

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

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

               if (i==0) tc.setPreferredWidth(50); 

               else tc.setPreferredWidth(760);

               tc.setMaxWidth(1500);

               tc.sizeWidthToFit();

           }

           scrollPane.setViewportView(table);

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

           inset = frame1.getInsets();

    }

 

     static void means(String parameter[]) {

       frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

      frame1.setTitle("关联分析                           作者：程学先       ");

      frame1.setBounds(10,10,窗口宽度,窗口高度+50);

        frame1.setLayout(null);

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

     String 字段名字串 = parameter[19];

     String 关键字 = parameter[6]; // 限一个字段号

     if (关键字.indexOf(",")>0)

        关键字=关键字.substring(0,关键字.indexOf(","));

     String 项目数据 = parameter[8]; //限一个字段号

     if (项目数据.indexOf(",")>0)

        项目数据=项目数据.substring(0,项目数据.indexOf(","));

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

          连接条件=" where "+parameter[20];

     else 连接条件="";

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

     String [] s2=项目数据.split(",");

     字段名表=关键字;

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

        字段名表=字段名表+","+s1[Integer.parseInt(s2[i])];

     数据表查询数据(表名);

     显示数据表格1();

        JLabel fl0=new JLabel("最小支持度");

        frame1.add(fl0); 

        fa0 = new JTextField("0.2",20);

        frame1.add(fa0);     

        fl0.setBounds(170,窗口高-70,70, 20);

        fa0.setBounds(240,窗口高-70,80, 20);

        fa0.addFocusListener(new FocusAdapter() { 

             public void focusGained(final FocusEvent arg0) {

                    当前列号=0;   

            }

        });

        JLabel fl4=new JLabel("计算数据");

        frame1.add(fl4); 

        jta1 = new JTextArea(); 

        jta1.setLineWrap(true);        //激活自动换行功能

        jta1.setWrapStyleWord(true);           

        fl4.setBounds(1000,10,300, 20);

     JScrollPane 滚动条 = new JScrollPane(jta1);

     滚动条.setBounds(710,30,600, 窗口高-130);

     frame1.add((Component)滚动条);

      Button2.addActionListener(new ActionListener() {     //最小支持度全覆盖显示频繁集

            public void actionPerformed(ActionEvent e) {

               for (double i0=0.05;i0<0.9;i0=i0+0.05){

                if (结束标志1==0)  显示频繁集1(i0);

                else break;

               }

               频繁集1=频繁集1.replaceAll("2项集：3项集：4项集：5项集：6项集：7项集：8项集：9项集：10项集：", "");

               频繁集1=频繁集1.replaceAll("2项集：3项集：4项集：5项集：6项集：7项集：8项集：9项集：", "");

               频繁集1=频繁集1.replaceAll("2项集：3项集：4项集：5项集：6项集：7项集：8项集：", "");

               频繁集1=频繁集1.replaceAll("2项集：3项集：4项集：5项集：6项集：7项集：", "");

               频繁集1=频繁集1.replaceAll("2项集：3项集：4项集：5项集：6项集：", "");

               频繁集1=频繁集1.replaceAll("2项集：3项集：4项集：5项集：", "");

               频繁集1=频繁集1.replaceAll("2项集：3项集：4项集：", "");

               频繁集1=频繁集1.replaceAll("2项集：3项集：", "");

               jta1.setText(频繁集1);

            }

        });

       Button2.setBounds(450,窗口高-70,140, 20);

       frame1.add(Button2);   

     

       Button1.addActionListener(new ActionListener() {//显示频繁集

            public void actionPerformed(ActionEvent e) {

             String [] s10=new String[1];

             String 显示数据="";

             int k=0;

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

                s10=表格数据[i][1].toString().split(",");//求元素

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

                    set1.add(s10[j]);

                }

             }

             元素个数=set1.size();

             元素个数2=set1.size(); 

             元素=set1.toArray(new String[0]);

             元素1=set1.toArray(new String[0]);

             元素2=set1.toArray(new String[0]);

             int 元素次数[]=new int[元素.length];

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

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

                   if ((","+表格数据[j][1]+",").indexOf(","+元素[i]+",")>=0){

                     元素次数[i]++;

                   }

                }

             String s="";

             for (int i=0;i<元素.length;i++)   //按元素出现次数从大到小排序

                for (int j=0;j<元素.length-i-1;j++){

                   if (元素次数[j]<元素次数[j+1]){

                     s=元素[j];

                     k=元素次数[j];

                     元素[j]=元素[j+1];

                     元素次数[j]=元素次数[j+1];

                     元素[j+1]=s;

                     元素次数[j+1]=k;

                   }

                }

           最小支持度=Float.parseFloat(fa0.getText())*元素数;

            频繁集="1项集："; 

            int 元素个数0=0;

           for (int i=0;i<元素.length;i++) {  //保存一项集

                元素2[i]=元素[i];

                if (((元素次数[i]+0.0)/记录条数)>=最小支持度){

                频繁集=频繁集+"{"+元素[i]+":"+元素次数[i]+"}";

                元素个数0++;

                }

           }

             int []序号=new int[1];

             for (int i=0;i<记录条数;i++){   //将元素名变为序号

                s10=表格数据[i][1].toString().split(",");//求元素

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

                序号=new int[s10.length];

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

                   s=s10[j];

                   for (int i1=0;i1<元素.length;i1++){

                      if (s.equals(元素[i1])){

                        序号[j]=i1;

                      }

                   }

                 }

                 Arrays.sort(序号);//从低到高排序

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

                   if (j<s10.length-1) 表格数据[i][2]=表格数据[i][2]+元素[序号[j]]+",";

                   else 表格数据[i][2]=表格数据[i][2]+元素[序号[j]];

                 }

             }

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

                表格数据[i][1]=表格数据[i][2];

             }

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

                table = new JTable(model);   //重新显示表格数据

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

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

                  if (i==0) tc.setPreferredWidth(50);

                  else tc.setPreferredWidth(760);

               }

                scrollPane.setViewportView(table);

                String [] 元素0=new String[元素个数0];

                for (int i=0;i<元素个数0;i++)

                 元素0[i]=元素[i];

                p1(2,元素个数0,元素0);  //以下从2项集开始计算

                jta1.setText(" 频繁集="+频繁集);

            }

        });

       Button1.setBounds(330,窗口高-70,120, 20);

       frame1.add(Button1);   

       final JButton Button3 = new JButton("退出");

       Button3.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

             frame1.setVisible(false);

             frame1.dispose();

            }

        });

       Button3.setBounds(570,窗口高-70,120, 20);

       frame1.add(Button3);   

      frame1.setVisible(true);

    }

 

static void p1(int 项集数0,int 元素数0,String [] 元素5) {

   if (元素数0==0) {

     if (项集数0==2) 结束标志1=1;

     return;

   }

     set1.clear();      //考虑到比元素0中较小的元素大的元素应当已经被组合过了

     int [] 次数=new int[元素2.length*元素2.length*元素2.length];

     String 频繁集01=项集数0+"频繁集";

     String 元素01[]=new String[元素2.length*元素2.length*元素2.length];

     int k1=0,k2=0,k3=0;

     String sp[]=null;

     String sp6[]=null;

    String sp1="",sp2="";

     char x1=10,x2=13;

     for (int i=0;i<元素数0;i++){      //在所有元素2中找小于元素0的最后一个元素的元素进行组合

       if (元素5[i].indexOf(",")>=0){

          sp=元素5[i].split(",");

          sp1=sp[sp.length-1];

       }

       else sp1=元素5[i];

a01:         for (int j=0;j<元素2.length;j++){

           if (元素2[j].compareTo(sp1)<0){  //找小于元素0的最后一个元素的元素组合并分析最小支持度

             sp2=元素5[i]+","+元素2[j];    //新组合

             k3=set1.size();

             set1.add(sp2);

             if (set1.size()==k3) continue a01;    //如果新组合重复，退出

                            次数[k1]=0;

           for (int i3=0;i3<记录条数;i3++){   //组合后的新集合在原来记录中出现的次数

             k3=0;

             sp6=sp2.split(",");

             for (int i4=0;i4<sp6.length;i4++)

             if ((","+表格数据[i3][1]+",").indexOf(sp6[i4])<0)  k3=1;

             if (k3==0)    次数[k1]++;

           }

           if ((次数[k1]+0.0)/记录条数>最小支持度) {  //检查支持度，看是否是频繁集

             元素01[k1]=sp2;

             k1++;   //是频繁集，承认元素01[k1]是新项集数0中的一个频繁集

           }

          }  

       } 

       }

     k2=0;

     for (int i4=0;i4<k1;i4++) {  //保存一项集

      频繁集01=频繁集01+"{"+元素01[i4]+":"+次数[i4]+"}";

      k2++;

    }

       频繁集=频繁集+x1+x2+频繁集01;

      p1(项集数0+1,k2,元素01);

     }

static void p2(int 项集数0,int 元素数0,String [] 元素0) {

   int n=0;

   for (int i=1;i<元素数0;i++)

     n=n+i;

   元素1=new String[n];

   int k=0;

   for (int i=0;i<元素数0-1;i++)

   for (int j=i+1;j<元素数0;j++){

     元素1[k]=元素0[i]+","+元素0[j];

     sk=元素1[k].split(",");

     set1.removeAll(set1);

     int [] 序号=new int[项集数0];

     for (int j1=0;j1<sk.length;j1++)

        set1.add(sk[j1]);

     if (set1.size()==项集数0) {

         sk=set1.toArray(new String[0]);   //从set1重新生成数组

         for (int j6=0;j6<sk.length;j6++){  //取每一个元素

          for (int i7=0;i7<元素个数;i7++){ //确定在新元素列表中的序号

                if (sk[j6].equals(元素2[i7])){

                   序号[j6]=i7;

                }

              }

             }

             Arrays.sort(序号);//从低到高排序

             元素1[k]="";

             for (int j7=0;j7<sk.length;j7++){   //重新得到元素1数组

              if (j7<sk.length-1) 元素1[k]=元素1[k]+元素2[序号[j7]]+","; 

              else 元素1[k]=元素1[k]+元素2[序号[j7]];

             }

        k++; 

     }

   }

   set1.removeAll(set1);

   for (int j1=0;j1<k;j1++){

        set1.add(元素1[j1]);

   }

        元素1=set1.toArray(new String[0]);   //从set1重新生成数组

   k=元素1.length;

for (int j1=0;j1<k;j1++)

    项集数=项集数0;元素数=k;元素数1=0;

       元素数1=0;

       k=0;

       if (元素数>0)

      频繁集=频繁集+项集数0+"项集：";

       else

         结束标志=1;

      元素次数=new int[元素数];

      int 标志=0;

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

         元素数1=0;

         sk=元素1[j].split(",");

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

               标志=0; 

             for (int j1=0;j1<sk.length;j1++){

                   if ((","+表格数据[i1][1].toString()+",").indexOf(","+sk[j1]+",")<0){

                         标志=1;

                  break;

                   }

             }

                if (标志==0)

                元素数1++;  

         }

       if ((元素数1+0.0)/记录条数>=最小支持度){ 

         if (结束标志==0) 频繁集=频繁集+"{"+元素1[j]+":"+元素数1+"}";

         元素次数[j]=元素数1;

         k++;

       }

       else {

          元素1[j]="";

       }

     }

      if (结束标志==0) 频繁集=频繁集+x1;

          String [] s3=new String[元素数];

          int 新元素数=0;

       for (int i2=0;i2<元素数;i2++)

         if (元素1[i2].length()>0){

            s3[新元素数]=元素1[i2];

           新元素数++;

       }

       元素1=new String[新元素数];

       for (int i2=0;i2<新元素数;i2++){

            元素1[i2]=s3[i2];

       }

       if (项集数0<元素个数)

         p2(项集数0+1,新元素数,元素1);

       }

 

static void 数据表查询数据(String 数据表名) {

   int c = 0;

   int b = 0;

   String s1="";

   try {

     cont4 = main1.getConn();

     stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

           ResultSet.CONCUR_UPDATABLE);

     s1 = "select " + 字段名表 + "  from " + 数据表名 + 连接条件;

     rs = stat4.executeQuery(s1);

     rsmdt4 = rs.getMetaData();

     列数 = rsmdt4.getColumnCount();

     列名 = new String[列数];

     列数据类型 = new String[列数];

     列数据宽度 = new int[列数];

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

        列名[i1] = rsmdt4.getColumnName(i1 + 1);

        列数据类型[i1] = rsmdt4.getColumnTypeName(i1 + 1);

        列数据宽度[i1] = rsmdt4.getColumnDisplaySize(i1 + 1);

     }

     rs.last();

     记录条数 = rs.getRow();

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

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

     while (c < 记录条数) {

        rs.absolute(c + 1);

        while (b < 列数) {

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

           if ((main1.数字数据类型.lastIndexOf("," + 列数据类型[b] + ",")) > 0)

             if ((表格数据0[c][b] == null)

                   || (表格数据0[c][b].trim().length() == 0))

                表格数据0[c][b] = "0";

             else if (表格数据0[c][b] == null)

                表格数据0[c][b] = "";

           表格数据[c][b] = 表格数据0[c][b];

           b++;

        }

        c++;

        b = 0;

     }

     rs.close();

     stat4.close();

     cont4.close();

   } catch (SQLException e1) {

     JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

   }

    }

      }

106.源码106，实验程序，仅供参考。读取某一个字段中的数据进行FP树关联分析，绘制FP树图样。

/*

 * 程序文件名：dataMining3.java

 * 作者：程学先

 * 功能：实验程序，读取某一个字段中的数据进行FP树关联分析，绘制FP树图样。

 * 其中每列可有多个数据，各数据间用逗号分隔。

 * 例如：某字段数据:

 * A,B

 * B,C,D

 * A,C,D,E

 * A,D,E

 * A,B,C

 * A,B,C,D

 * A

 * A,B,C

 * A,B,D

 * B,C,E

 * 可以单步执行，每一步后显示当前FP树图样，也可以一次执行画出最终FP树图样。

 */

 

import java.awt.BasicStroke;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Insets;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.Arrays;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableColumn;

import javax.swing.table.TableModel;

 

class 存储结构FP

{

   int 序号;

   String 元素名;

   int 层次号;

   int 列号;

   int 上级序号;

   int 次数;

   String 上级节点名;

   String 下级节点名;

   public 存储结构FP(int 序号,String 元素名,int 层次号,int 列号,int 上级序号,int 次数,String 上级节点名,String 下级节点名)

   {

     this.序号=序号;

     this.元素名=元素名;

     this.层次号=层次号;

     this.列号=列号;

     this.上级序号=上级序号;

     this.次数=次数;

     this.上级节点名=上级节点名;

     this.下级节点名=下级节点名;

}

}

 

public class dataMining3 extends JFrame {

   static dataMining3 frame1=new dataMining3();

    static int 当前记录号;

    static Graphics g;

    static Graphics2D  g2;

    static Insets inset;

   private static JTable table;  

   static String 表名;   

   static int 窗口宽=1400,窗口高=600;

    static int 左边=100,到顶=窗口高;

    static int [][][] 位置参数;

    static int 序号0=0;

   static String [] 第i层元素号集; 

   static Object[][] 表格数据;

   static String sk[];

    static JTextField fb1;

    static JTextArea fa0;

    static TableModel model;

    static JScrollPane scrollPane;

    static ArrayList<存储结构FP> 存储数据=new ArrayList<存储结构FP>();

    static int 最大层数=0;

    static int 开始运行=0;

   private static Connection cont4;

   private static Statement stat4;

   private static ResultSetMetaData rsmdt4;

   private static ResultSet rs;

   static String [] 列名;

    static int 记录条数,列数,当前列号;

    static String [] 列数据类型;

   private static int[] 列数据宽度;

   private static String[][] 表格数据0;

   private static String 连接条件 = "";

   private static String 字段名表 = "";

 

    public static void 显示数据表格1() {

        列数据宽度=new int[2];

        列数据宽度[0]=20;

        列数据宽度[1]=330;

        scrollPane = new JScrollPane();

        scrollPane.setBounds(10,40,300,430); 

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

        table = new JTable(model);

        table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

        table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

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

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

            tc.setPreferredWidth(列数据宽度[i]);  //设置表格中各列的宽度

            tc.setMaxWidth(260);

            tc.sizeWidthToFit();

            }

        scrollPane.setViewportView(table);

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

        inset = frame1.getInsets();

        }

    

static void means(String parameter[]) {

         frame1=new dataMining3();

       frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

      frame1.setTitle("FP树关联分析                           作者：程学先");

      frame1.setBounds(1000,10,350,窗口高+70);

        frame1.setLayout(null);

        JLabel fb0=new JLabel("纯文本文件名");

        frame1.add(fb0); 

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

     String 字段名字串 = parameter[19];

     String 项目数据 = parameter[8]; // X坐标号，限一个字段号

     if (项目数据.indexOf(",")>0)

        项目数据=项目数据.substring(0,项目数据.indexOf(","));

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

          连接条件=" where "+parameter[20];

     else 连接条件="";

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

     String [] s2=项目数据.split(",");

     字段名表="' '"+" as 标志";

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

        字段名表=字段名表+","+s1[Integer.parseInt(s2[i])];

           数据表查询数据(表名);

            String [] sl1,sl2,sl3;

            int [] sl4;

        sl1=new String[记录条数];

        sl2=new String[记录条数];

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

           sl1[i]=表格数据[i][1].toString();

        sl4=new int[200];

        int sl5=0;   //最多元素数

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

           sl2[i]=sl1[i];

           sl3=sl2[i].split(",");    //得到每条记录元素数组

           if (sl5<sl3.length)  sl5=sl3.length;   //得到最长元素数组

           for (int j=0;j<sl3.length-1;j++){   //找到没个分解后元素位最长的长度

             if (sl4[j]<sl3[j].length()) sl4[j]=sl3[j].length();

           }

        }

        for (int i=0;i<记录条数;i++){   //以下补齐长度

           sl2[i]=sl1[i];

           sl3=sl2[i].split(",");    //得到每条记录元素数组

           for (int j=0;j<sl3.length;j++){   //找到没个分解后元素位最长的长度

             for (int k=sl3[j].length();k<sl4[j];k++)

                sl3[j]=sl3[j]+" ";

           }

           Arrays.sort(sl3);

           sl2[i]="";

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

             if (sl2[i].length()==0) sl2[i]=sl3[j];

             else sl2[i]=sl2[i]+","+sl3[j];

           }

        }

        Arrays.sort(sl2);

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

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

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

           表格数据[i][1]=sl2[i];

        }

        表格数据[0][0]="→";

        当前记录号=0;

          存储数据.clear();

          序号0=0;

          存储数据.add(new 存储结构FP(序号0,"NULL",0,0,0,0,"",""));

          序号0++;

          显示数据表格1();

          位置参数=new int [20][15][2];

        最大层数=0;

        开始运行=0;

         int y1=100;   //中心点左边距

         位置参数[0][0][0]=20;   //根到顶距

         第i层元素号集=new String[20];

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

           位置参数[i][0][1]=10+(20-i)*(y1/20);   //第i层最左节点左边距

           第i层元素号集[i]="";

         }

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

           位置参数[i][0][0]=50*(i+1);    //第i层到顶距 

           for (int j=1;j<15;j++){

             位置参数[i][j][0]=50*(i+1);    //第i层到顶距 

             位置参数[i][j][1]=位置参数[i][j-1][1]+60+i*10;   //第i层第j元素左边距 

           }

         }

        fb1 = new JTextField("",20);

        frame1.add(fb1);     

        fb0.setBounds(10,10,80, 20);

        fb1.setBounds(90,10,180, 20);

        fb1.addMouseListener(new MouseAdapter() { 

           public void mouseClicked(MouseEvent e) {

                    String [] sl1,sl2,sl3;

                   int [] sl4;

               sl1=new String[记录条数];

               sl2=new String[记录条数];

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

                 sl1[i]=表格数据[i][1].toString();

               sl4=new int[200];

               int sl5=0;   //最多元素数

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

                 sl2[i]=sl1[i];

                 sl3=sl2[i].split(",");    //得到每条记录元素数组

                 if (sl5<sl3.length)  sl5=sl3.length;   //得到最长元素数组

                 for (int j=0;j<sl3.length-1;j++){   //找到每个分解后元素位最长的长度

                    if (sl4[j]<sl3[j].length()) sl4[j]=sl3[j].length();

                 }

               }

               for (int i=0;i<记录条数;i++){   //以下补齐长度

                 sl2[i]=sl1[i];

                 sl3=sl2[i].split(",");    //得到每条记录元素数组

                 for (int j=0;j<sl3.length;j++){   //找到没个分解后元素位最长的长度

                    for (int k=sl3[j].length();k<sl4[j];k++)

                       sl3[j]=sl3[j]+" ";

                 }

                 Arrays.sort(sl3);

                 sl2[i]="";

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

                    if (sl2[i].length()==0) sl2[i]=sl3[j];

                    else sl2[i]=sl2[i]+","+sl3[j];

                 }

               }

               Arrays.sort(sl2);

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

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

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

                 表格数据[i][1]=sl2[i];

               }

               表格数据[0][0]="→";

               当前记录号=0;

             存储数据.clear();

             序号0=0;

             存储数据.add(new 存储结构FP(序号0,"NULL",0,0,0,0,"",""));

            序号0++;

             显示数据表格1();

           }

       });

       final JButton Button0 = new JButton("单步显示");

       Button0.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

             String []sk1=null,sk2=null;

             String sk3;

             int sk4,sk5,sk6;

             int 新列号=0;

             if (当前记录号==记录条数) return;

             sk=model.getValueAt(当前记录号,1).toString().split(",");   //取每一个子元素

                   model.setValueAt(" ", 当前记录号, 0);//当前记录 左边箭头删除

                  当前记录号++;   //准备下一步单步

                 if (当前记录号<记录条数)

                 model.setValueAt("→", 当前记录号, 0);//下一记录 左边加箭头

                 else

                     model.setValueAt("", 当前记录号-1, 0);//下一记录 左边加箭头

                 int 当前父节点号=0;//从根开始

                  for (int i=0;i<sk.length;i++){   //对一条记录分析一个元素

                     if (最大层数<i+1) 最大层数=i+1;

                  if ((","+存储数据.get(当前父节点号).下级节点名).indexOf(","+sk[i]+"。")>=0){  //下级节点有同名的

                       sk1=存储数据.get(当前父节点号).下级节点名.split(sk[i]+"。");

                       if (sk1[1].indexOf(",")>=0)

                          sk4=Integer.parseInt(sk1[1].substring(0,sk1[1].indexOf(",")));

                       else sk4=Integer.parseInt(sk1[1]);

                       存储数据.get(sk4).次数++;

                       当前父节点号=sk4;

                     }

                     else if (存储数据.get(当前父节点号).下级节点名.length()==0){  //下级无节点

                    新列号=0;      //无下级节点

                       sk5=存储数据.get(当前父节点号).列号;  //最后一个序号的列号

                       sk6=存储数据.get(当前父节点号).序号;  //最后一个序号的列号

                        新列号=sk5+1;

                      sk3=存储数据.get(当前父节点号).元素名;

                    if (第i层元素号集[i+1].length()>0)

                    第i层元素号集[i+1]=第i层元素号集[i+1]+","+序号0;   //修改第i层元素号集,插入新节点号

                    else 第i层元素号集[i+1]=序号0+"";

                       存储数据.add(new 存储结构FP(序号0,sk[i],i+1,新列号,sk6,1,sk3,""));

                       if (存储数据.get(当前父节点号).下级节点名.length()==0)

                          存储数据.get(当前父节点号).下级节点名=sk[i]+"。"+序号0;

                       else 存储数据.get(当前父节点号).下级节点名=存储数据.get(当前父节点号).下级节点名+","+sk[i]+"。"+序号0;

                       当前父节点号=序号0;  //记录当前父节点序号

                       序号0++;

                     }

                     else { //下级有节点但无同名的

                       sk3=存储数据.get(当前父节点号).元素名;  //为新节点定义准备上级节点元素名

                       sk4=当前父节点号;   //为新节点定义准备上级节点元素序号号

                       sk5=存储数据.get(当前父节点号).列号;

                       sk6=存储数据.get(当前父节点号).序号;

                       sk1=存储数据.get(当前父节点号).下级节点名.split(",");

                       sk2=sk1[sk1.length-1].split("。");   //找子节点中最后一个序号

                       新列号=存储数据.get(Integer.parseInt(sk2[1])).列号;  //最后一个序号的列号

                       sk1=(第i层元素号集[i+1]+",k").split(sk2[1]+",");//i+1为当前层次号,确保将该层序号分为二部分

                     第i层元素号集[i+1]=sk1[0]+sk2[1]+","+序号0+","+sk1[1];   //修改第i层元素号集,插入新节点号

                     sk2=第i层元素号集[i+1].split(",k"); 

                     第i层元素号集[i+1]=sk2[0];

                       sk2=sk1[1].split(",");

                       for (int k=0;k<sk2.length-1;k++){//修改第i层元素号集后面那些序号的列号加1，为新节点腾地方

                          存储数据.get(Integer.parseInt(sk2[k])).列号=存储数据.get(Integer.parseInt(sk2[k])).列号+1;

                          }

                       if (存储数据.get(当前父节点号).下级节点名.length()==0)

                       存储数据.get(当前父节点号).下级节点名=sk[i]+"。"+序号0; 

                       else

                           存储数据.get(当前父节点号).下级节点名=存储数据.get(当前父节点号).下级节点名+","+sk[i]+"。"+序号0;

                       存储数据.add(new 存储结构FP(序号0,sk[i],i+1,新列号,sk6,1,sk3,""));

                       当前父节点号=序号0; //记录当前父节点序号

                       序号0++;

                     }

                  } 

                  for (int i=1;i<=最大层数;i++){

                     sk1=第i层元素号集[i].split(",");

                     int j1=-1,j2=0;

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

                       j1++;

                          j2=存储数据.get(Integer.parseInt(sk1[j])).上级序号;

                    if (j1<存储数据.get(j2).列号)

                          j1=存储数据.get(j2).列号;

                       存储数据.get(Integer.parseInt(sk1[j])).列号=j1;

                  }

                  }

             开始运行=5;

             grap1.grap11();

            }

        });

       Button0.setBounds(10,窗口高-110,300, 20);

       frame1.add(Button0);   

       final JButton Button1 = new JButton("显示完整FP树");

       Button1.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

             String []sk1=null,sk2=null;

             String sk3;

             int sk4,sk5,sk6;

             int 新列号=0;

             int i0=当前记录号;

             for (当前记录号=i0;当前记录号<记录条数;当前记录号++) {

             sk=model.getValueAt(当前记录号,1).toString().split(",");   //取每一个子元素

                   model.setValueAt(" ", 当前记录号, 0);//当前记录 左边箭头删除

                 if (当前记录号<记录条数)

                 model.setValueAt("→", 当前记录号, 0);//下一记录 左边加箭头

                 else

                     model.setValueAt("", 当前记录号-1, 0);//下一记录 左边加箭头

                 int 当前父节点号=0;//从根开始

                  for (int i=0;i<sk.length;i++){   //对一条记录分析一个元素

                     if (最大层数<i+1) 最大层数=i+1;

                  if ((","+存储数据.get(当前父节点号).下级节点名).indexOf(","+sk[i]+"。")>=0){  //下级节点有同名的

                       sk1=存储数据.get(当前父节点号).下级节点名.split(sk[i]+"。");

                       if (sk1[1].indexOf(",")>=0)

                          sk4=Integer.parseInt(sk1[1].substring(0,sk1[1].indexOf(",")));

                       else sk4=Integer.parseInt(sk1[1]);

                       存储数据.get(sk4).次数++;

                       当前父节点号=sk4;

                     }

                     else if (存储数据.get(当前父节点号).下级节点名.length()==0){  //下级无节点

                    新列号=0;      //无下级节点

                       sk5=存储数据.get(当前父节点号).列号;  //最后一个序号的列号

                       sk6=存储数据.get(当前父节点号).序号;  //最后一个序号的列号

                    新列号=sk5+1;

                      sk3=存储数据.get(当前父节点号).元素名;

                    if (第i层元素号集[i+1].length()>0)

                    第i层元素号集[i+1]=第i层元素号集[i+1]+","+序号0;   //修改第i层元素号集,插入新节点号

                    else 第i层元素号集[i+1]=序号0+"";

                       存储数据.add(new 存储结构FP(序号0,sk[i],i+1,新列号,sk6,1,sk3,""));

                       if (存储数据.get(当前父节点号).下级节点名.length()==0)

                          存储数据.get(当前父节点号).下级节点名=sk[i]+"。"+序号0;

                       else 存储数据.get(当前父节点号).下级节点名=存储数据.get(当前父节点号).下级节点名+","+sk[i]+"。"+序号0;

                       当前父节点号=序号0; //记录当前父节点序号

                       序号0++;

                     }

                     else { //下级有节点但无同名的

                       sk3=存储数据.get(当前父节点号).元素名;  //为新节点定义准备上级节点元素名

                       sk4=当前父节点号;   //为新节点定义准备上级节点元素序号号

                       sk5=存储数据.get(当前父节点号).列号;

                       sk6=存储数据.get(当前父节点号).序号;

                       sk1=存储数据.get(当前父节点号).下级节点名.split(",");

                       sk2=sk1[sk1.length-1].split("。");   //找子节点中最后一个序号

                       新列号=存储数据.get(Integer.parseInt(sk2[1])).列号;  //最后一个序号的列号

                       sk1=(第i层元素号集[i+1]+",k").split(sk2[1]+",");//i+1为当前层次号,确保将该层序号分为二部分

                     第i层元素号集[i+1]=sk1[0]+sk2[1]+","+序号0+","+sk1[1];   //修改第i层元素号集,插入新节点号

                     sk2=第i层元素号集[i+1].split(",k");

                     第i层元素号集[i+1]=sk2[0];

                       sk2=sk1[1].split(",");

                       for (int k=0;k<sk2.length-1;k++){//修改第i层元素号集后面那些序号的列号加1，为新节点腾地方

                          存储数据.get(Integer.parseInt(sk2[k])).列号=存储数据.get(Integer.parseInt(sk2[k])).列号+1;

                          }

                       if (存储数据.get(当前父节点号).下级节点名.length()==0)

                       存储数据.get(当前父节点号).下级节点名=sk[i]+"。"+序号0;

                       else

                           存储数据.get(当前父节点号).下级节点名=存储数据.get(当前父节点号).下级节点名+","+sk[i]+"。"+序号0;

                       存储数据.add(new 存储结构FP(序号0,sk[i],i+1,新列号,sk6,1,sk3,""));

                       当前父节点号=序号0;//记录当前父节点序号

                       序号0++;

                     }

                  }

                  for (int i=1;i<=最大层数;i++){

                     sk1=第i层元素号集[i].split(",");

                     int j1=-1,j2=0;

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

                       j1++;

                          j2=存储数据.get(Integer.parseInt(sk1[j])).上级序号;

                    if (j1<存储数据.get(j2).列号)

                          j1=存储数据.get(j2).列号;

                       存储数据.get(Integer.parseInt(sk1[j])).列号=j1;

                  }

                  }

             }

             开始运行=5;

             grap1.grap11();     //刷新屏幕

            }

        });

       Button1.setBounds(10,窗口高-70,300, 20);

       frame1.add(Button1);   

 

       final JButton Button2 = new JButton("退出");

       Button2.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

             frame1.setVisible(false);

             frame1.dispose();

             grap1.frame2.setVisible(false);

             grap1.frame2.dispose();

             System.exit(0);

            }

        });

       Button2.setBounds(10,窗口高-30,300, 20);

       frame1.add(Button2);   

      frame1.setVisible(true);

       grap1.frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

      grap1.frame2.setBounds(10,30,980,650);

      grap1.frame2.setVisible(true);

       } 

   static void 数据表查询数据(String 数据表名) {

   int c = 0;

   int b = 0;

   String s1="";

   try {

     cont4 = main1.getConn();

     stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

           ResultSet.CONCUR_UPDATABLE);

     s1 = "select " + 字段名表 + "  from " + 数据表名 + 连接条件;

     rs = stat4.executeQuery(s1);

     rsmdt4 = rs.getMetaData();

     列数 = rsmdt4.getColumnCount();

     列名 = new String[列数];

     列数据类型 = new String[列数];

     列数据宽度 = new int[列数];

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

        列名[i1] = rsmdt4.getColumnName(i1 + 1);

        列数据类型[i1] = rsmdt4.getColumnTypeName(i1 + 1);

        列数据宽度[i1] = rsmdt4.getColumnDisplaySize(i1 + 1);

     }

     rs.last();

     记录条数 = rs.getRow();

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

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

     while (c < 记录条数) {

        rs.absolute(c + 1);

        while (b < 列数) {

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

           if ((main1.数字数据类型.lastIndexOf("," + 列数据类型[b] + ",")) > 0)

             if ((表格数据0[c][b] == null)

                   || (表格数据0[c][b].trim().length() == 0))

                表格数据0[c][b] = "0";

             else if (表格数据0[c][b] == null)

                表格数据0[c][b] = "";

           表格数据[c][b] = 表格数据0[c][b];

           b++;

        }

        c++;

        b = 0;

     }

     rs.close();

     stat4.close();

     cont4.close();

   } catch (SQLException e1) {

     JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

   }

    }

    }

class grap1  extends JFrame {

   static grap1 frame2=new grap1();

    static Graphics g;

    static void  grap11() {

      frame2.repaint();

   }

    public void paint(Graphics g1) {

        g=g1;

    if (dataMining3.开始运行==0){

           g1.setColor(Color.WHITE);// 将画笔颜色设置成白色

           g1.fillRect(0, 0, getWidth(), getHeight()); //清空画面

           g1.setColor(Color.black);// 将画笔颜色设置成黑色

           dataMining3.开始运行=1;

    }

    else if (dataMining3.开始运行==5){

           Graphics2D g2=(Graphics2D)g;

         g2.setStroke(new BasicStroke(2f));

           g1.setColor(Color.WHITE);// 将画笔颜色设置成白色

           g1.fillRect(0, 0, getWidth(), getHeight()); //清空画面

           h();

            dataMining3.开始运行=1;

    }

    }

    public static void h(){

           Graphics2D g2=(Graphics2D)g;

           g2.setStroke(new BasicStroke(2f));

           g.setColor(Color.BLACK);// 将画笔颜色设置成黑色

           int w1,w2,w3,w4,w5,w01,w02,w03,w04;

           String st1,st2,st3;

           String [] sr1,sr2;

          for (int i=0;i<dataMining3.存储数据.size();i++){

            w1=dataMining3.存储数据.get(i).层次号;

            w2=dataMining3.存储数据.get(i).列号;

            w01=dataMining3.位置参数[w1][w2][1];    //左边距

            w02=dataMining3.位置参数[w1][w2][0];    //到顶距

            w3=dataMining3.存储数据.get(i).次数;

            st1=dataMining3.存储数据.get(i).元素名;

            st2=dataMining3.存储数据.get(i).下级节点名;

             g.drawArc(w01,w02,20,20,0,360);    //画圆圈

            g.drawString(st1,w01-(st1.length()*15),w02+10);    //画元素名

             g.drawString(w3+"",w01-((w3+"").length()*15),w02+25);    //画次数

          }

          for (int i=0;i<dataMining3.存储数据.size();i++){

            w1=dataMining3.存储数据.get(i).层次号;

            w2=dataMining3.存储数据.get(i).列号;

            w01=dataMining3.位置参数[w1][w2][1];    //左边距

            w02=dataMining3.位置参数[w1][w2][0];    //到顶距

            st1=dataMining3.存储数据.get(i).元素名;

               st2=dataMining3.存储数据.get(i).下级节点名;

               sr1=st2.split(",");

               for (int k=0;k<sr1.length;k++){

                  if (sr1[k].indexOf("。")>0){

                  sr2=sr1[k].split("。");

                  w4=dataMining3.存储数据.get(Integer.parseInt(sr2[1])).层次号;

                  w5=dataMining3.存储数据.get(Integer.parseInt(sr2[1])).列号;

                  w03=dataMining3.位置参数[w4][w5][1];    //左边距

                      w04=dataMining3.位置参数[w4][w5][0];    //到顶距

                       g.drawLine(w01+10,w02+10,w03+10,w04+10);//画线

                       }

               }

              

             }

            }

     }

版本2

104.源码104，实验程序，仅供参考。读取数据表中的二个数字类型数据字段数据应用公式法寻求拟合最好的函数。本程序尝试用一元一次函数：y=a+bx、 一元多项式函数：y=a1+a2x+a3x2+……、指数函数：y=a+bex、正弦函数：y=a+bsin(x)等对一组实验数据进行尝试性拟合，找出一个函数式使按式计算值域测试数据的拟合误差最小。

/*

 * 程序文件名：dataMining1.java

 * 作者：程学先

 * 功能：实验程序，读取数据表中的二个数字类型数据字段数据应用公式法寻求拟合最好的函数。

 * 本程序尝试用一元一次函数：y=a+bx、 一元多项式函数：y=a1+a2x+a3x2+……、

 * 指数函数：y=a+bex、正弦函数：y=a+bsin(x)

 * 等对一组实验数据进行尝试性拟合，找出一个函数式使按式计算值域测试数据的拟合误差最小。

  */

 

import java.awt.BasicStroke;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Insets;

import java.awt.List;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableColumn;

import javax.swing.table.TableModel;

 

public class dataMining1 extends JFrame {

   private static final long serialVersionUID = 3672837897457785750L;

   static dataMining1 frame1 = new dataMining1();

   static double[] variabl1841;

   static double[] variabl1661;

   static double variabl3647 = 0, variabl1519 = 0;

   static double variabl3685 = 0, variabl1305 = 0;

   static int variabl1727 = 1340, variabl1783 = 700;

   static String variabl16751 = "";

   static Graphics g;

   static Graphics2D g2;

   static Insets inset;

   static int variabl2661 = 100, variabl2657 = variabl1783;

   private static JTable table;

   static String variabl2603;

   static int variabl2483 = 1400;

   static String[][] variabl26151;

   static int variabl19631, variabl19632;

   static Object[][] variabl2197;

   static List list1 = new List();

   static JTextField fa0, fa1, fa2, fa3, fb1, ja10, ja15, ja16, ja17, ja18,

        ja19;

   static JLabel fl5, fl6, fl7, fl8, fl9, fl10;

   static JButton Button0;

   static JTextArea jta1;

   private static Connection cont4;

   private static Statement stat4;

   private static ResultSetMetaData rsmdt4;

   private static ResultSet rs;

   static String[] variabl2517;

   static int variabl1853, variabl2651, variabl1739;

   static String[] variabl1501;

   private static int[] variabl1489;

   private static String[][] variabl21970;

   private static String variabl2049 = "";

   private static String variabl1633 = "";

 

   public static void variabl1253() {

     JScrollPane scrollPane = new JScrollPane();

     scrollPane.setBounds(10, 10, variabl2483 - 60, variabl1783 - 100);

     TableModel model = new DefaultTableModel(variabl2197, variabl2517);

     table = new JTable(model);

     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

      table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

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

        TableColumn tc = table.getColumn(variabl2517[i]);

        tc.setPreferredWidth(100);

        tc.setMaxWidth(100);

        tc.sizeWidthToFit();

     }

     scrollPane.setViewportView(table);

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

     inset = frame1.getInsets();

     return;

   }

 

   public static void variabl12531() {

     variabl1489[0] = variabl1489[0] + 6;

     variabl1489[1] = variabl1489[1] + 6;

     JScrollPane scrollPane = new JScrollPane();

     scrollPane.setBounds(10, 10, variabl2483 - 60, variabl1783 - 100);

     TableModel model = new DefaultTableModel(variabl2197, variabl2517);

     table = new JTable(model);

     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

      table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

     for (int i1 = 0; i1 < variabl2651; i1++) {

        TableColumn tc = table.getColumn(variabl2517[i1]);

        tc.setPreferredWidth(20);

        tc.setMaxWidth(20);

        tc.sizeWidthToFit();

     }

     scrollPane.setViewportView(table);

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

     inset = frame1.getInsets();

   }

 

   static void means(String parameter[]) {

     frame1 = new dataMining1();

      frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

     frame1.setTitle(" 公式法数据分析               作者：程学先       ");

     frame1.setBounds(10, 10, variabl1727, variabl1783 + 50);

     frame1.setLayout(null);

     variabl2603 = parameter[4];

     String variabl1325 = parameter[19];

     String variabl2489 = parameter[8];

     if (variabl2489.indexOf(",") > 0)

        variabl2489 = variabl2489.substring(0, variabl2489.indexOf(","));

     String variabl2473 = parameter[9];

     if (variabl2473.indexOf(",") > 0)

        variabl2473 = variabl2473.substring(0, variabl2473.indexOf(","));

     if (variabl2603.indexOf(",") > 0)

        variabl2049 = " where " + parameter[20];

     else

        variabl2049 = "";

     String[] s1 = variabl1325.split(",");

     String[] s2 = (variabl2489 + "," + variabl2473).split(",");

     variabl1633 = "";

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

        if (i == 0)

           variabl1633 = s1[Integer.parseInt(s2[i])];

        else

           variabl1633 = variabl1633 + "," + s1[Integer.parseInt(s2[i])];

     variabl2861(variabl2603);

     variabl2866.variabl3647 = 0;

     variabl2866.variabl1519 = 0;

     variabl2866.variabl3685 = 0;

     variabl2866.variabl1305 = 0;

     variabl2866.variabl1415 = 20;

     variabl2866.variabl1395 = 10;

     variabl3647 = 0;

     variabl1519 = 0;

     variabl3685 = 0;

     variabl1305 = 0;

     variabl26151 = new String[variabl1853][variabl2197[0].length];

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

        for (int j = 0; j < variabl2197[0].length; j++) {

           variabl26151[i][j] = variabl2197[i][j].toString();

        }

     if (variabl26151[0].length < 3)

        variabl1253();

     JLabel fl0 = new JLabel("纵向字段名");

     frame1.add(fl0);

     fa0 = new JTextField(variabl2517[0], 20);

     frame1.add(fa0);

     fl0.setBounds(310, variabl1783 - 80, 80, 20);

     fa0.setBounds(390, variabl1783 - 80, 80, 20);

     fa0.addFocusListener(new FocusAdapter() {

        public void focusGained(final FocusEvent arg0) {

           variabl1739 = 0;

        }

     });

 

     JLabel fl2 = new JLabel("横向字段名");

     frame1.add(fl2);

     fa2 = new JTextField(variabl2517[1], 20);

     frame1.add(fa2);

     fl2.setBounds(470, variabl1783 - 80, 80, 20);

     fa2.setBounds(550, variabl1783 - 80, 80, 20);

     fa2.addFocusListener(new FocusAdapter() {

        public void focusGained(final FocusEvent arg0) {

           variabl1739 = 2;

        }

     });

     JLabel fl4 = new JLabel("计算过程");

     fl4.setBounds(1100, variabl1783 - 90, 80, 30);

     frame1.add(fl4);

     jta1 = new JTextArea();

     frame1.add(jta1);

     jta1.setBounds(1000, 40, 310, 560);

     fl5 = new JLabel("x1=");

     frame1.add(fl5);

     ja15 = new JTextField();

     frame1.add(ja15);

     fl5.setBounds(30, variabl1783 - 55, 30, 20);

     ja15.setBounds(60, variabl1783 - 55, 100, 20);

     fl6 = new JLabel("x2=");

     frame1.add(fl6);

     ja16 = new JTextField();

     frame1.add(ja16);

     fl6.setBounds(160, variabl1783 - 55, 30, 20);

     ja16.setBounds(190, variabl1783 - 55, 100, 20);

     fl7 = new JLabel("x3=");

     frame1.add(fl7);

     ja17 = new JTextField();

     frame1.add(ja17);

     fl7.setBounds(290, variabl1783 - 55, 30, 20);

     ja17.setBounds(320, variabl1783 - 55, 100, 20);

     fl8 = new JLabel("x4=");

     frame1.add(fl8);

     ja18 = new JTextField();

     frame1.add(ja18);

     fl8.setBounds(420, variabl1783 - 55, 30, 20);

     ja18.setBounds(450, variabl1783 - 55, 100, 20);

     fl9 = new JLabel("y=");

     frame1.add(fl9);

     ja19 = new JTextField();

     frame1.add(ja19);

     fl9.setBounds(550, variabl1783 - 55, 30, 20);

     ja19.setBounds(580, variabl1783 - 55, 100, 20);

     fl10 = new JLabel("拟合误差");

     frame1.add(fl10);

     ja10 = new JTextField();

     frame1.add(ja10);

     fl10.setBounds(680, variabl1783 - 55, 60, 20);

     ja10.setBounds(740, variabl1783 - 55, 100, 20);

     Button0 = new JButton("预测y值");

     Button0.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           try {

             double z01 = Double.parseDouble(ja15.getText());

             double yyy1 = 0;

             if (variabl2866.variabl2143 == 1) {

                yyy1 = variabl2866.variabl2575[0]

                      + variabl2866.variabl2575[1] * z01;

                ja19.setText((yyy1 + "      ").substring(0, 6));

             } else if (variabl2866.variabl2143 == 5) {

                yyy1 = variabl2866.variabl2575[0]

                      + variabl2866.variabl2575[1] * Math.exp(z01);

                ja19.setText((yyy1 + "      ").substring(0, 6));

             } else if (variabl2866.variabl2143 == 6) {

                yyy1 = variabl2866.variabl2575[0]

                      + variabl2866.variabl2575[1] * Math.sin(z01);

                ja19.setText((yyy1 + "      ").substring(0, 6));

             } else if (variabl2866.variabl2143 == 10) {

                z01 = Double.parseDouble(ja15.getText());

                yyy1 = variabl2866.variabl2575[0]

                      + variabl2866.variabl2575[1] * z01;

                if ((variabl2866.variabl2575[2] != 0)

                      && (ja16.getText() != null)) {

                   double z02 = Double.parseDouble(ja16.getText());

                   yyy1 = yyy1 + variabl2866.variabl2575[2] * z02;

                }

                if ((variabl2866.variabl2575[3] != 0)

                      && (ja17.getText() != null)) {

                   double z03 = Double.parseDouble(ja16.getText());

                   yyy1 = yyy1 + variabl2866.variabl2575[3] * z03;

                }

                if ((variabl2866.variabl2575[4] != 0)

                      && (ja18.getText() != null)) {

                   double z04 = Double.parseDouble(ja16.getText());

                   yyy1 = yyy1 + variabl2866.variabl2575[4] * z04;

                }

                ja19.setText((yyy1 + "      ").substring(0, 6));

             } else {

                yyy1 = 0;

                z01 = Double.parseDouble(ja15.getText());

                yyy1 = variabl2866.variabl2575[0]

                      + variabl2866.variabl2575[1] * z01

                      + variabl2866.variabl2575[2] * z01 * z01;

                ja19.setText((yyy1 + "      ").substring(0, 6));

             }

           } catch (Exception e2) {

           }

        }

     });

     Button0.setBounds(850, variabl1783 - 55, 120, 20);

     frame1.add(Button0);

     Button0.setVisible(false);

     fl5.setVisible(false);

     fl6.setVisible(false);

     fl7.setVisible(false);

     fl8.setVisible(false);

     fl9.setVisible(false);

     fl10.setVisible(false);

     ja15.setVisible(false);

     ja16.setVisible(false);

     ja17.setVisible(false);

     ja18.setVisible(false);

     ja19.setVisible(false);

     ja10.setVisible(false);

 

     final JButton Button1 = new JButton("计算并显示图表");

     Button1.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           if (variabl26151[0].length > 2) {

             variabl2866.variabl2143 = 10;

             variabl2866.variabl2019(variabl26151);

           } else {

             variabl1841 = new double[variabl1853];

             variabl1661 = new double[variabl1853];

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

                variabl1841[i] = Double.parseDouble(variabl2197[i][0]

                      .toString());

                variabl1661[i] = Double.parseDouble(variabl2197[i][1]

                      .toString());

             }

             variabl2866.variabl28661();

           }

           Button0.setVisible(true);

           fl5.setVisible(true);

           ja15.setVisible(true);

           fl9.setVisible(true);

           ja19.setVisible(true);

           ja10.setVisible(true);

           fl10.setVisible(true);

        }

     });

     Button1.setBounds(680, variabl1783 - 80, 170, 20);

     frame1.add(Button1);

 

     final JButton Button2 = new JButton("退出");

     Button2.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           variabl2866.frame2.setVisible(false);

           variabl2866.frame2.dispose();

           frame1.setVisible(false);

           frame1.dispose();

           System.exit(0);

        }

     });

     Button2.setBounds(850, variabl1783 - 80, 120, 20);

     frame1.add(Button2);

     frame1.setVisible(true);

   }

 

   static void variabl2861(String variabl2217) {

     int c = 0;

     int b = 0;

     String s1 = "";

     try {

        cont4 = main1.getConn();

        stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

             ResultSet.CONCUR_UPDATABLE);

        s1 = "select " + variabl1633 + "  from " + variabl2217

             + variabl2049;

        rs = stat4.executeQuery(s1);

        rsmdt4 = rs.getMetaData();

        variabl2651 = rsmdt4.getColumnCount();

        variabl2517 = new String[variabl2651];

        variabl1501 = new String[variabl2651];

        variabl1489 = new int[variabl2651];

        for (int i1 = 0; i1 < variabl2651; i1++) {

           variabl2517[i1] = rsmdt4.getColumnName(i1 + 1);

           variabl1501[i1] = rsmdt4.getColumnTypeName(i1 + 1);

           variabl1489[i1] = rsmdt4.getColumnDisplaySize(i1 + 1);

        }

        rs.last();

        variabl1853 = rs.getRow();

        variabl21970 = new String[variabl1853][variabl2651];

        int t = 1;

        while (c < variabl1853) {

           rs.absolute(c + 1);

           while (b < variabl2651) {

             variabl21970[c][b] = rs.getString(b + 1);

             if ((main1.variabl1545.lastIndexOf("," + variabl1501[b]

                   + ",")) > 0)

                if ((variabl21970[c][b] == null)

                      || (variabl21970[c][b].trim().length() == 0))

                   variabl21970[c][b] = "0";

                else if (variabl21970[c][b] == null)

                   variabl21970[c][b] = "";

             double x0 = Double.parseDouble(variabl21970[c][b]

                   .toString());

             if ((x0 > 0.00001) || (x0 < -0.00001))

                t = 0;

             b++;

           }

           if (t == 1) {

             break;

           }

           c++;

           b = 0;

           t = 1;

        }

        variabl1853 = c;

        rs.close();

        stat4.close();

        cont4.close();

     } catch (SQLException e1) {

        JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

     }

     variabl2197 = new String[variabl1853][variabl2651];

     for (int i1 = 0; i1 < variabl1853; i1++)

        for (int j1 = 0; j1 < variabl2651; j1++)

           variabl2197[i1][j1] = variabl21970[i1][j1];

   }

}

 

class variabl2866 extends JFrame {

   private static final long serialVersionUID = 1L;

   static variabl2866 frame2 = new variabl2866();

   static Graphics g;

   static double[] variabl1841, variabl1661;

   static int variabl1853;

   static int variabl1727 = 1000, variabl1783 = 700;

   static double variabl3647 = 0, variabl1519, variabl3685 = 0, variabl1305;

   static int variabl1415 = 20, variabl1395 = 10;

   static String variabl16751;

   static int variabl1617, variabl2273, variabl2355;

   static double variabl1029;

   static double variabl1019;

   static int variabl1529 = 60, w0 = 0, h0 = 0;

   static int variabl1437 = 60;

   static double variabl1021;

   static double variabl1027;

   static double variabl2283 = 0, variabl2365 = 0, variabl1869 = 0,

        variabl3653 = 0;

   static double variabl24531 = 0, variabl24231 = 0, Lxx1 = 0, Lxy1 = 0;

   static double yyy;

   static double xxx;

   static double variabl2227 = 0, variabl2143 = 0;

   static double[] variabl2575 = new double[20];

 

   static void variabl28661() {

     variabl2866 frame2 = new variabl2866();

      frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

     frame2.setBounds(10, 10, 1000, variabl1783 - 50);

     frame2.setVisible(true);

   }

 

   public void paint(Graphics g1) {

     variabl1853 = dataMining1.variabl1853;

     variabl1841 = new double[variabl1853];

     variabl1661 = new double[variabl1853];

     variabl1519 = dataMining1.variabl1841[0];

     variabl1305 = dataMining1.variabl1661[0];

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

        variabl1841[i] = dataMining1.variabl1841[i];

        variabl1661[i] = dataMining1.variabl1661[i];

        if (variabl1841[i] > variabl3647)

           variabl3647 = variabl1841[i];

        if (variabl1841[i] < variabl1519)

           variabl1519 = variabl1841[i];

        if (variabl1661[i] > variabl3685)

           variabl3685 = variabl1661[i];

        if (variabl1661[i] < variabl1305)

           variabl1305 = variabl1661[i];

     }

     g1.setColor(Color.WHITE);

     g1.fillRect(0, 0, getWidth(), getHeight());

     g = g1;

     brokenLine();

   }

 

   static void brokenLine() {

     g.setColor(Color.BLACK);

     variabl1617 = variabl1783 - 200;

     double variabl1939 = variabl1727 - 100;

     double variabl1047 = variabl1617 / (variabl3647 - variabl1519);

     double variabl1053 = variabl1939 / (variabl3685 - variabl1305);

     variabl1029 = (double) ((variabl3647 - variabl1519)) / (variabl1415);

     variabl1019 = (double) (variabl1617) / (variabl3647 - variabl1519);

     variabl1529 = 60;

     variabl1437 = 60;

     variabl1021 = (double) ((variabl3685 - variabl1305)) / (variabl1395);

     variabl1027 = (double) ((variabl1727 - 200))

           / (variabl3685 - variabl1305);

     double[] variabl1137 = new double[variabl1415 + 1];

      variabl1137[0] = variabl1519;

     for (int i = 1; i < variabl1415 + 1; i++) {

        variabl1137[i] = variabl1137[i - 1] + (variabl3647 - variabl1519)

             / variabl1415;

     }

     double[] variabl1265 = new double[variabl1395 + 1];

     variabl1265[0] = variabl1305;

     for (int i = 1; i < variabl1395 + 1; i++) {

        variabl1265[i] = variabl1265[i - 1] + (variabl3685 - variabl1305)

             / variabl1395;

     }

     variabl2143 = 1;

     variabl1785();

     variabl1645(2);

     variabl1645(3);

     variabl1645(4);

     variabl1623(2);

     variabl1623(3);

     variabl1623(4);

     variabl2085();

     variabl1871();

     Graphics2D g2 = (Graphics2D) g;

     g2.setStroke(new BasicStroke(2f));

     g.drawLine(variabl1529, variabl1437 - 10, variabl1529, variabl1617

           + variabl1437 + 5);

     g.drawLine(variabl1529, variabl1437 - 15, variabl1529 - 3, variabl1437);

     g.drawLine(variabl1529, variabl1437 - 15, variabl1529 + 2, variabl1437);

     g.setColor(Color.RED);

     g.drawString(dataMining1.fa0.getText(), variabl1529 + 10,

           variabl1437 - 5);

     int x = 0, y = 0;

     w0 = 5;

     h0 = 5;

     double y2, z1;

     y2 = ((variabl24231 - Lxy1 * variabl24531 / Lxx1) + (Lxy1 / Lxx1)

           * variabl3685)

           - variabl1519;

     y2 = variabl1617 + variabl1437 - y2 * variabl1019;

     g.setColor(Color.RED);

     double xx1 = variabl1305;

     double xx2 = variabl3685;

     double yy1 = (variabl24231 - Lxy1 * variabl24531 / Lxx1)

           + (Lxy1 / Lxx1 * xx1);

     double yy2 = (variabl24231 - Lxy1 * variabl24531 / Lxx1)

           + (Lxy1 / Lxx1 * xx2);

     xx1 = (xx1 - variabl1305) * variabl1027 + variabl1529;

     xx2 = (xx2 - variabl1305) * variabl1027 + variabl1529;

     yy1 = (yy1 - variabl1519) * variabl1019;

     yy2 = (yy2 - variabl1519) * variabl1019;

     yy1 = variabl1617 + variabl1437 - yy1;

     yy2 = variabl1617 + variabl1437 - yy2;

     String z0;

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

        z1 = variabl1137[i + 1];

        z0 = z1 + "        ";

        z0 = z0.substring(0, 6);

        x = variabl1529 - 40;

        y = variabl1437 * 2 + variabl1617

             - (int) (variabl1529 + (i + 1) * variabl1019 * variabl1029);

        g.setColor(Color.RED);

        g.drawString(z0, x, y);

        g.setColor(Color.BLACK);

        g.drawLine(x + 35, y, x + 45, y);

     }

     if (((variabl3647 > 0) && (variabl3647 * variabl1519 >= 0))

           || ((variabl3647 <= 0) && (variabl1519 < 0))) {

        g.drawLine(x, variabl1437 + variabl1617, x + variabl1727 - 80,

             variabl1437 + variabl1617);

        g.drawLine(x + variabl1727 - 100, variabl1437 + variabl1617 - 3, x

             + variabl1727 - 80, variabl1437 + variabl1617);

        g.drawLine(x + variabl1727 - 100, variabl1437 + variabl1617 + 3, x

             + variabl1727 - 80, variabl1437 + variabl1617);

        g.setColor(Color.RED);

        g.drawString(dataMining1.fa2.getText(), x + variabl1727 - 120,

             variabl1437 + variabl1617 - 20);

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

           g.setColor(Color.RED);

           z1 = variabl1265[i + 1];

           z0 = z1 + "        ";

           z0 = z0.substring(0, 6);

           x = (int) (variabl1529 + (i + 1) * variabl1027 * variabl1021);

           y = variabl1437 + variabl1617 + 6;

           g.drawString(z0, x, y + 10);

           g.setColor(Color.BLACK);

           g.drawLine(x, y - 10, x, y - 5);

        }

     } else {

        int variabl1161 = (int) (variabl1617 + variabl1437 - (0 - variabl1519)

             * variabl1019);

        g.drawLine(x, variabl1161, x + variabl1727 - 80, variabl1161);

        g.drawLine(x + variabl1727 - 100, variabl1161 - 3, x + variabl1727

             - 80, variabl1161);

        g.drawLine(x + variabl1727 - 100, variabl1161 + 3, x + variabl1727

             - 80, variabl1161);

        g.setColor(Color.RED);

        g.drawString(dataMining1.fa2.getText(), x + variabl1727 - 120 + 20,

             variabl1161 - 20);

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

           g.setColor(Color.RED);

           z1 = ((i + 1) * variabl1021 + variabl1305);

           z0 = z1 + "        ";

           z0 = z0.substring(0, 6);

           x = (int) (variabl1529 + (i + 1) * variabl1027 * variabl1021);

           y = variabl1161 + 6;

           g.drawString(z0, x, y + 10);

           g.setColor(Color.BLACK);

           g.drawLine(x, y - 10, x, y - 5);

        }

     }

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

        yyy = (variabl1841[i] - variabl1519) * variabl1019;

        yyy = variabl1617 + variabl1437 - yyy;

        xxx = (variabl1661[i] - variabl1305) * variabl1027 + variabl1529;

        g.fillOval((int) xxx, (int) yyy, w0, h0);

     }

     g.setColor(Color.RED);

     double yyy1 = 0, xxx1, yyy2, xxx2, yyy3, xxx3;

     xxx1 = variabl1305;

     variabl2355 = 1;

     if (variabl2143 == 1)

        yyy1 = variabl2575[0] + variabl2575[1] * xxx1;

     else if (variabl2143 == 5)

        yyy1 = variabl2575[0] + variabl2575[1] * Math.exp(xxx1);

     else if (variabl2143 == 6)

        yyy1 = variabl2575[0] + variabl2575[1] * Math.sin(xxx1);

     else {

        for (int i4 = 0; i4 < 6; i4++) {

           yyy1 = yyy1 + variabl2575[i4] * Math.pow(xxx1, i4);

           if (variabl2575[i4] != 0)

             variabl2355 = i4;

        }

     }

     yyy3 = (yyy1 - variabl1519) * variabl1019;

     yyy3 = variabl1617 + variabl1437 - yyy3;

     xxx3 = (xxx1 - variabl1305) * variabl1027 + variabl1529;

     int variabl1781 = 200;

     for (int i = 1; i < variabl1781; i++) {

        xxx = xxx1 + (variabl3685 - variabl1305) / variabl1781;

        if (variabl2143 == 1)

           yyy = variabl2575[0] + variabl2575[1] * xxx;

        else if (variabl2143 == 5)

           yyy = variabl2575[0] + variabl2575[1] * Math.exp(xxx);

        else if (variabl2143 == 6)

           yyy = variabl2575[0] + variabl2575[1] * Math.sin(xxx);

        else {

           yyy = 0;

           for (int i4 = 0; i4 < variabl2575.length; i4++) {

             yyy = yyy + variabl2575[i4] * Math.pow(xxx, i4);

           }

        }

        xxx2 = xxx;

        yyy2 = yyy;

        yyy = (yyy - variabl1519) * variabl1019;

        yyy = variabl1617 + variabl1437 - yyy;

        xxx = (xxx - variabl1305) * variabl1027 + variabl1529;

        g.drawLine((int) xxx3, (int) yyy3, (int) xxx, (int) yyy);

        xxx1 = xxx2;

        yyy1 = yyy2;

        xxx3 = xxx;

        yyy3 = yyy;

     }

     g.drawString(variabl16751, 100, variabl1617 + 100);

   }

 

   public static void variabl1785() {

     variabl2283 = 0;

     variabl2365 = 0;

     variabl1869 = 0;

     variabl3653 = 0;

     variabl24531 = 0;

     variabl24231 = 0;

     Lxx1 = 0;

     Lxy1 = 0;

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

        variabl2283 = variabl2283 + variabl1661[i];

        variabl2365 = variabl2365 + variabl1841[i];

        variabl1869 = variabl1869 + variabl1661[i] * variabl1841[i];

        variabl3653 = variabl3653 + variabl1661[i] * variabl1661[i];

        yyy = (variabl1841[i] - variabl1519) * variabl1019;

        yyy = variabl1617 + variabl1437 - yyy;

        xxx = (variabl1661[i] - variabl1305) * variabl1027 + variabl1529;

     }

     variabl24531 = variabl2283 / variabl1853;

     variabl24231 = variabl2365 / variabl1853;

     Lxx1 = variabl3653 - variabl2283 * variabl2283 / variabl1853;

     Lxy1 = variabl1869 - variabl2283 * variabl2365 / variabl1853;

     String v1 = ((variabl24231 - Lxy1 * variabl24531 / Lxx1) + "      ")

           .substring(0, 6);

     String v2 = ((Lxy1 / Lxx1) + "      ").substring(0, 6);

     variabl16751 = "回归方程1=" + "Y=" + v1 + "+" + v2 + "x";

     char x1 = 13, x22 = 10;

     String variabl2541 = "  x和=" + variabl2283 + x1 + x22;

     variabl2541 = variabl2541 + "  y和=" + variabl2365 + x1 + x22;

     variabl2541 = variabl2541 + "  xy和=" + variabl1869 + x1 + x22;

     variabl2541 = variabl2541 + "  x平方和=" + variabl3653 + x1 + x22;

     variabl2541 = variabl2541 + "  variabl2453=" + variabl2283

           / variabl1853 + x1 + x22;

     variabl2541 = variabl2541 + "  variabl2423=" + variabl2365

           / variabl1853 + x1 + x22;

     variabl2541 = variabl2541 + " Lxx=x平方和-x和*x和/variabl1853="

           + (variabl3653 - variabl2283 * variabl2283 / variabl1853) + x1

           + x22;

     variabl2541 = variabl2541 + " Lxy=xy和-x和*y和/variabl1853="

           + (variabl1869 - variabl2283 * variabl2365 / variabl1853) + x1

           + x22;

     variabl2541 = variabl2541

           + " Y=(variabl2423-Lxy*variabl2453/Lxx)+(Lxy/Lxx)*x" + x1 + x22;

     double a = variabl2365 / variabl1853

           - (variabl1869 - variabl2283 * variabl2365 / variabl1853)

           * variabl2283 / variabl1853

           / (variabl3653 - variabl2283 * variabl2283 / variabl1853);

     double b = (variabl1869 - variabl2283 * variabl2365 / variabl1853)

           / (variabl3653 - variabl2283 * variabl2283 / variabl1853);

     if (Lxy1 / Lxx1 > 0)

        variabl2541 = variabl2541 + "  ="

             + (variabl24231 - Lxy1 * variabl24531 / Lxx1) + "+"

             + (Lxy1 / Lxx1) + "*x";

     else

        variabl2541 = variabl2541 + "  ="

             + (variabl24231 - Lxy1 * variabl24531 / Lxx1)

             + (Lxy1 / Lxx1) + "*x";

     dataMining1.jta1.setText(variabl2541.trim());

     double c = 0;

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

        c = c + (variabl1841[i] - (a + b * variabl1661[i]))

             * (variabl1841[i] - (a + b * variabl1661[i]));

     }

     variabl2227 = Math.sqrt(c);

     dataMining1.ja10.setText((variabl2227 + "").substring(0, 6));

     variabl2575[0] = a;

     variabl2575[1] = b;

   }

 

   public static void variabl1623(int variabl2273) {

     try {

        double[] X = new double[variabl1661.length];

        double[] Y = new double[variabl1661.length];

        for (int i1 = 0; i1 < variabl1661.length; i1++) {

           X[i1] = variabl1661[i1];

           Y[i1] = variabl1841[i1];

        }

        int mm = X.length;

        int m = mm - 1;

        double bel[] = new double[variabl2273];

        double alp[] = new double[variabl2273 + 1];

        double A[] = new double[variabl2273 + 1];

        double error;

        double err[] = new double[m + 1];

        double sum[] = new double[m + 1];

        double my_sum = 0;

        double S1[] = new double[m + 1];

        double S0[] = new double[m + 1];

        double SS[] = new double[m + 1];

        double AU = 0, AL = 0, alp_L = 0, alp_U = 0, bel_U = 0, bel_L = 0;

        double sum_temp[] = new double[m + 1];

        my_sum = 0;

        double my_sumtemp = 0;

        boolean flag = true;

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

           AU += Y[i];

           AL++;

           alp_L++;

           alp_U += X[i];

           S0[i] = 1;

        }

        A[0] = AU / AL;

        bel_L = AL;

        alp[1] = alp_U / alp_L;

        my_sum += A[0] * 1;

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

           sum[i] += A[0] * 1;

        }

        AU = 0;

        AL = 0;

        alp_L = 0;

        alp_U = 0;

        bel_U = 0;

        double temp = 0;

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

           temp = (X[i] - alp[1]);

           S1[i] = temp;

           AU += Y[i] * temp;

           AL += temp * temp;

           alp_U += X[i] * temp * temp;

        }

        alp_L = AL;

        A[1] = AU / AL;

        alp[2] = alp_U / alp_L;

        bel_U = AL;

        bel[1] = bel_U / bel_L;

        my_sum += A[1] * (X[1] - alp[1]);

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

           sum[i] += A[1] * (X[i] - alp[1]);

        }

        int n = variabl2273;

        for (int j = 3; j <= n; j++) {

           AU = 0;

           AL = 0;

           alp_L = 0;

           alp_U = 0;

           bel_U = 0;

           bel_L = 0;

           for (int ii = 0; ii <= m; ii++) {

             SS[ii] = S1[ii];

           }

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

             sum_temp[i] = (X[i] - alp[j - 1]) * S1[0] - bel[j - 2]

                   * S0[0];

           }

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

             if (flag) {

                my_sumtemp = (X[1] - alp[j - 1]) * S1[0] - bel[j - 2]

                      * S0[0];

             }

             bel_L = bel_L + S1[i] * S1[i];

             S1[i] = (X[i] - alp[j - 1]) * S1[i] - bel[j - 2] * S0[i];

             alp_L = alp_L + S1[i] * S1[i];

             alp_U = alp_U + X[i] * S1[i] * S1[i];

             S0[i] = SS[i];

             AU = AU + Y[i] * S1[i];

             flag = false;

           }

           flag = true;

           bel_U = alp_L;

           AL = alp_L;

           alp[j] = alp_U / alp_L;

           bel[j - 1] = bel_U / bel_L;

           A[j - 1] = AU / AL;

           my_sum += A[j - 1] * my_sumtemp;

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

             sum[i] += A[j - 1] * sum_temp[i];

           }

        }

        AU = 0;

        AL = 0;

        alp_L = 0;

        alp_U = 0;

        bel_U = 0;

        bel_L = 0;

        for (int ii = 0; ii <= m; ii++) {

           SS[ii] = S1[ii];

        }

        flag = true;

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

           sum_temp[i] = (X[i] - alp[n]) * S1[0] - bel[n - 1] * S0[0];

        }

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

           if (flag) {

             my_sumtemp = (X[1] - alp[n]) * S1[0] - bel[n - 1] * S0[0];

           }

           S1[i] = (X[i] - alp[n]) * S1[i] - bel[n - 1] * S0[i];

           AL = AL + S1[i] * S1[i];

           S0[i] = SS[i];

           AU = AU + Y[i] * S1[i];

           flag = false;

        }

        A[n] = AU / AL;

        my_sum += A[n] * my_sumtemp;

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

           sum[i] += A[n] * sum_temp[i];

        }

        String sk = "";

        String sk1 = "";

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

           A[i] = A[i] * Math.pow(10, (i - 2));

           sk1 = (A[i] + "      ").substring(0, 6);

           if ((i == 0) && (A[i] != 0))

             sk = sk + sk1;

           if ((i == 1) && (A[i] != 0))

             sk = sk + "+" + sk1 + "x";

           if ((i == 2) && (A[i] != 0))

             sk = sk + "+" + sk1 + "x^2";

           if ((i == 3) && (A[i] != 0))

             sk = sk + "+" + sk1 + "x^3";

           if ((i == 4) && (A[i] != 0))

             sk = sk + "+" + sk1 + "x^4";

        }

        double xc = 0, xc1 = 0;

        for (int i1 = 0; i1 < variabl1853; i1++) {

           xc1 = ((A[0] + A[1] * variabl1661[i1] + A[2] * variabl1661[i1]

                * variabl1661[i1] + A[3] * variabl1661[i1]

                * variabl1661[i1] * variabl1661[i1] + A[4]

                * variabl1661[i1] * variabl1661[i1] * variabl1661[i1]

                * variabl1661[i1]));

          xc = xc + (variabl1841[i1] - xc1) * (variabl1841[i1] - xc1);

        }

        xc = Math.sqrt(xc);

        if (xc < variabl2227) {

           variabl2227 = xc;

           dataMining1.ja10.setText((variabl2227 + "").substring(0, 6));

           variabl16751 = sk;

           variabl2143 = 3;

           for (int i3 = 0; i3 < A.length; i3++)

             variabl2575[i3] = A[i3];

        }

     } catch (Exception e2) {

     }

   }

 

   public static void variabl1645(int variabl2273) {

     try {

        int i = 0;

        double[] a = new double[6], dt = new double[3];

        double[] x = new double[variabl1661.length];

        double[] y = new double[variabl1661.length];

        for (int i1 = 0; i1 < variabl1661.length; i1++) {

           x[i1] = variabl1661[i1];

           y[i1] = variabl1841[i1];

        }

        int n = x.length;

        int m = variabl2273;

        int j = 0, k = 0;

        double z = 0.0, p = 0.0, c = 0.0, g = 0.0, q = 0.0, d1 = 0.0, d2 = 0.0;

        double[] s = new double[20], t = new double[20], b = new double[20];

        for (i = 0; i <= m - 1; i++)

           a[i] = 0.0;

        if (m > n)

           m = n;

        if (m > 20)

           m = 20;

        z = 0.0;

        for (i = 0; i <= n - 1; i++) {

           z = z + x[i] / (1.0 * n);

        }

        b[0] = 1.0;

        d1 = 1.0 * n;

        p = 0.0;

        c = 0.0;

        for (i = 0; i <= n - 1; i++) {

           p = p + (x[i] - z);

           c = c + y[i];

        }

        c = c / d1;

        p = p / d1;

        a[0] = c * b[0];

        if (m > 1) {

           t[1] = 1.0;

           t[0] = -p;

           d2 = 0.0;

           c = 0.0;

           g = 0.0;

           for (i = 0; i <= n - 1; i++) {

             q = x[i] - z - p;

             d2 = d2 + q * q;

             c = c + y[i] * q;

             g = g + (x[i] - z) * q * q;

           }

           c = c / d2;

           p = g / d2;

           q = d2 / d1;

           d1 = d2;

           a[1] = c * t[1];

           a[0] = c * t[0] + a[0];

        }

        for (j = 2; j <= m - 1; j++) {

           s[j] = t[j - 1];

           s[j - 1] = -p * t[j - 1] + t[j - 2];

           if (j >= 3)

             for (k = j - 2; k >= 1; k--)

                s[k] = -p * t[k] + t[k - 1] - q * b[k];

           s[0] = -p * t[0] - q * b[0];

           d2 = 0.0;

           c = 0.0;

           g = 0.0;

           for (i = 0; i <= n - 1; i++) {

             q = s[j];

             for (k = j - 1; k >= 0; k--)

                q = q * (x[i] - z) + s[k];

             d2 = d2 + q * q;

             c = c + y[i] * q;

             g = g + (x[i] - z) * q * q;

           }

           c = c / d2;

           p = g / d2;

           q = d2 / d1;

           d1 = d2;

           a[j] = c * s[j];

           t[j] = s[j];

           for (k = j - 1; k >= 0; k--) {

             a[k] = c * s[k] + a[k];

             b[k] = t[k];

             t[k] = s[k];

           }

        }

        dt[0] = 0.0;

        dt[1] = 0.0;

        dt[2] = 0.0;

        for (i = 0; i <= n - 1; i++) {

           q = a[m - 1];

           for (k = m - 2; k >= 0; k--)

             q = a[k] + q * (x[i] - z);

           p = q - y[i];

           if (Math.abs(p) > dt[2])

             dt[2] = Math.abs(p);

           dt[0] = dt[0] + p * p;

           dt[1] = dt[1] + Math.abs(p);

        }

        String sk = "", sk1 = "";

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

           a[i] = a[i] * Math.pow(10, (i + 1 - variabl2273));

           sk1 = (a[i] + "      ").substring(0, 6);

           if ((i == 0) && (a[i] != 0))

             sk = sk + sk1;

           if ((i == 1) && (a[i] != 0))

             sk = sk + "+" + sk1 + "x";

           if ((i == 2) && (a[i] != 0))

             sk = sk + "+" + sk1 + "x^2";

           if ((i == 3) && (a[i] != 0))

             sk = sk + "+" + sk1 + "x^3";

           if ((i == 4) && (a[i] != 0))

             sk = sk + "+" + sk1 + "x^4";

        }

        double xc = 0, xc1 = 0;

        for (int i1 = 0; i1 < variabl1853; i1++) {

           xc1 = ((a[0] + a[1] * variabl1661[i1] + a[2] * variabl1661[i1]

                * variabl1661[i1] + a[3] * variabl1661[i1]

                * variabl1661[i1] * variabl1661[i1] + a[4]

                * variabl1661[i1] * variabl1661[i1] * variabl1661[i1]

                * variabl1661[i1]));

          xc = xc + (variabl1841[i1] - xc1) * (variabl1841[i1] - xc1);

        }

        xc = Math.sqrt(xc);

        if (xc < variabl2227) {

           variabl2227 = xc;

           variabl16751 = "y=" + sk;

           dataMining1.ja10.setText((variabl2227 + "").substring(0, 6));

           variabl2143 = 4;

           for (int i3 = 0; i3 < a.length; i3++)

             variabl2575[i3] = a[i3];

        }

     } catch (Exception e2) {

     }

   }

 

   public static void variabl2085() {

     String sk = "";

     try {

        double[] x1 = new double[variabl1661.length];

        double[] y1 = new double[variabl1661.length];

        for (int i1 = 0; i1 < variabl1661.length; i1++) {

           x1[i1] = variabl1661[i1];

           y1[i1] = variabl1841[i1];

        }

        int n = x1.length;

        double x[] = new double[x1.length];

        double y[] = new double[x1.length];

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

           x[i] = Math.exp(x1[i]);

           y[i] = y1[i];

        }

        double[] a = new double[2];

        double[] dt = new double[6];

        int i;

        double xx, yy, e, f, q, u, p, umax, umin, s;

        xx = 0.0;

        yy = 0.0;

        for (i = 0; i <= n - 1; i++) {

           xx = xx + x[i] / n;

           yy = yy + y[i] / n;

        }

        e = 0.0;

        f = 0.0;

        for (i = 0; i <= n - 1; i++) {

           q = x[i] - xx;

           e = e + q * q;

           f = f + q * (y[i] - yy);

        }

        a[1] = f / e;

        a[0] = yy - a[1] * xx;

        q = 0.0;

        u = 0.0;

        p = 0.0;

        umax = 0.0;

        umin = 1.0e+30;

        sk = ((a[0] + "      ").substring(0, 6) + "+"

             + (a[1] + "      ").substring(0, 6) + "*e^x");

        for (i = 0; i <= n - 1; i++) {

           s = a[1] * x[i] + a[0];

           q = q + (y[i] - s) * (y[i] - s);

           p = p + (s - yy) * (s - yy);

           e = Math.abs(y[i] - s);

           if (e > umax)

             umax = e;

           if (e < umin)

             umin = e;

           u = u + e / n;

        }

        dt[1] = Math.sqrt(q / n);

        dt[0] = q;

        dt[2] = p;

        dt[3] = umax;

        dt[4] = umin;

        dt[5] = u;

        double xc = 0, xc1 = 0;

        for (int i1 = 0; i1 < variabl1853; i1++) {

           xc1 = a[0] + a[1] * Math.exp(variabl1661[i1]);

          xc = xc + (variabl1841[i1] - xc1) * (variabl1841[i1] - xc1);

        }

        xc = Math.sqrt(xc);

        if (xc < variabl2227) {

           variabl2227 = xc;

           variabl2143 = 5;

           variabl16751 = "y=" + sk;

           variabl2575[0] = a[0];

           variabl2575[1] = a[1];

           dataMining1.ja10.setText((variabl2227 + "").substring(0, 6));

        }

     } catch (Exception e2) {

     }

   }

 

   public static void variabl1871() {

     String sk = "";

     try {

        double[] x1 = new double[variabl1661.length];

        double[] y1 = new double[variabl1661.length];

        for (int i1 = 0; i1 < variabl1661.length; i1++) {

           x1[i1] = variabl1661[i1];

           y1[i1] = variabl1841[i1];

        }

        double x[] = new double[x1.length];

        double y[] = new double[x1.length];

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

           x[i] = Math.sin(x1[i]);

          y[i] = y1[i];

        }

        int n = x.length;

        double[] a = new double[2];

        double[] dt = new double[6];

        int i;

        double xx, yy, e, f, q, u, p, umax, umin, s;

        xx = 0.0;

        yy = 0.0;

        for (i = 0; i <= n - 1; i++) {

           {

             xx = xx + x[i] / n;

             yy = yy + y[i] / n;

           }

        }

        e = 0.0;

        f = 0.0;

        for (i = 0; i <= n - 1; i++) {

           q = x[i] - xx;

           e = e + q * q;

           f = f + q * (y[i] - yy);

        }

        a[1] = f / e;

        a[0] = yy - a[1] * xx;

        q = 0.0;

        u = 0.0;

        p = 0.0;

        umax = 0.0;

        umin = 1.0e+30;

        sk = "y=" + (a[0] + "      ").substring(0, 6) + "+"

             + (a[1] + "      ").substring(0, 6) + "*sin(x)";

        for (i = 0; i <= n - 1; i++) {

           s = a[1] * x[i] + a[0];

           q = q + (y[i] - s) * (y[i] - s);

           p = p + (s - yy) * (s - yy);

           e = Math.abs(y[i] - s);

           if (e > umax)

             umax = e;

           if (e < umin)

             umin = e;

           u = u + e / n;

        }

        dt[1] = Math.sqrt(q / n);

        dt[0] = q;

        dt[2] = p;

        dt[3] = umax;

        dt[4] = umin;

        dt[5] = u;

        double xc = 0, xc1 = 0;

        for (int i1 = 0; i1 < variabl1853; i1++) {

           xc1 = a[0] + a[1] * Math.sin(variabl1661[i1]);

          xc = xc + (variabl1841[i1] - xc1) * (variabl1841[i1] - xc1);

        }

        xc = Math.sqrt(xc);

        if (xc < variabl2227) {

           variabl2227 = xc;

           variabl16751 = sk;

           variabl2143 = 6;

           variabl2575[0] = a[0];

           variabl2575[1] = a[1];

           dataMining1.ja10.setText((variabl2227 + "").substring(0, 6));

        }

     } catch (Exception e2) {

     }

   }

 

   public static void variabl2019(String[][] variabl26151) {

     try {

        double[][] source = new double[variabl26151.length][variabl26151[0].length];

        for (int i1 = 0; i1 < variabl26151.length; i1++) {

           for (int j1 = 0; j1 < variabl26151[0].length; j1++) {

             source[i1][j1] = Double.parseDouble(variabl26151[i1][j1]);

          }

        }

        int rowNum = source.length + 1;

        int colNum = source[0].length + 1;

        double[] mean = new double[colNum - 1];

        double[] dev = new double[colNum - 1];

        double[][] sp = new double[colNum - 1][colNum - 1];

        double[][] r = new double[colNum - 1][colNum - 1];

        ArrayList<String> choose = new ArrayList<String>();

        for (int i = 0; i < colNum - 1; i++) {

           double[] listdouble = getdoublebycolumn(source, i);

           double sum = 0;

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

             sum += listdouble[j];

           mean[i] = sum / listdouble.length;

        }

        for (int i = 0; i < colNum - 1; i++) {

           double[] listdouble = getdoublebycolumn(source, i);

           double sum = 0;

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

             sum += Math.pow((listdouble[j] - mean[i]), 2);

           dev[i] = (double) Math.sqrt(sum / listdouble.length);

        }

        for (int i = 0; i < colNum - 1; i++) {

 

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

             sp[i][j] = 0;

             for (int k = 0; k < rowNum - 1; k++)

                sp[i][j] += (source[k][i] - mean[i])

                      * (source[k][j] - mean[j]);

             sp[j][i] = sp[i][j];

           }

        }

        for (int i = 0; i < colNum - 1; i++) {

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

             r[i][j] = (double) (sp[i][j] / Math.sqrt(sp[i][i]

                   * sp[j][j]));

             r[j][i] = r[i][j];

           }

        }

        double F_in = 3.280;

        double F_out = 3.280;

        for (int k = 0; k < colNum - 2; k++) {

           double[] u = new double[colNum - 2];

           for (int i = 0; i < colNum - 2; i++) {

             u[i] = r[colNum - 2][i] * r[colNum - 2][i] / r[i][i];

           }

           double Q = r[colNum - 2][colNum - 2];

           int min_index = getMinIndex(u, choose);

           double[][] r3 = new double[colNum - 1][colNum - 1];

           double pF_out = u[min_index]

                / (Q / (rowNum - 1 - choose.size() - 1));

           if (!(Math.abs(pF_out) > F_out)) {

             choose.remove(min_index + "");

             r = trans(r, min_index, colNum);

             break;

           }

           for (String in : choose) {

             int ii = Integer.parseInt(in);

             u[ii] = 0;

           }

           int index = getMaxIndex(u);

           double pF = u[index]

                / ((r[colNum - 2][colNum - 2] - u[index]) / ((rowNum - 1)

                      - choose.size() - 1 - 1));

           double[][] r2 = new double[colNum - 1][colNum - 1];

           if (pF > F_in) {

             choose.add(index + "");

             r = trans(r, index, colNum);

           }

        }

        double[] b = new double[choose.size()];

        int bi = 0;

        for (String in : choose) {

           int ii = Integer.parseInt(in);

           b[bi] = r[ii][colNum - 2] * dev[colNum - 2] / dev[ii];

           bi++;

        }

        double b0 = mean[colNum - 2];

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

           b0 -= b[i] * mean[Integer.parseInt(choose.get(i))];

        }

        variabl2575[0] = b0;

        String ans = "y=" + (b0 + "       ").substring(0, 6) + "+";

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

           int iii = Integer.parseInt(choose.get(i)) + 1;

           if (i < b.length - 1) {

             ans += (b[i] + "       ").substring(0, 6) + "x" + iii + "+";

             variabl2575[iii] = b[i];

           } else {

             ans += (b[i] + "       ").substring(0, 6) + "x" + iii;

             variabl2575[iii] = b[i];

           }

        }

        double rr = (double) Math.sqrt(1 - r[colNum - 2][colNum - 2]);

        double ssy = 0, ssy1 = 0, xc = 0;

        for (int i = 0; i < rowNum - 1; i++) {

           ssy += (source[i][colNum - 2] - mean[colNum - 2])

                * (source[i][colNum - 2] - mean[colNum - 2]);

           ssy1 = source[i][colNum - 2];

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

             ssy1 = ssy1 - b[j] * source[i][j];

           }

           xc = xc + ssy1 * ssy1;

        }

        double d = (double) Math.sqrt(r[colNum - 2][colNum - 2] * ssy

             / rowNum - 1 - choose.size() - 1);

        xc = Math.sqrt(xc);

        char x1 = 10, x2 = 13;

        if (variabl2575[1] != 0) {

           dataMining1.fl6.setVisible(true);

           dataMining1.ja16.setVisible(true);

        }

        if (variabl2575[2] != 0) {

           dataMining1.fl7.setVisible(true);

           dataMining1.ja17.setVisible(true);

        }

        if (variabl2575[3] != 0) {

           dataMining1.fl8.setVisible(true);

           dataMining1.ja18.setVisible(true);

        }

        JOptionPane.showMessageDialog(null, "回归方程：" + ans + x1 + x2

             + "实验数据标准误差: " + (xc + "       ").substring(0, 6));

     } catch (Exception e2) {

     }

   }

 

   public static double[] getdoublebycolumn(double[][] strarray, int column) {

     int rowlength = strarray.length;

     int columnlength = strarray[0].length;

     double[] templist = new double[rowlength];

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

        templist[i] = (strarray[i][column]);

     }

     return templist;

   }

 

   public static int getMaxIndex(double[] pu) {

     int index = 0;

     double max = 0;

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

        if (Math.abs(pu[i]) >= max) {

           index = i;

           max = Math.abs(pu[i]);

        }

     }

     return index;

   }

 

   public static int getMinIndex(double[] pu, ArrayList<String> pchoose) {

     int index = 0;

     double min = 1;

     for (String in : pchoose) {

        int ii = Integer.parseInt(in);

        if (Math.abs(pu[ii]) <= min) {

           index = ii;

           min = Math.abs(pu[ii]);

        }

      }

     return index;

 

   }

 

   public static double[][] trans(double[][] pr, int pindex, int pcol) {

     double[][] r2 = new double[pcol - 1][pcol - 1];

     for (int i = 0; i < pcol - 1; i++)

        for (int j = 0; j < pcol - 1; j++) {

           if (i == pindex && j == pindex)

             r2[i][j] = 1 / pr[i][j];

           else if (i == pindex && j != pindex)

             r2[i][j] = pr[i][j] / pr[i][i];

           else if (i != pindex && j == pindex)

             r2[i][j] = -pr[i][j] / pr[j][j];

           else {

             r2[i][j] = pr[i][j] - pr[i][pindex] * pr[pindex][j]

                   / pr[pindex][pindex];

           }

        }

     return r2;

   }

}

 

105.源码105，实验程序，仅供参考。读取纯文本文件二数据表中的数据进行Apriori关联分析。

/*

 * 程序文件名：dataMining2.java

 * 作者：程学先

 * 功能：实验程序，读取纯文本文件二数据表中的数据进行Apriori关联分析。

 * 其中每行一项共一列数据，可以有多个元素，用逗号分隔

  */

import java.awt.BorderLayout;

import java.awt.Component;

import java.awt.Insets;

import java.awt.List;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.Arrays;

import java.util.HashSet;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableColumn;

import javax.swing.table.TableModel;

 

public class dataMining2 extends JFrame {

   static int variabl1727 = 1340, variabl1783 = 600;

   static Insets inset;

   static int variabl2661 = 100, variabl2657 = variabl1783;

   private static JTable table;

   static String variabl2603;

   static String[] sk;

   static int variabl2483 = 1400, variabl2503 = 600;

   static int variabl19631, variabl19632;

   static Object[][] variabl2197;

   static List list1 = new List();

   static JTextField fa0, fa1, fa2, fa3, fb1;

   static HashSet<String> set1 = new HashSet<String>();

   static TableModel model;

   static JScrollPane scrollPane;

   static double variabl4017 = 0;

   static int variabl2451 = 1, variabl2313 = 1, variabl23131 = 1;

   static int variabl2061 = set1.size();

   static int variabl20612 = set1.size();

   static String[] variabl25890 = null;

   static String variabl2589[] = set1.toArray(new String[0]);

   static String variabl25891[] = set1.toArray(new String[0]);

   static String variabl25892[] = set1.toArray(new String[0]);

   static int variabl2209[] = new int[variabl2589.length];

   static dataMining2 frame1 = new dataMining2();

   static JButton Button0 = new JButton("显示数据表格");

   static JButton Button1 = new JButton("显示频繁集");

   static JButton Button2 = new JButton("自动测试频繁集");

   static String variabl2263 = "", variabl22631 = "";

   static char x1 = 10, x2 = 13;

   static int variabl1959 = 0, variabl19591 = 0;

   static JTextArea jta1;

   private static Connection cont4;

   private static Statement stat4;

   private static ResultSetMetaData rsmdt4;

   private static ResultSet rs;

   static String[] variabl2517;

   static int variabl1853, variabl2651, variabl1739;

   static String[] variabl1501;

   private static int[] variabl1489;

   private static String[][] variabl21970;

   private static String variabl2049 = "";

   private static String variabl1633 = "";

 

   public static void variabl40191(double variabl4041) {

     variabl4017 = variabl4041;

     fa0.setText((variabl4017 + 0.005 + "    ").substring(0, 4));

     int variabl2209[] = new int[variabl2589.length];

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

        for (int j = 0; j < variabl1853; j++) {

           if (("," + variabl2197[j][1] + ",").indexOf(","

                + variabl2589[i] + ",") >= 0) {

             variabl2209[i]++;

           }

        }

     variabl25891 = new String[variabl2589.length];

     variabl25892 = new String[variabl2589.length];

     String[] variabl25896 = new String[variabl2589.length];

     variabl2263 = "1项集：";

     int variabl20610 = 0;

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

        variabl25892[i] = variabl2589[i];

        if (((variabl2209[i] + 0.0) / variabl1853) >= variabl4017) {

           variabl2263 = variabl2263 + "{" + variabl2589[i] + ":"

                + variabl2209[i] + "}";

           variabl25896[variabl20610] = variabl2589[i];

           variabl20610++;

        }

     }

     jta1.setText(" variabl2263=" + variabl2263);

     if (variabl2061 == 0)

        variabl19591 = 1;

     p1(2, variabl20610, variabl25896);

     jta1.setText(" variabl2263=" + variabl2263);

     char x1 = 10;

     x2 = 13;

     variabl22631 = variabl22631 + x1 + x2 + "最小支持度="

           + ((variabl4041 + 0.005) + "    ").substring(0, 4) + x1 + x2

           + variabl2263;

   }

 

   public static void variabl12531() {

     scrollPane = new JScrollPane();

     scrollPane.setBounds(10, 10, 700, variabl2503 - 100);

     model = new DefaultTableModel(variabl2197, variabl2517);

     table = new JTable(model);

     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

      table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

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

        TableColumn tc = table.getColumn(variabl2517[i]);

        if (i == 0)

           tc.setPreferredWidth(50);

        else

           tc.setPreferredWidth(760);

        tc.setMaxWidth(1500);

        tc.sizeWidthToFit();

     }

     scrollPane.setViewportView(table);

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

     inset = frame1.getInsets();

   }

 

   static void means(String parameter[]) {

      frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

     frame1.setTitle("关联分析                           作者：程学先       ");

     frame1.setBounds(10, 10, variabl1727, variabl1783 + 50);

     frame1.setLayout(null);

     variabl2603 = parameter[4];

     String variabl1325 = parameter[19];

     String variabl2253 = parameter[6];

     if (variabl2253.indexOf(",") > 0)

        variabl2253 = variabl2253.substring(0, variabl2253.indexOf(","));

     String variabl2009 = parameter[8];

     if (variabl2009.indexOf(",") > 0)

        variabl2009 = variabl2009.substring(0, variabl2009.indexOf(","));

     if (variabl2603.indexOf(",") > 0)

        variabl2049 = " where " + parameter[20];

     else

        variabl2049 = "";

     String[] s1 = variabl1325.split(",");

     String[] s2 = variabl2009.split(",");

     variabl1633 = variabl2253;

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

        variabl1633 = variabl1633 + "," + s1[Integer.parseInt(s2[i])];

     variabl2861(variabl2603);

     variabl12531();

     JLabel fl0 = new JLabel("最小支持度");

     frame1.add(fl0);

     fa0 = new JTextField("0.2", 20);

     frame1.add(fa0);

     fl0.setBounds(170, variabl2503 - 70, 70, 20);

     fa0.setBounds(240, variabl2503 - 70, 80, 20);

     fa0.addFocusListener(new FocusAdapter() {

        public void focusGained(final FocusEvent arg0) {

           variabl1739 = 0;

        }

     });

     JLabel fl4 = new JLabel("计算数据");

     frame1.add(fl4);

     jta1 = new JTextArea();

     jta1.setLineWrap(true);

     jta1.setWrapStyleWord(true);

     fl4.setBounds(1000, 10, 300, 20);

     JScrollPane variabl2509 = new JScrollPane(jta1);

     variabl2509.setBounds(710, 30, 600, variabl2503 - 130);

     frame1.add((Component) variabl2509);

     Button2.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           for (double i0 = 0.05; i0 < 0.9; i0 = i0 + 0.05) {

             if (variabl19591 == 0)

                variabl40191(i0);

              else

                break;

           }

           variabl22631 = variabl22631.replaceAll(

                "2项集：3项集：4项集：5项集：6项集：7项集：8项集：9项集：10项集：", "");

           variabl22631 = variabl22631.replaceAll(

                "2项集：3项集：4项集：5项集：6项集：7项集：8项集：9项集：", "");

           variabl22631 = variabl22631.replaceAll(

                "2项集：3项集：4项集：5项集：6项集：7项集：8项集：", "");

           variabl22631 = variabl22631.replaceAll(

                "2项集：3项集：4项集：5项集：6项集：7项集：", "");

           variabl22631 = variabl22631.replaceAll("2项集：3项集：4项集：5项集：6项集：",

                "");

           variabl22631 = variabl22631.replaceAll("2项集：3项集：4项集：5项集：", "");

           variabl22631 = variabl22631.replaceAll("2项集：3项集：4项集：", "");

           variabl22631 = variabl22631.replaceAll("2项集：3项集：", "");

           jta1.setText(variabl22631);

        }

     });

     Button2.setBounds(450, variabl2503 - 70, 140, 20);

     frame1.add(Button2);

 

     Button1.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           String[] s10 = new String[1];

           String variabl1659 = "";

           int k = 0;

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

             s10 = variabl2197[i][1].toString().split(",");

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

                set1.add(s10[j]);

             }

           }

           variabl2061 = set1.size();

           variabl20612 = set1.size();

           variabl2589 = set1.toArray(new String[0]);

           variabl25891 = set1.toArray(new String[0]);

           variabl25892 = set1.toArray(new String[0]);

           int variabl2209[] = new int[variabl2589.length];

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

             for (int j = 0; j < variabl1853; j++) {

                if (("," + variabl2197[j][1] + ",").indexOf(","

                     + variabl2589[i] + ",") >= 0) {

                   variabl2209[i]++;

                }

             }

           String s = "";

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

             for (int j = 0; j < variabl2589.length - i - 1; j++) {

                if (variabl2209[j] < variabl2209[j + 1]) {

                  s = variabl2589[j];

                   k = variabl2209[j];

                   variabl2589[j] = variabl2589[j + 1];

                   variabl2209[j] = variabl2209[j + 1];

                   variabl2589[j + 1] = s;

                   variabl2209[j + 1] = k;

                }

             }

           variabl4017 = Float.parseFloat(fa0.getText()) * variabl2313;

           variabl2263 = "1项集：";

           int variabl20610 = 0;

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

             variabl25892[i] = variabl2589[i];

             if (((variabl2209[i] + 0.0) / variabl1853) >= variabl4017) {

                variabl2263 = variabl2263 + "{" + variabl2589[i] + ":"

                      + variabl2209[i] + "}";

                variabl20610++;

             }

           }

           int[] variabl2673 = new int[1];

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

             s10 = variabl2197[i][1].toString().split(",");

             variabl2197[i][2] = "";

             variabl2673 = new int[s10.length];

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

                s = s10[j];

               for (int i1 = 0; i1 < variabl2589.length; i1++) {

                   if (s.equals(variabl2589[i1])) {

                      variabl2673[j] = i1;

                   }

                }

              }

             Arrays.sort(variabl2673);

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

                if (j < s10.length - 1)

                   variabl2197[i][2] = variabl2197[i][2]

                        + variabl2589[variabl2673[j]] + ",";

                else

                   variabl2197[i][2] = variabl2197[i][2]

                        + variabl2589[variabl2673[j]];

             }

           }

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

             variabl2197[i][1] = variabl2197[i][2];

           }

           model = new DefaultTableModel(variabl2197, variabl2517);

           table = new JTable(model);

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

             TableColumn tc = table.getColumn(variabl2517[i]);

             if (i == 0)

                tc.setPreferredWidth(50);

             else

                tc.setPreferredWidth(760);

           }

           scrollPane.setViewportView(table);

           String[] variabl25890 = new String[variabl20610];

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

             variabl25890[i] = variabl2589[i];

           p1(2, variabl20610, variabl25890);

           jta1.setText(" variabl2263=" + variabl2263);

        }

     });

     Button1.setBounds(330, variabl2503 - 70, 120, 20);

     frame1.add(Button1);

     final JButton Button3 = new JButton("退出");

     Button3.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           frame1.setVisible(false);

           frame1.dispose();

        }

     });

     Button3.setBounds(570, variabl2503 - 70, 120, 20);

     frame1.add(Button3);

     frame1.setVisible(true);

   }

 

  static void p1(int variabl24510, int variabl23130, String[] variabl25895) {

     if (variabl23130 == 0) {

        if (variabl24510 == 2)

           variabl19591 = 1;

        return;

     }

     set1.clear();

     int[] variabl2647 = new int[variabl25892.length * variabl25892.length

           * variabl25892.length];

     String variabl226301 = variabl24510 + "频繁集";

     String variabl258901[] = new String[variabl25892.length

           * variabl25892.length * variabl25892.length];

     int k1 = 0, k2 = 0, k3 = 0;

     String sp[] = null;

     String sp6[] = null;

     String sp1 = "", sp2 = "";

     char x1 = 10, x2 = 13;

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

        if (variabl25895[i].indexOf(",") >= 0) {

           sp = variabl25895[i].split(",");

           sp1 = sp[sp.length - 1];

        } else

           sp1 = variabl25895[i];

        a01: for (int j = 0; j < variabl25892.length; j++) {

           if (variabl25892[j].compareTo(sp1) < 0) {

             sp2 = variabl25895[i] + "," + variabl25892[j];

             k3 = set1.size();

             set1.add(sp2);

             if (set1.size() == k3)

                continue a01;

             variabl2647[k1] = 0;

             for (int i3 = 0; i3 < variabl1853; i3++) {

                k3 = 0;

                sp6 = sp2.split(",");

                for (int i4 = 0; i4 < sp6.length; i4++)

                   if (("," + variabl2197[i3][1] + ",")

                        .indexOf(sp6[i4]) < 0)

                      k3 = 1;

                if (k3 == 0)

                   variabl2647[k1]++;

             }

             if ((variabl2647[k1] + 0.0) / variabl1853 > variabl4017) {

                variabl258901[k1] = sp2;

                k1++;

             }

           }

        }

     }

     k2 = 0;

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

        variabl226301 = variabl226301 + "{" + variabl258901[i4] + ":"

             + variabl2647[i4] + "}";

        k2++;

     }

     variabl2263 = variabl2263 + x1 + x2 + variabl226301;

     p1(variabl24510 + 1, k2, variabl258901);

   }

 

  static void p2(int variabl24510, int variabl23130, String[] variabl25890) {

     int n = 0;

     for (int i = 1; i < variabl23130; i++)

        n = n + i;

     variabl25891 = new String[n];

     int k = 0;

     for (int i = 0; i < variabl23130 - 1; i++)

        for (int j = i + 1; j < variabl23130; j++) {

           variabl25891[k] = variabl25890[i] + "," + variabl25890[j];

           sk = variabl25891[k].split(",");

           set1.removeAll(set1);

           int[] variabl2673 = new int[variabl24510];

           for (int j1 = 0; j1 < sk.length; j1++)

             set1.add(sk[j1]);

           if (set1.size() == variabl24510) {

             sk = set1.toArray(new String[0]);

             for (int j6 = 0; j6 < sk.length; j6++) {

                for (int i7 = 0; i7 < variabl2061; i7++) {

                   if (sk[j6].equals(variabl25892[i7])) {

                      variabl2673[j6] = i7;

                   }

                }

              }

             Arrays.sort(variabl2673);

             variabl25891[k] = "";

             for (int j7 = 0; j7 < sk.length; j7++) {

                if (j7 < sk.length - 1)

                   variabl25891[k] = variabl25891[k]

                        + variabl25892[variabl2673[j7]] + ",";

                else

                   variabl25891[k] = variabl25891[k]

                        + variabl25892[variabl2673[j7]];

             }

             k++;

           }

        }

     set1.removeAll(set1);

     for (int j1 = 0; j1 < k; j1++) {

        set1.add(variabl25891[j1]);

     }

     variabl25891 = set1.toArray(new String[0]);

     k = variabl25891.length;

     for (int j1 = 0; j1 < k; j1++)

        variabl2451 = variabl24510;

     variabl2313 = k;

     variabl23131 = 0;

     variabl23131 = 0;

     k = 0;

     if (variabl2313 > 0)

        variabl2263 = variabl2263 + variabl24510 + "项集：";

     else

        variabl1959 = 1;

     variabl2209 = new int[variabl2313];

     int variabl2559 = 0;

     for (int j = 0; j < variabl2313; j++) {

        variabl23131 = 0;

        sk = variabl25891[j].split(",");

        for (int i1 = 0; i1 < variabl1853; i1++) {

           variabl2559 = 0;

           for (int j1 = 0; j1 < sk.length; j1++) {

             if (("," + variabl2197[i1][1].toString() + ",").indexOf(","

                   + sk[j1] + ",") < 0) {

                variabl2559 = 1;

                break;

             }

           }

           if (variabl2559 == 0)

             variabl23131++;

        }

       if ((variabl23131 + 0.0) / variabl1853 >= variabl4017) {

           if (variabl1959 == 0)

             variabl2263 = variabl2263 + "{" + variabl25891[j] + ":"

                   + variabl23131 + "}";

           variabl2209[j] = variabl23131;

           k++;

        } else {

           variabl25891[j] = "";

        }

     }

     if (variabl1959 == 0)

        variabl2263 = variabl2263 + x1;

     String[] s3 = new String[variabl2313];

     int variabl1821 = 0;

     for (int i2 = 0; i2 < variabl2313; i2++)

        if (variabl25891[i2].length() > 0) {

           s3[variabl1821] = variabl25891[i2];

           variabl1821++;

        }

     variabl25891 = new String[variabl1821];

     for (int i2 = 0; i2 < variabl1821; i2++) {

        variabl25891[i2] = s3[i2];

     }

     if (variabl24510 < variabl2061)

        p2(variabl24510 + 1, variabl1821, variabl25891);

   }

 

   static void variabl2861(String variabl2217) {

     int c = 0;

     int b = 0;

     String s1 = "";

     try {

        cont4 = main1.getConn();

        stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

             ResultSet.CONCUR_UPDATABLE);

        s1 = "select " + variabl1633 + "  from " + variabl2217

             + variabl2049;

        rs = stat4.executeQuery(s1);

        rsmdt4 = rs.getMetaData();

        variabl2651 = rsmdt4.getColumnCount();

        variabl2517 = new String[variabl2651];

        variabl1501 = new String[variabl2651];

        variabl1489 = new int[variabl2651];

        for (int i1 = 0; i1 < variabl2651; i1++) {

           variabl2517[i1] = rsmdt4.getColumnName(i1 + 1);

           variabl1501[i1] = rsmdt4.getColumnTypeName(i1 + 1);

           variabl1489[i1] = rsmdt4.getColumnDisplaySize(i1 + 1);

        }

        rs.last();

        variabl1853 = rs.getRow();

        variabl2197 = new String[variabl1853][variabl2651 + 1];

        variabl21970 = new String[variabl1853][variabl2651 + 1];

        while (c < variabl1853) {

           rs.absolute(c + 1);

           while (b < variabl2651) {

             variabl21970[c][b] = rs.getString(b + 1);

             if ((main1.variabl1545.lastIndexOf("," + variabl1501[b]

                   + ",")) > 0)

                if ((variabl21970[c][b] == null)

                      || (variabl21970[c][b].trim().length() == 0))

                   variabl21970[c][b] = "0";

                else if (variabl21970[c][b] == null)

                   variabl21970[c][b] = "";

             variabl2197[c][b] = variabl21970[c][b];

             b++;

           }

           c++;

           b = 0;

        }

        rs.close();

        stat4.close();

        cont4.close();

     } catch (SQLException e1) {

        JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

     }

   }

}

 

106.源码106，实验程序，仅供参考。读取某一个字段中的数据进行FP树关联分析，绘制FP树图样。

/*

 * 程序文件名：dataMining3.java

 * 作者：程学先

 * 功能：实验程序，读取某一个字段中的数据进行FP树关联分析。

 * 其中每列可有多个数据，各数据间用逗号分隔。

 * 可以单步执行，每一步后显示当前FP树图样，也可以一次执行画出最终FP树图样。

 */

 

import java.awt.BasicStroke;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Insets;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.Arrays;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableColumn;

import javax.swing.table.TableModel;

 

class variabl1189 {

   int variabl2673;

   String variabl2343;

   int variabl2409;

   int variabl2547;

   int variabl1763;

   int variabl2647;

   String variabl1335;

   String variabl3661;

 

   public variabl1189(int variabl2673, String variabl2343, int variabl2409,

        int variabl2547, int variabl1763, int variabl2647,

        String variabl1335, String variabl3661) {

     this.variabl2673 = variabl2673;

     this.variabl2343 = variabl2343;

     this.variabl2409 = variabl2409;

     this.variabl2547 = variabl2547;

     this.variabl1763 = variabl1763;

     this.variabl2647 = variabl2647;

     this.variabl1335 = variabl1335;

     this.variabl3661 = variabl3661;

   }

}

 

public class dataMining3 extends JFrame {

   static dataMining3 frame1 = new dataMining3();

   static int variabl1527;

   static Graphics g;

   static Graphics2D g2;

   static Insets inset;

   private static JTable table;

   static String variabl2603;

   static int variabl2483 = 1400, variabl2503 = 600;

   static int variabl2661 = 100, variabl2657 = variabl2503;

   static int[][][] variabl1921;

   static int variabl26730 = 0;

   static String[] variabl1107;

   static Object[][] variabl2197;

   static String sk[];

   static JTextField fb1;

   static JTextArea fa0;

   static TableModel model;

   static JScrollPane scrollPane;

   static ArrayList<variabl1189> variabl1955 = new ArrayList<variabl1189>();

   static int variabl1887 = 0;

   static int variabl2203 = 0;

   private static Connection cont4;

   private static Statement stat4;

   private static ResultSetMetaData rsmdt4;

   private static ResultSet rs;

   static String[] variabl2517;

   static int variabl1853, variabl2651, variabl1739;

   static String[] variabl1501;

   private static int[] variabl1489;

   private static String[][] variabl21970;

   private static String variabl2049 = "";

   private static String variabl1633 = "";

 

   public static void variabl12531() {

     variabl1489 = new int[2];

     variabl1489[0] = 20;

     variabl1489[1] = 330;

     scrollPane = new JScrollPane();

     scrollPane.setBounds(10, 40, 300, 430);

     model = new DefaultTableModel(variabl2197, variabl2517);

     table = new JTable(model);

     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

      table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

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

        TableColumn tc = table.getColumn(variabl2517[i]);

        tc.setPreferredWidth(variabl1489[i]);

        tc.setMaxWidth(260);

        tc.sizeWidthToFit();

     }

     scrollPane.setViewportView(table);

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

     inset = frame1.getInsets();

   }

 

   static void means(String parameter[]) {

     frame1 = new dataMining3();

      frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

     frame1.setTitle("FP树关联分析                           作者：程学先");

     frame1.setBounds(1000, 10, 350, variabl2503 + 70);

     frame1.setLayout(null);

     JLabel fb0 = new JLabel("纯文本文件名");

     frame1.add(fb0);

     variabl2603 = parameter[4];

     String variabl1325 = parameter[19];

     String variabl2009 = parameter[8];

     if (variabl2009.indexOf(",") > 0)

        variabl2009 = variabl2009.substring(0, variabl2009.indexOf(","));

     if (variabl2603.indexOf(",") > 0)

        variabl2049 = " where " + parameter[20];

     else

        variabl2049 = "";

     String[] s1 = variabl1325.split(",");

     String[] s2 = variabl2009.split(",");

     variabl1633 = "' '" + " as 标志";

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

        variabl1633 = variabl1633 + "," + s1[Integer.parseInt(s2[i])];

     variabl2861(variabl2603);

     String[] sl1, sl2, sl3;

     int[] sl4;

     sl1 = new String[variabl1853];

     sl2 = new String[variabl1853];

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

        sl1[i] = variabl2197[i][1].toString();

     sl4 = new int[200];

     int sl5 = 0;

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

        sl2[i] = sl1[i];

        sl3 = sl2[i].split(",");

        if (sl5 < sl3.length)

           sl5 = sl3.length;

        for (int j = 0; j < sl3.length - 1; j++) {

           if (sl4[j] < sl3[j].length())

             sl4[j] = sl3[j].length();

        }

     }

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

        sl2[i] = sl1[i];

        sl3 = sl2[i].split(",");

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

           for (int k = sl3[j].length(); k < sl4[j]; k++)

             sl3[j] = sl3[j] + " ";

        }

        Arrays.sort(sl3);

        sl2[i] = "";

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

           if (sl2[i].length() == 0)

             sl2[i] = sl3[j];

           else

             sl2[i] = sl2[i] + "," + sl3[j];

        }

     }

     Arrays.sort(sl2);

     variabl2197 = new String[variabl1853][2];

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

        variabl2197[i][0] = " ";

        variabl2197[i][1] = sl2[i];

     }

     variabl2197[0][0] = "→";

     variabl1527 = 0;

     variabl1955.clear();

     variabl26730 = 0;

     variabl1955.add(new variabl1189(variabl26730, "NULL", 0, 0, 0, 0, "",

           ""));

     variabl26730++;

     variabl12531();

     variabl1921 = new int[20][15][2];

     variabl1887 = 0;

     variabl2203 = 0;

     int y1 = 100;

     variabl1921[0][0][0] = 20;

     variabl1107 = new String[20];

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

        variabl1921[i][0][1] = 10 + (20 - i) * (y1 / 20);

        variabl1107[i] = "";

     }

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

        variabl1921[i][0][0] = 50 * (i + 1);

        for (int j = 1; j < 15; j++) {

           variabl1921[i][j][0] = 50 * (i + 1);

           variabl1921[i][j][1] = variabl1921[i][j - 1][1] + 60 + i * 10;

        }

     }

     fb1 = new JTextField("", 20);

     frame1.add(fb1);

     fb0.setBounds(10, 10, 80, 20);

     fb1.setBounds(90, 10, 180, 20);

     fb1.addMouseListener(new MouseAdapter() {

        public void mouseClicked(MouseEvent e) {

           String[] sl1, sl2, sl3;

           int[] sl4;

           sl1 = new String[variabl1853];

           sl2 = new String[variabl1853];

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

             sl1[i] = variabl2197[i][1].toString();

           sl4 = new int[200];

           int sl5 = 0;

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

             sl2[i] = sl1[i];

             sl3 = sl2[i].split(",");

             if (sl5 < sl3.length)

                sl5 = sl3.length;

             for (int j = 0; j < sl3.length - 1; j++) {

                if (sl4[j] < sl3[j].length())

                   sl4[j] = sl3[j].length();

             }

           }

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

             sl2[i] = sl1[i];

             sl3 = sl2[i].split(",");

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

                for (int k = sl3[j].length(); k < sl4[j]; k++)

                   sl3[j] = sl3[j] + " ";

             }

             Arrays.sort(sl3);

             sl2[i] = "";

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

                if (sl2[i].length() == 0)

                   sl2[i] = sl3[j];

                else

                   sl2[i] = sl2[i] + "," + sl3[j];

             }

           }

           Arrays.sort(sl2);

           variabl2197 = new String[variabl1853][2];

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

             variabl2197[i][0] = " ";

             variabl2197[i][1] = sl2[i];

           }

           variabl2197[0][0] = "→";

           variabl1527 = 0;

           variabl1955.clear();

           variabl26730 = 0;

           variabl1955.add(new variabl1189(variabl26730, "NULL", 0, 0, 0,

                0, "", ""));

           variabl26730++;

           variabl12531();

        }

     });

     final JButton Button0 = new JButton("单步显示");

     Button0.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           String[] sk1 = null, sk2 = null;

           String sk3;

           int sk4, sk5, sk6;

           int variabl2393 = 0;

           if (variabl1527 == variabl1853)

             return;

           sk = model.getValueAt(variabl1527, 1).toString().split(",");

           model.setValueAt(" ", variabl1527, 0);

           variabl1527++;

           if (variabl1527 < variabl1853)

             model.setValueAt("→", variabl1527, 0);

           else

             model.setValueAt("", variabl1527 - 1, 0);

           int variabl1255 = 0;

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

             if (variabl1887 < i + 1)

                variabl1887 = i + 1;

             if (("," + variabl1955.get(variabl1255).variabl3661)

                   .indexOf("," + sk[i] + "。") >= 0) {

                sk1 = variabl1955.get(variabl1255).variabl3661

                      .split(sk[i] + "。");

                if (sk1[1].indexOf(",") >= 0)

                   sk4 = Integer.parseInt(sk1[1].substring(0,

                        sk1[1].indexOf(",")));

                else

                   sk4 = Integer.parseInt(sk1[1]);

                variabl1955.get(sk4).variabl2647++;

                variabl1255 = sk4;

             } else if (variabl1955.get(variabl1255).variabl3661

                   .length() == 0) {

                variabl2393 = 0;

                sk5 = variabl1955.get(variabl1255).variabl2547;

                sk6 = variabl1955.get(variabl1255).variabl2673;

                variabl2393 = sk5 + 1;

                sk3 = variabl1955.get(variabl1255).variabl2343;

                if (variabl1107[i + 1].length() > 0)

                   variabl1107[i + 1] = variabl1107[i + 1] + ","

                        + variabl26730;

                else

                   variabl1107[i + 1] = variabl26730 + "";

                variabl1955.add(new variabl1189(variabl26730, sk[i],

                      i + 1, variabl2393, sk6, 1, sk3, ""));

                if (variabl1955.get(variabl1255).variabl3661.length() == 0)

                   variabl1955.get(variabl1255).variabl3661 = sk[i]

                        + "。" + variabl26730;

                else

                   variabl1955.get(variabl1255).variabl3661 = variabl1955

                        .get(variabl1255).variabl3661

                        + ","

                        + sk[i]

                        + "。" + variabl26730;

                variabl1255 = variabl26730;

                variabl26730++;

             } else {

                sk3 = variabl1955.get(variabl1255).variabl2343;

                sk4 = variabl1255;

                sk5 = variabl1955.get(variabl1255).variabl2547;

                sk6 = variabl1955.get(variabl1255).variabl2673;

                sk1 = variabl1955.get(variabl1255).variabl3661

                      .split(",");

                sk2 = sk1[sk1.length - 1].split("。");

                variabl2393 = variabl1955.get(Integer.parseInt(sk2[1])).variabl2547;

               sk1 = (variabl1107[i + 1] + ",k").split(sk2[1] + ",");

                variabl1107[i + 1] = sk1[0] + sk2[1] + ","

                      + variabl26730 + "," + sk1[1];

                sk2 = variabl1107[i + 1].split(",k");

                variabl1107[i + 1] = sk2[0];

                sk2 = sk1[1].split(",");

                for (int k = 0; k < sk2.length - 1; k++) {

                   variabl1955.get(Integer.parseInt(sk2[k])).variabl2547 = variabl1955

                         .get(Integer.parseInt(sk2[k])).variabl2547 + 1;

                }

                if (variabl1955.get(variabl1255).variabl3661.length() == 0)

                   variabl1955.get(variabl1255).variabl3661 = sk[i]

                        + "。" + variabl26730;

                else

                   variabl1955.get(variabl1255).variabl3661 = variabl1955

                        .get(variabl1255).variabl3661

                        + ","

                        + sk[i]

                        + "。" + variabl26730;

                variabl1955.add(new variabl1189(variabl26730, sk[i],

                      i + 1, variabl2393, sk6, 1, sk3, ""));

                variabl1255 = variabl26730;

                variabl26730++;

             }

           }

           for (int i = 1; i <= variabl1887; i++) {

             sk1 = variabl1107[i].split(",");

             int j1 = -1, j2 = 0;

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

                j1++;

                j2 = variabl1955.get(Integer.parseInt(sk1[j])).variabl1763;

                if (j1 < variabl1955.get(j2).variabl2547)

                   j1 = variabl1955.get(j2).variabl2547;

                variabl1955.get(Integer.parseInt(sk1[j])).variabl2547 = j1;

             }

           }

           variabl2203 = 5;

           grap1.grap11();

        }

     });

     Button0.setBounds(10, variabl2503 - 110, 300, 20);

     frame1.add(Button0);

     final JButton Button1 = new JButton("显示完整FP树");

     Button1.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           String[] sk1 = null, sk2 = null;

           String sk3;

           int sk4, sk5, sk6;

           int variabl2393 = 0;

           int i0 = variabl1527;

           for (variabl1527 = i0; variabl1527 < variabl1853; variabl1527++) {

             sk = model.getValueAt(variabl1527, 1).toString().split(",");

             model.setValueAt(" ", variabl1527, 0);

             if (variabl1527 < variabl1853)

                model.setValueAt("→", variabl1527, 0);

             else

                model.setValueAt("", variabl1527 - 1, 0);

             int variabl1255 = 0;

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

                if (variabl1887 < i + 1)

                   variabl1887 = i + 1;

                if (("," + variabl1955.get(variabl1255).variabl3661)

                      .indexOf("," + sk[i] + "。") >= 0) {

                   sk1 = variabl1955.get(variabl1255).variabl3661

                        .split(sk[i] + "。");

                   if (sk1[1].indexOf(",") >= 0)

                      sk4 = Integer.parseInt(sk1[1].substring(0,

                           sk1[1].indexOf(",")));

                   else

                      sk4 = Integer.parseInt(sk1[1]);

                   variabl1955.get(sk4).variabl2647++;

                  variabl1255 = sk4;

                } else if (variabl1955.get(variabl1255).variabl3661

                      .length() == 0) {

                   variabl2393 = 0;

                   sk5 = variabl1955.get(variabl1255).variabl2547;

                   sk6 = variabl1955.get(variabl1255).variabl2673;

                   variabl2393 = sk5 + 1;

                   sk3 = variabl1955.get(variabl1255).variabl2343;

                   if (variabl1107[i + 1].length() > 0)

                      variabl1107[i + 1] = variabl1107[i + 1] + ","

                           + variabl26730;

                   else

                      variabl1107[i + 1] = variabl26730 + "";

                   variabl1955

                       .add(new variabl1189(variabl26730, sk[i],

                             i + 1, variabl2393, sk6, 1, sk3, ""));

                   if (variabl1955.get(variabl1255).variabl3661

                        .length() == 0)

                      variabl1955.get(variabl1255).variabl3661 = sk[i]

                           + "。" + variabl26730;

                   else

                      variabl1955.get(variabl1255).variabl3661 = variabl1955

                           .get(variabl1255).variabl3661

                           + ","

                           + sk[i] + "。" + variabl26730;

                   variabl1255 = variabl26730;

                   variabl26730++;

                } else {

                   sk3 = variabl1955.get(variabl1255).variabl2343;

                   sk4 = variabl1255;

                   sk5 = variabl1955.get(variabl1255).variabl2547;

                   sk6 = variabl1955.get(variabl1255).variabl2673;

                   sk1 = variabl1955.get(variabl1255).variabl3661

                        .split(",");

                   sk2 = sk1[sk1.length - 1].split("。");

                   variabl2393 = variabl1955.get(Integer

                        .parseInt(sk2[1])).variabl2547;

                   sk1 = (variabl1107[i + 1] + ",k").split(sk2[1]

                        + ",");

                   variabl1107[i + 1] = sk1[0] + sk2[1] + ","

                        + variabl26730 + "," + sk1[1];

                   sk2 = variabl1107[i + 1].split(",k");

                   variabl1107[i + 1] = sk2[0];

                   sk2 = sk1[1].split(",");

                   for (int k = 0; k < sk2.length - 1; k++) {

                      variabl1955.get(Integer.parseInt(sk2[k])).variabl2547 = variabl1955

                           .get(Integer.parseInt(sk2[k])).variabl2547 + 1;

                   }

                   if (variabl1955.get(variabl1255).variabl3661

                        .length() == 0)

                      variabl1955.get(variabl1255).variabl3661 = sk[i]

                           + "。" + variabl26730;

                   else

                      variabl1955.get(variabl1255).variabl3661 = variabl1955

                           .get(variabl1255).variabl3661

                           + ","

                           + sk[i] + "。" + variabl26730;

                   variabl1955

                       .add(new variabl1189(variabl26730, sk[i],

                             i + 1, variabl2393, sk6, 1, sk3, ""));

                   variabl1255 = variabl26730;

                   variabl26730++;

                }

             }

             for (int i = 1; i <= variabl1887; i++) {

                sk1 = variabl1107[i].split(",");

                int j1 = -1, j2 = 0;

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

                   j1++;

                   j2 = variabl1955.get(Integer.parseInt(sk1[j])).variabl1763;

                   if (j1 < variabl1955.get(j2).variabl2547)

                      j1 = variabl1955.get(j2).variabl2547;

                   variabl1955.get(Integer.parseInt(sk1[j])).variabl2547 = j1;

                }

             }

           }

           variabl2203 = 5;

           grap1.grap11();

        }

     });

     Button1.setBounds(10, variabl2503 - 70, 300, 20);

     frame1.add(Button1);

 

     final JButton Button2 = new JButton("退出");

     Button2.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {

           frame1.setVisible(false);

           frame1.dispose();

           grap1.frame2.setVisible(false);

           grap1.frame2.dispose();

           System.exit(0);

        }

     });

     Button2.setBounds(10, variabl2503 - 30, 300, 20);

     frame1.add(Button2);

     frame1.setVisible(true);

      grap1.frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

     grap1.frame2.setBounds(10, 30, 980, 650);

     grap1.frame2.setVisible(true);

   }

 

   static void variabl2861(String variabl2217) {

     int c = 0;

     int b = 0;

     String s1 = "";

     try {

        cont4 = main1.getConn();

        stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

             ResultSet.CONCUR_UPDATABLE);

        s1 = "select " + variabl1633 + "  from " + variabl2217

             + variabl2049;

        rs = stat4.executeQuery(s1);

        rsmdt4 = rs.getMetaData();

        variabl2651 = rsmdt4.getColumnCount();

        variabl2517 = new String[variabl2651];

        variabl1501 = new String[variabl2651];

        variabl1489 = new int[variabl2651];

        for (int i1 = 0; i1 < variabl2651; i1++) {

           variabl2517[i1] = rsmdt4.getColumnName(i1 + 1);

           variabl1501[i1] = rsmdt4.getColumnTypeName(i1 + 1);

           variabl1489[i1] = rsmdt4.getColumnDisplaySize(i1 + 1);

        }

        rs.last();

        variabl1853 = rs.getRow();

        variabl2197 = new String[variabl1853][variabl2651];

        variabl21970 = new String[variabl1853][variabl2651];

        while (c < variabl1853) {

           rs.absolute(c + 1);

           while (b < variabl2651) {

             variabl21970[c][b] = rs.getString(b + 1);

             if ((main1.variabl1545.lastIndexOf("," + variabl1501[b]

                   + ",")) > 0)

                if ((variabl21970[c][b] == null)

                      || (variabl21970[c][b].trim().length() == 0))

                   variabl21970[c][b] = "0";

                else if (variabl21970[c][b] == null)

                   variabl21970[c][b] = "";

             variabl2197[c][b] = variabl21970[c][b];

             b++;

           }

           c++;

           b = 0;

        }

        rs.close();

        stat4.close();

        cont4.close();

     } catch (SQLException e1) {

        JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

     }

   }

}

 

class grap1 extends JFrame {

   static grap1 frame2 = new grap1();

   static Graphics g;

   static void grap11() {

     frame2.repaint();

   }

 

   public void paint(Graphics g1) {

     g = g1;

     if (dataMining3.variabl2203 == 0) {

        g1.setColor(Color.WHITE);

        g1.fillRect(0, 0, getWidth(), getHeight());

        g1.setColor(Color.black);

        dataMining3.variabl2203 = 1;

     } else if (dataMining3.variabl2203 == 5) {

        Graphics2D g2 = (Graphics2D) g;

        g2.setStroke(new BasicStroke(2f));

        g1.setColor(Color.WHITE);

        g1.fillRect(0, 0, getWidth(), getHeight());

        h();

        dataMining3.variabl2203 = 1;

     }

   }

 

   public static void h() {

     Graphics2D g2 = (Graphics2D) g;

     g2.setStroke(new BasicStroke(2f));

     g.setColor(Color.BLACK);

     int w1, w2, w3, w4, w5, w01, w02, w03, w04;

     String st1, st2, st3;

     String[] sr1, sr2;

     for (int i = 0; i < dataMining3.variabl1955.size(); i++) {

        w1 = dataMining3.variabl1955.get(i).variabl2409;

        w2 = dataMining3.variabl1955.get(i).variabl2547;

        w01 = dataMining3.variabl1921[w1][w2][1];

        w02 = dataMining3.variabl1921[w1][w2][0];

        w3 = dataMining3.variabl1955.get(i).variabl2647;

        st1 = dataMining3.variabl1955.get(i).variabl2343;

        st2 = dataMining3.variabl1955.get(i).variabl3661;

        g.drawArc(w01, w02, 20, 20, 0, 360);

        g.drawString(st1, w01 - (st1.length() * 15), w02 + 10);

        g.drawString(w3 + "", w01 - ((w3 + "").length() * 15), w02 + 25);

     }

     for (int i = 0; i < dataMining3.variabl1955.size(); i++) {

        w1 = dataMining3.variabl1955.get(i).variabl2409;

        w2 = dataMining3.variabl1955.get(i).variabl2547;

        w01 = dataMining3.variabl1921[w1][w2][1];

        w02 = dataMining3.variabl1921[w1][w2][0];

        st1 = dataMining3.variabl1955.get(i).variabl2343;

        st2 = dataMining3.variabl1955.get(i).variabl3661;

        sr1 = st2.split(",");

        for (int k = 0; k < sr1.length; k++) {

           if (sr1[k].indexOf("。") > 0) {

             sr2 = sr1[k].split("。");

             w4 = dataMining3.variabl1955.get(Integer.parseInt(sr2[1])).variabl2409;

             w5 = dataMining3.variabl1955.get(Integer.parseInt(sr2[1])).variabl2547;

             w03 = dataMining3.variabl1921[w4][w5][1];

             w04 = dataMining3.variabl1921[w4][w5][0];

             g.drawLine(w01 + 10, w02 + 10, w03 + 10, w04 + 10);

           }

        }

     }

   }

  }

 

 

 

 

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

上一篇：管理信息系统软件生产线源码101-103
下一篇：管理信息系统软件生产线源码107-108