博文

管理信息系统软件生产线源码107-108

已有 1661 次阅读 2018-7-14 15:58 |个人分类:生活点滴|系统分类:科研笔记| 软件生产线, 软部件, 数据库, 管理信息系统, JAVA

版本1

107.源码107，实验程序，仅供参考。读取数据表中若干数字数据类型字段的数据进行聚类分析。

* 程序文件名：dataMining4.java

* 作者：程学先

* 功能：实验程序，读取数据表中若干数字数据类型字段的数据进行聚类分析。

* 可分析2聚类、三聚类、多聚类

* 其中每条记录可以为一列到多列数据。如果为一或二列数据，可以显示点的分布图。

* 必须输入的参数：表名、字段号表

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.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.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.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableColumn;

import javax.swing.table.TableModel;

public class dataMining4 extends JFrame {

static dataMining4 frame1 = new dataMining4();

static double[] 纵向数据;

static double[] 横向数据;

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

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

static int 窗口宽度 = 1200, 窗口高度 = 660;

static int 序号0;

static int[] 记录条数n = null;

static Graphics g;

static Graphics2D g2;

static Insets inset;

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

private static JTable table;

static String 表名;

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

static String[] sk;

static int 窗口宽 = 1300, 窗口高 = 700, 记录数 = 0, 元素个数 = 0;

static String[] 记录1;

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

static String[] 列数据类型;

static double[][] 中心位置 = new double[20][2];

static String[] 中心位置0 = new String[20];

static int 迭代次数 = 20, 标志 = 0;

static int 预期分类数 = 2;

static int[] 类项数 = null, 类项数0 = null;

static String[][] 表格数据;

static String[][] 表格数据m; // i,0存放原始数据

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

static HashSet<String> set1 = new HashSet<String>(); // 建立集合

static TableModel model;

static JScrollPane scrollPane = new JScrollPane();

static JButton Button1, Button2, Button3, Button5;

private static Connection cont4;

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

static String[] 列名;

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

private static int[] 列数据宽度;

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

private static String 连接条件 = "";

private static String 字段名表 = "";

public static void 求新中心值() {

String[] d03 = null;

double d01[][];

for (int i = 1; i < 预期分类数 + 1; i++) { // 求每一类（i+1列）中心)

中心位置0[i] = "";

d01 = new double[预期分类数 + 1][元素个数];

for (int j = 0; j < 类项数[i]; j++) { // 对每一类（列）每一行（j）数据先分解

d03 = 表格数据[j][i].split(",");// 取某类一个数分解

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

d01[i][j1] = d01[i][j1] + Double.parseDouble(d03[j1]); // 某一类数据对应某一维数据

}

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

if (j1 == 0)

中心位置0[i] = d01[i][j1] / 类项数[i] + "";

else

中心位置0[i] = 中心位置0[i] + "," + d01[i][j1] / 类项数[i] + "";

}

public static void 按中心分类() {

double[][] d01 = new double[20][预期分类数 + 1]; // 中心位置分解

double[] d02 = new double[预期分类数 + 1]; // 任意一个数据分解

String[] d03 = new String[预期分类数 + 1]; // 临时变量数组

double[] x = new double[预期分类数 + 1];

for (int i = 0; i < 预期分类数 + 1; i++) { // 记录分类前每组元素个数

x[i] = 类项数[i];

类项数[i] = 0;

}

for (int i = 1; i < 预期分类数 + 1; i++) { // 中心位置分解)

d03 = 中心位置0[i].split(",");

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

d01[j][i] = Double.parseDouble(d03[j]);

}

for (int i = 0; i < 记录条数; i++) { // 清表格数

for (int j = 1; j < 预期分类数 + 1; j++) {

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

}

int k0 = 0, k1 = 0;

double x1 = 0, x0 = 0;

for (int i = 0; i < 记录条数; i++) { // 将每一个数据放到某一列去

x1 = 0;

x0 = 0;

k1 = 0;

d03 = 表格数据m[i][0].split(",");// 取一个数分解

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

d02[j1] = Double.parseDouble(d03[j1]); // 变为双精度类型

for (int j = 1; j < 预期分类数 + 1; j++) {

x1 = 0;

for (int j2 = 0; j2 < d02.length; j2++) { // 求每一值的每一元素与中心的差的平方和

if (j2 == 0)

x1 = (d02[j2] - d01[j2][j]) * (d02[j2] - d01[j2][j]);

else {

x1 = x1 + (d02[j2] - d01[j2][j])

* (d02[j2] - d01[j2][j]);

}

if (j == 1) {

x0 = x1; // 最小平方和

k1 = 1; // 最小平方和的项号

} else {

if (x1 < x0) {

x0 = x1;

k1 = j; // 类号，决定在那一列

}

表格数据[类项数[k1]][k1] = 表格数据m[i][0]; // 加到相应类中

类项数[k1]++; // 加到相应类的新行中，类项数[i]为行号

}

k0 = 0;

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

if (x[i] != 类项数[i])

k0 = 1;

if (k0 == 0) {

Button1.setVisible(false);

Button2.setVisible(false);

标志 = 1;

return;

}

static void means(String parameter[]) {

frame1 = new dataMining4();

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.setTitle("聚类分析作者：程学先");

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

frame1.setLayout(null);

窗口宽 = 1300;

窗口高 = 700;

set1 = new HashSet<String>(); // 建立集合

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

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

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

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

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

else

连接条件 = "";

if (项目数据.trim().length() > 0) {

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

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

字段名表 = "";

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

if (i == 0)

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

else

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

} else

字段名表 = 字段名字串;

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

元素个数 = 列数;

预期分类数 = 2;

JLabel fl0 = new JLabel("预期分类数");

frame1.add(fl0);

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

frame1.add(fa0);

fl0.setBounds(10, 10, 80, 20);

fa0.setBounds(90, 10, 60, 20);

Button5 = new JButton("更新表格");

Button5.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

Button1.setVisible(true);

Button2.setVisible(true);

标志 = 0;

序号0 = 0;

fa1.setText("1");

预期分类数 = Integer.parseInt(fa0.getText());

表格数据 = new String[记录条数][预期分类数 + 1]; // 重定义表格数据

类项数 = new int[预期分类数 + 1];

int x0 = 列数据宽度[0];

列数据宽度 = new int[预期分类数 + 1];

列数据宽度[0] = x0;

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

表格数据[i][0] = 表格数据m[i][0]; // 还原老的表格数据

for (int j = 1; j < 预期分类数 + 1; j++) {

表格数据[i][j] = ""; // 除第一列外清空其他各列

}

列名 = new String[预期分类数 + 1]; // 定义列名数组

列名[0] = "原始数据";

for (int i = 1; i < 预期分类数 + 1; i++) {

列名[i] = "第" + i + "类数据";

}

for (int i = 1; i < 预期分类数 + 1; i++)

列数据宽度[i] = 列数据宽度[0];

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

table = new JTable(model);

table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

for (int i = 0; i < 预期分类数 + 1; i++) {

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

tc.setPreferredWidth(列数据宽度[i] * 12); // 设置表格中各列的宽度

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

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

}

});

Button5.setBounds(160, 10, 120, 20);

frame1.add(Button5);

Button5.setVisible(false);

fa0.addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {

Button5.setVisible(true);

当前列号 = 0;

}

});

JLabel fl1 = new JLabel("迭代次数");

frame1.add(fl1);

fa1 = new JTextField("1", 20);

frame1.add(fa1);

fl1.setBounds(340, 10, 80, 20);

fa1.setBounds(420, 10, 80, 20);

fa1.addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {

当前列号 = 0;

}

});

Button1 = new JButton("单步");

Button1.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (标志 == 1)

return;

迭代次数 = Integer.parseInt(fa1.getText());

预期分类数 = Integer.parseInt(fa0.getText());

int[] kd = new int[预期分类数 + 1];

int i1 = 0;

if (序号0 == 0) { // 第一次划分中心，中心数据为前（预期分类数）个数据

中心位置0 = new String[预期分类数 + 1];

类项数 = new int[预期分类数 + 1];

类项数0 = new int[预期分类数 + 1];

String[] 中心位置1 = new String[预期分类数 + 1];

表格数据 = new String[记录条数][预期分类数 + 1]; // 重定义表格数据

for (i1 = 0; i1 < 预期分类数; i1++) {

中心位置0[i1 + 1] = 表格数据m[i1][0];

表格数据[0][i1 + 1] = 表格数据m[i1][0];

类项数[i1 + 1] = 1;

}

i1 = 1;

for (int i = 预期分类数; i < 记录条数; i++) {

表格数据[i1][预期分类数] = 表格数据m[i][0];

类项数[预期分类数]++;

i1++;

}

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

table = new JTable(model);

table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

for (int i = 0; i < 预期分类数 + 1; i++) {

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

tc.setPreferredWidth(列数据宽度[i] * 12); // 设置表格中各列的宽度

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

迭代次数 = 迭代次数 + 1;

fa1.setText(迭代次数 + "");

序号0++;

calc05.frame2.setVisible(false);

return;

}

按中心分类();

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

table = new JTable(model);

table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

for (int i = 0; i < 预期分类数 + 1; i++) {

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

tc.setPreferredWidth(列数据宽度[i] * 12); // 设置表格中各列的宽度

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

迭代次数 = 迭代次数 + 1;

序号0++;

fa1.setText(迭代次数 + "");

求新中心值();

calc05.frame2.setVisible(false);

}

});

Button1.setBounds(510, 10, 120, 20);

frame1.add(Button1);

Button2 = new JButton("完成迭代");

Button2.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

迭代次数 = Integer.parseInt(fa1.getText());

迭代次数 = 0;

标志 = 0;

预期分类数 = Integer.parseInt(fa0.getText());

中心位置0 = new String[预期分类数 + 1];

类项数 = new int[预期分类数 + 1];

类项数0 = new int[预期分类数 + 1];

表格数据 = new String[记录条数][预期分类数 + 1]; // 重定义表格数据

int i1 = 0;

if (序号0 == 0) { // 第一次划分中心，中心数据为前（预期分类数）个数据

for (i1 = 0; i1 < 预期分类数; i1++) {

中心位置0[i1 + 1] = 表格数据m[i1][0];

表格数据[0][i1 + 1] = 表格数据m[i1][0];

类项数[i1 + 1] = 1;

}

i1 = 1;

for (int i = 预期分类数; i < 记录条数; i++) {

表格数据[i1][预期分类数] = 表格数据m[i][0];

类项数[预期分类数]++;

i1++;

}

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

table = new JTable(model);

table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

for (int i = 0; i < 预期分类数 + 1; i++) {

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

tc.setPreferredWidth(列数据宽度[i] * 12); // 设置表格中各列的宽度

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

迭代次数 = 迭代次数 + 1;

fa1.setText(迭代次数 + "");

序号0++;

calc05.frame2.setVisible(false);

}

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

表格数据[i][0] = 表格数据m[i][0];

while (标志 == 0) {

按中心分类();

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

table = new JTable(model);

table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

for (int i = 0; i < 预期分类数 + 1; i++) {

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

tc.setPreferredWidth(列数据宽度[i] * 12); // 设置表格中各列的宽度

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

迭代次数 = 迭代次数 + 1;

序号0++;

fa1.setText(迭代次数 + "");

求新中心值();

calc05.frame2.setVisible(false);

迭代次数++;

fa1.setText(迭代次数 + "");

if (标志 != 0)

break;

}

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

table = new JTable(model);

table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

for (int i = 0; i < 预期分类数 + 1; i++) {

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

tc.setPreferredWidth(列数据宽度[i] * 12); // 设置表格中各列的宽度

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

calc05.frame2.setVisible(false);

}

});

Button2.setBounds(630, 10, 120, 20);

frame1.add(Button2);

Button3 = new JButton("显示图形");

Button3.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

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

int b = 0;

记录条数n = new int[预期分类数 + 1];

String[][] sg = new String[记录条数][预期分类数 + 1];

for (int i = 1; i < 预期分类数 + 1; i++) {

for (int j = 0; j < 类项数[i]; j++) {

sg[b] = 表格数据[j][i].split(","); // 取相应类一个数据

横向数据[b] = Double.parseDouble(sg[b][0]);

if (元素个数 > 1)

纵向数据[b] = Double.parseDouble(sg[b][1]);

b++;

}

记录条数n[i] = b - 1;

}

calc05.calc011(); // 绘图

}

});

Button3.setBounds(750, 10, 120, 20);

frame1.add(Button3);

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

Button4.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

calc05.frame2.setVisible(false);

calc05.frame2.dispose();

frame1.setVisible(false);

frame1.dispose();

System.exit(0);

}

});

Button4.setBounds(870, 10, 120, 20);

frame1.add(Button4);

set1.clear();

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

String s0 = "";

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

if (j == 0)

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

else

s0 = s0 + "," + 表格数据[i][j];

}

set1.add(s0); // 去掉重复值

}

记录数 = 记录条数;

记录条数 = set1.size();

Object[] s10 = set1.toArray();

表格数据 = new String[记录条数][预期分类数 + 1]; // 重定义表格数据

表格数据0 = new String[记录条数][元素个数];

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

表格数据[i][0] = s10[i].toString();

for (int j = 1; j < 预期分类数 + 1; j++)

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

}

表格数据m = new String[记录条数][预期分类数 + 1];

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

for (int j = 0; j < 预期分类数 + 1; j++)

表格数据m[i][j] = 表格数据[i][j]; // 保存老的表格数据

列数据宽度 = new int[预期分类数 + 1];

列名 = new String[预期分类数 + 1]; // 定义列名数组

列名[0] = "原始数据";

类项数 = new int[预期分类数 + 1];

for (int i = 1; i < 预期分类数 + 1; i++) {

列名[i] = "第" + i + "类数据";

}

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

String sk0 = "";

String[] sk;

for (int i = 0; i < 记录条数; i++) { // 以下统一每个数据数据元素个数

sk = 表格数据[i][0].split(","); // 再取一个原始数据，可1、2、多维，逗号分隔

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

表格数据0[i][j] = sk[j]; // 表格数据0为表格数据按维展开数

}

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

if (列数据宽度[0] < 表格数据[i][0].trim().length())

列数据宽度[0] = 表格数据[i][0].trim().length();

}

for (int i = 1; i < 预期分类数 + 1; i++)

列数据宽度[i] = 列数据宽度[0];

标志 = 0;

fa1.setText("1");

if (元素个数 < 3)

Button3.setVisible(true);

else

Button3.setVisible(false);

scrollPane.setVisible(false);

scrollPane = new JScrollPane();

scrollPane.setBounds(10, 40, 窗口宽 - 60, 窗口高 - 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 < 预期分类数 + 1; i++) {

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

tc.setPreferredWidth(列数据宽度[i] * 12); // 设置表格中各列的宽度

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

类项数 = new int[预期分类数 + 1];

类项数0 = new int[预期分类数 + 1];

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

inset = frame1.getInsets();

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

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

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

while (c < 记录条数) {

rs.absolute(c + 1);

while (b < 列数) {

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

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

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

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

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

else

表格数据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 calc05 extends JFrame {

private static final long serialVersionUID = 1L;

static calc05 frame2 = new calc05();

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 yyy;

static double xxx;

static double[] yyy1;

static double[] xxx1;

static int[] 记录条数n1;

static int 预期分类数, 元素个数;

static double[][] 中心位置 = new double[20][2];

static String[] 中心位置0 = new String[20];

static void calc011() {

calc05 frame2 = new calc05();

frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

记录条数 = dataMining4.记录条数;

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

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

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

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

元素个数 = dataMining4.元素个数;

记录条数n1 = new int[dataMining4.预期分类数 + 1];

预期分类数 = dataMining4.预期分类数;

纵向分段数 = 20;

横向分段数 = 10;

中心位置 = new double[20][2];

中心位置0 = new String[20];

for (int i = 1; i < 预期分类数 + 1; i++) {

中心位置0[i] = dataMining4.中心位置0[i];

}

int h = 10;

if (元素个数 > 1) {

窗口宽度 = 1200;

窗口高度 = 700;

} else {

窗口宽度 = 1200;

窗口高度 = 220;

h = 550;

}

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

frame2.setVisible(true);

}

public void paint(Graphics g1) {

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

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

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

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

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

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

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

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

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

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

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

}

记录条数n1 = new int[预期分类数 + 1];

for (int i = 1; i < 预期分类数 + 1; i++) {

记录条数n1[i] = dataMining4.记录条数n[i];

}

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

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

g = g1;

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

}

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

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

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

if (纵向最大值 - 纵向最小值 != 0) {

纵向坐标单位数据 = (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] + (横向最大值 - 横向最小值) / 横向分段数;

}

Graphics2D g2 = (Graphics2D) g;

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

if (元素个数 > 1) {

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

double x2, y2, z1;

int x = 0, y = 0;

String z0;

g.setColor(Color.RED);

if (元素个数 > 1)

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("第1类数据", 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);

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); // 横向单位点短线

}

String sg[];

double sh[][] = new double[预期分类数 + 1][2];

xxx1 = new double[预期分类数 + 1];

yyy1 = new double[预期分类数 + 1];

for (int j = 1; j < 预期分类数 + 1; j++) {

sg = 中心位置0[j].split(",");

sh[j][0] = Double.parseDouble(sg[0]);

if (sg.length > 1) {

sh[j][1] = Double.parseDouble(sg[1]);

}

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

yyy1[j] = (sh[j][1] - 纵向最小值) * 纵向单位数据长度;

yyy1[j] = 可用高度 + Y线到顶距 - yyy1[j];

g.setColor(Color.CYAN);

g.fillOval((int) xxx1[j], (int) yyy1[j] - 15, w0 + 30, h0 + 30); // 打所有测试数据坐标点，打圆点

g.setColor(Color.BLACK);

}

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

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

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

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

for (int j = 1; j < 预期分类数 + 1; j++) { // 变色

if ((i > 0) && (记录条数n1[j] == i - 1)) {

if (j / 2 == (j / 2.0)) {

g.setColor(Color.RED);

} else {

g.setColor(Color.BLACK);

}

g.fillOval((int) xxx, (int) yyy - 5, w0 + 10, h0 + 10); // 打所有测试数据坐标点，打圆点

}

g.setColor(Color.RED);

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

xxx1 = 横向最小值;

变量数 = 1;

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

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

int 递增系数 = 200;

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

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

xxx2 = xxx;

yyy2 = yyy;

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

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

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

xxx1 = xxx2;

yyy1 = yyy2;

yyy3 = yyy;

}

108.源码108，实验程序，仅供参考。读取数据表中的若干个字段数据进行条件熵绘制决策树。

* 程序文件名：dataMining5.java

* 作者：程学先

* 程序功能：读取数据表中的若干个字段数据进行条件熵绘制决策树。

* 必须输入的参数：表名、类属性、描述属性，其中类属性限单字段，其值限为是、否

* 描述属性可以为多个，其值均为有限离散型数据。

* 例如：某数据表中数据:

* 年龄输入层次学生信用等级是否购买电脑

* 青少年高否一般否

* 青少年高否良好否

* 中年高否一般是

* 老年中否一般是

* 老年低是一般是

* 老年低是良好否

* 中年低是良好是

* 青少年中否一般否

* 青少年低是一般是

* 老年中是一般是

* 青少年中是良好是

* 中年中否良好是

* 中年高是一般是

* 老年中否良好否

* ………………

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

class 存储结构I3

{

int 序号;

String 元素名;

int 层次号;

int 列号;

int 上级序号;

int 上级层次号;

String 上级节点名;

String 下级节点号;

String 显示;

int 表格号;

public 存储结构I3(int 序号,String 元素名,int 层次号,int 列号,int 上级序号,

int 上级层次号,String 上级节点名,String 下级节点号,String 显示,int 表格号)

{

this.序号=序号;

this.元素名=元素名;

this.层次号=层次号;

this.列号=列号;

this.上级序号=上级序号;

this.上级层次号=上级层次号;

this.上级节点名=上级节点名;

this.下级节点号=下级节点号; //下级节点序号集

this.显示=显示;

this.表格号=表格号;

}

public class dataMining5 extends JFrame {

static dataMining5 frame1=new dataMining5();

static String [] 列名;

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

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

static Graphics g;

static Graphics2D g2;

static Insets inset;

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

private static JTable table;

static String 表名;

static int 窗口宽=1400,窗口高=600,记录数=0;

static String[] 记录1;

static int 表格列数=2;

static String [] 表格列名;

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

static String[] 列数据类型;

static int[] 列宽=new int[2];

static Object[][] 表格数据;

static Object[][][] 表格数据集;

static JTextField fb1,fc1;

static JTextArea fa0;

static HashSet<String> set1 = new HashSet<String>(); //建立类属性集合

static HashSet<String> set2 = new HashSet<String>(); //建立描述属性集合

static TableModel model;

static JScrollPane scrollPane;

static int [][][] 位置参数;

static int 序号0=0;

static ArrayList<存储结构I3> 存储数据=new ArrayList<存储结构I3>();

static int [] 每层列号; //每层最后一个列号;

static int [][] 表层对应; //0:表号,1:层号,2:上级号,3:记录条数,4:表格列数

static int 层号=0,列号0=0,上级号=0,上级层号=0;

static String 上级名="";

static String [] 上级节点名称,列名集合;

static int 表顺序号=0,最大表号=0; //表号用于迭代识别保存的表，最大表号记录迭代结束信号

static int 新表号=0; //将表格数据存到表格数据集中后，根据本号逐一单步运行

static String [] 子集名称;

static int 开始运行=0;

private static Connection cont4;

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

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

static String 类属性名称;

private static String 连接条件 = "";

private static String 字段名表 = "";

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

记录条数 = 记录数;

表格列数 = 列宽.length;

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

scrollPane = new JScrollPane();

scrollPane.setBounds(810,40,400,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<表格列数;i++) {

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

if (列宽[i]<表格列名[i].length()) 列宽[i]=表格列名[i].length();

tc.setPreferredWidth(列宽[i]*15); //设置表格中各列的宽度

tc.setMaxWidth(1000);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

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

inset = frame1.getInsets();

}

public static void means(String [] parameter) {

frame1=new dataMining5();

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.setTitle("ID3条件熵计算程序作者：程学先");

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

frame1.setLayout(null);

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

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

String 类属性名称 = parameter[9]; // 限一个字段号

if (类属性名称.indexOf(",")>0)

类属性名称=类属性名称.substring(0,类属性名称.indexOf(","));

String 项目数据 = parameter[8]+","+类属性名称;

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

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

else 连接条件="";

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

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

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

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

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

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

显示数据表格1();

序号0=0;

位置参数=new int [15][15][2];

位置参数[0][0][0]=15; //根到顶距

int y1=200;

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

位置参数[i][0][1]=10+(15-i)*(y1/15); //第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元素左边距

}

表格数据集=new Object[100][][];

每层列号=new int[100];

表层对应=new int[100][5];

上级节点名称=new String [100];

列名集合=new String [100];

子集名称=new String [100];

最大表号=1;

JLabel fl1=new JLabel("子集名称");

fl1.setBounds(310,40,60, 20);

frame1.add(fl1);

fc1 = new JTextField(" 全集 ");

fc1.setBounds(370,40,280, 20);

frame1.add(fc1);

JLabel fl0=new JLabel("条件熵计算式与计算值");

frame1.add(fl0);

fa0 = new JTextArea("");

frame1.add(fa0);

fl0.setBounds(10,40,300, 20);

fa0.setBounds(10,70,800,430);

fa0.addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {

当前列号=0;

}

});

final JButton Button0 = new JButton("单步");

Button0.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if ((序号0>0)&&(最大表号<=新表号+1)) {

fc1.setText("迭代结束，请查看图形！");

return;

}

String 列名集="",子集名="";

if (序号0==0){

层号=0;列号0=0;上级号=-1;上级名="";上级层号=-1;表顺序号=0;新表号=0;

表格数据集[表顺序号]=new Object[记录条数][表格列数]; // 保存当前数据表数据

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

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

表格数据集[表顺序号][i][j]=表格数据[i][j]; // 保存当前数据表数据

每层列号[层号]=列号0;

表层对应[表顺序号][0]=表顺序号;

表层对应[表顺序号][1]=层号;

表层对应[表顺序号][2]=上级号;

表层对应[表顺序号][3]=记录条数;

表层对应[表顺序号][4]=表格列数;//以上记录为第一次求根的结果

表格数据集[表顺序号]=new Object[记录条数][表格列数]; // 保存当前数据表数据

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

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

表格数据集[表顺序号][i][j]=表格数据[i][j]; // 保存当前数据表数据

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

if (列名集.length()==0) 列名集=表格列名[j];

else 列名集=列名集+","+表格列名[j];

}

上级节点名称[表顺序号]="";

列名集合[表顺序号]=列名集;

}

else { //以下逐一处理每一个子表

新表号++;

层号=表层对应[新表号][1];

上级号=表层对应[新表号][2];

记录条数=表层对应[新表号][3];

表格列数=表层对应[新表号][4];

上级层号=层号-1;

上级名=上级节点名称[新表号];

列名集=列名集合[新表号];

子集名=子集名称[新表号];

fc1.setText(子集名);

}

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

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

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

表格数据[i][j]=表格数据集[新表号][i][j];

}

if (序号0>0){

表格列名=列名集.split(",");

scrollPane = new JScrollPane();

scrollPane.setBounds(810,40,400,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<表格列数;i++) {

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

tc.setPreferredWidth(表格列名[i].length()*20); //设置表格中各列的宽度列宽[i]

tc.setMaxWidth(1000);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

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

inset = frame1.getInsets();

}

if (最大表号<=新表号) return;

数据分析(表格数据,记录条数,表格列数,层号,列号0,上级号,上级层号,上级名,新表号,列名集,子集名);

}

});

Button0.setBounds(850,窗口高-110,300, 20);

frame1.add(Button0);

final JButton Button1 = new JButton("绘图");

Button1.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

开始运行=5;

id3grap1.frame2.setVisible(true);

id3grap1.id3grap1();

}

});

Button1.setBounds(850,窗口高-80,300, 20);

frame1.add(Button1);

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

Button2.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

frame1.setVisible(false);

frame1.dispose();

id3grap1.frame2.setVisible(false);

id3grap1.frame2.dispose();

System.exit(0);

}

});

Button2.setBounds(850,窗口高-50,300, 20);

frame1.add(Button2);

id3grap1.frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

id3grap1.frame2.setBounds(10,30,800,650);

id3grap1.frame2.setVisible(true);

frame1.setVisible(true);

}

public static void 数据分析(Object [][] 表格数据,int 记录条数,int 表格列数,int 层号,

int 列号0,int 上级号,int 上级层号,String 上级名,int 表号0,String 列名集,String 子集名){

double 计算值=0;

if ((记录条数==0)||(表格列数<=1)) return;

double 最小值=1;

String 最小属性="";

String 类属性名称="";

String [] s10=null;

set1.removeAll(set1);

String []s1=null; //存放类属性数据，去掉重复值

String []s2=null; //存放某一个描述属性数据，去掉重复值

int [] t1=null; //存放类属性某数据重复个数

int [] t2=null; //存放某一个描述属性某数据重复个数

int [][] t20=null; //存放某一个描述属性某属性值数据重复个数

String 显示内容="";

String 显示内容1="";

int 类属性个数=0,描述属性个数=0;

char x1=10,x2=13;

表格列名=列名集.split(",");

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

set2.removeAll(set2); //描述属性

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

if (i==0) {

set1.add(表格数据[j][表格列数-1].toString()); //类属性

类属性名称=表格数据[j][表格列数-1].toString();

}

if (j>0){

set2.add(表格数据[j-1][i].toString());//第i列数据置入

}

if (i==0) {

类属性个数=set1.size();

s1=new String[类属性个数];

s1=set1.toArray(new String[0]); //还原为数组

t1=new int[类属性个数];

}

描述属性个数=set2.size();

s2=new String[描述属性个数];

s2=set2.toArray(new String[0]);

t2=new int[描述属性个数];

t20=new int[描述属性个数][类属性个数];

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

for (int k=0;k<类属性个数;k++){

if ((i==0)&&(s1[k].equals(表格数据[j][表格列数-1]))){

t1[k]++; //存放类属性某数据重复个数

}

for (int k=0;k<描述属性个数;k++){

if (s2[k].equals(表格数据[j][i])){

t2[k]++; //存放描述属性某数据重复个数

for (int k1=0;k1<类属性个数;k1++){

if (s1[k1].equals(表格数据[j][表格列数-1])){

t20[k][k1]++; //存放某一个描述属性某属性值数据重复个数

}

显示内容=显示内容+表格列名[i]+"条件熵=";

int k1=0,k=0;

double [] 对数值=new double[类属性个数];

double [] 计算值0=new double[描述属性个数];

double [] 计算值1=new double[类属性个数];

double 计算值2=0;

double 值=0;

for (k=0;k<描述属性个数;k++){

显示内容=显示内容+"-"+t2[k]+"/"+记录条数+"*( ";

显示内容1=显示内容1+"+"+t2[k]+"/"+记录条数+"*( ";

计算值0[k]=t2[k]/记录条数;

计算值=0;

double x=0;

for (k1=0;k1<类属性个数;k1++){

显示内容=显示内容+t20[k][k1]+"/"+t2[k]+"*ln( ";

显示内容1=显示内容1+t20[k][k1]+"/"+t2[k]+"*";

x=(t20[k][k1]+0.0000)/t2[k];

if (x<0.001) x=0.001;

对数值[k1]=-(Math.log10(x)/Math.log10(2)) ;

显示内容=显示内容+t20[k][k1]+"/"+t2[k]+" )";

显示内容1=显示内容1+(对数值[k1]+" ").substring(0,8);

if (k1<类属性个数-1) 显示内容1=显示内容1+"+";

计算值1[k1]=对数值[k1]*x;

计算值=计算值+计算值1[k1];

if (k1<类属性个数-1) 显示内容=显示内容+"+";

}

显示内容=显示内容+" )";

显示内容1=显示内容1+" )";

计算值2=计算值2+计算值*t2[k]/记录条数;

值=值+计算值*t2[k]/记录条数;

}

显示内容=显示内容+" )"+x1+x2+" =";

显示内容1=显示内容1+" )"+x1+x2+" =";

显示内容=显示内容+显示内容1+值+x1+x2;

if (值<最小值){

最小值=值;

最小属性=表格列名[i];

}

值=0;

}

显示内容=显示内容+x1+x2+"比较上述数据，可见"+最小属性+"的条件熵最小，其值为："+ 最小值+"。选为下一级的根。";

fa0.setText( 显示内容);

最小属性=最小属性.replaceAll(" ",""); //去掉空格

if (上级号>=0){

if (存储数据.get(上级号).下级节点号.length()==0) 存储数据.get(上级号).下级节点号=序号0+"";

else 存储数据.get(上级号).下级节点号=存储数据.get(上级号).下级节点号+","+序号0;

}

if (计算值!=0){

存储数据.add(new 存储结构I3(序号0,最小属性,层号,列号0,上级号, //列号0:列号,上级号:上级序号

上级层号,上级名,"",显示内容,表号0)); // 保存每个节点数据准备护画图 ;上级层号:上级层次号,上级名:上级节点名

层号++;上级号=序号0;

序号0++;

表格列数--;

String [] sl1=列名集.split(",");

列名集="";

String 序号集="";

int h0=0;

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

if (sl1[i].equals(最小属性)) {

h0=i; //最小属性所在列号

continue;

}

if (列名集.length()==0) {

列名集=sl1[i];

序号集=i+"";

}

else {

列名集=列名集+","+sl1[i];

序号集=序号集+","+i;

}

set1.removeAll(set1);

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

set1.add(表格数据[i][h0].toString());

String [] sj0=set1.toArray(new String[0]); //还原为数组

Object [][] sj=new Object[100][表格列数];

int sj1=0,sj2=0,sj3=0;

String sj4="";

for (int i=0;i<set1.size();i++) { //根据最小属性的值分组

sj2=0;

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

if (! sj0[i].equals(表格数据[j][h0])) continue;

sj3=0;

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

if (k!=h0) {

sj[sj2][sj3]=表格数据[j][k];

sj3++;

}

sj2++;

}

表顺序号++;

表格数据集[表顺序号]=new Object[sj2][表格列数]; // 保存当前数据表数据

for (int i1=0;i1<sj2;i1++)

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

表格数据集[表顺序号][i1][j]=sj[i1][j]; // 保存当前数据表数据

每层列号[层号]=列号0;

表层对应[表顺序号][0]=表顺序号;

表层对应[表顺序号][1]=层号;

表层对应[表顺序号][2]=上级号;

表层对应[表顺序号][3]=sj2;

表层对应[表顺序号][4]=表格列数;

最大表号++;

上级节点名称[表顺序号]=最小属性;

列名集合[表顺序号]=列名集;

子集名称[表顺序号]=子集名+sj0[i];

}

else {

fa0.setText("本"+子集名+"子集决策数据相同，分枝结束！");

存储数据.add(new 存储结构I3(序号0,子集名,层号,列号0,上级号, //列号0:列号,上级号:上级序号

上级层号,类属性名称,"","本"+子集名+"子集决策数据相同，分枝结束！",-1)); // 保存每个节点数据准备画图 ;上级层号:上级层次号,上级名:上级节点名上级名

序号0++;

}

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

记录1=new String[记录条数];

记录数=记录条数;

char x6='"';

表格数据 = 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 id3grap1 extends JFrame {

static id3grap1 frame2=new id3grap1();

static Graphics g;

static void id3grap1() {

frame2.repaint();

}

public void paint(Graphics g1) {

g=g1;

if (dataMining5.开始运行==0){

g1.setColor(Color.WHITE);// 将画笔颜色设置成白色

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

g1.setColor(Color.black);// 将画笔颜色设置成黑色

dataMining5.开始运行=1;

}

else if (dataMining5.开始运行==5){

Graphics2D g2=(Graphics2D)g;

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

g1.setColor(Color.WHITE);// 将画笔颜色设置成白色

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

//以下画纵向坐标线包括箭头、坐标名称

h();

dataMining5.开始运行=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;

int 最大层次号=0;

for (int i=0;i<dataMining5.存储数据.size();i++){

if (dataMining5.存储数据.get(i).层次号>最大层次号)

最大层次号=dataMining5.存储数据.get(i).层次号;

dataMining5.每层列号[dataMining5.存储数据.get(i).层次号]=0;

}

for (int i=0;i<=最大层次号;i++){

for (int j=0;j<dataMining5.存储数据.size();j++){

if (dataMining5.存储数据.get(j).层次号==i){

dataMining5.存储数据.get(j).列号=dataMining5.每层列号[i];

dataMining5.每层列号[i]++;

}

for (int i=0;i<dataMining5.存储数据.size();i++){

w1=dataMining5.存储数据.get(i).层次号;

w2=dataMining5.存储数据.get(i).列号;

w01=dataMining5.位置参数[w1][w2][1]; //左边距

w02=dataMining5.位置参数[w1][w2][0]; //到顶距

st1=dataMining5.存储数据.get(i).元素名;

st2=dataMining5.存储数据.get(i).下级节点号;

g.drawString(st1,w01,w02); //画元素名

}

for (int i=0;i<dataMining5.存储数据.size();i++){

w1=dataMining5.存储数据.get(i).层次号;

w2=dataMining5.存储数据.get(i).列号;

w01=dataMining5.位置参数[w1][w2][1]; //左边距

w02=dataMining5.位置参数[w1][w2][0]; //到顶距

st1=dataMining5.存储数据.get(i).元素名;

st2=dataMining5.存储数据.get(i).下级节点号;

sr1=st2.split(",");

if (st2.length()>0)

for (int k=0;k<sr1.length;k++){

w4=dataMining5.存储数据.get(Integer.parseInt(sr1[k])).层次号;

w5=dataMining5.存储数据.get(Integer.parseInt(sr1[k])).列号;

w03=dataMining5.位置参数[w4][w5][1]; //左边距

w04=dataMining5.位置参数[w4][w5][0]; //到顶距

g.drawLine(w01+10,w02+10,w03+10,w04-12);//画线

}

else if (dataMining5.存储数据.get(i).显示.indexOf("结束")>=0)

g.drawString(dataMining5.存储数据.get(i).上级节点名,w01+10,w02+13); //画元素名

}

版本2

107.源码107，实验程序，仅供参考。读取数据表中若干数字数据类型字段的数据进行聚类分析。

* 程序文件名：dataMining4.java

* 作者：程学先

* 功能：实验程序，读取数据表中若干数字数据类型字段的数据进行聚类分析。

* 可分析2聚类、三聚类、多聚类

* 其中每条记录可以为一列到多列数据。如果为一或二列数据，可以显示点的分布图。

* 必须输入的参数：表名、字段号表

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.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.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.JTextField;

import javax.swing.ListSelectionModel;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableColumn;

import javax.swing.table.TableModel;

public class dataMining4 extends JFrame {

static dataMining4 frame1 = new dataMining4();

static double[] variabl1841;

static double[] variabl1661;

static int variabl3647 = 0, variabl1519 = 0;

static int variabl3685 = 0, variabl1305 = 0;

static int variabl1727 = 1200, variabl1783 = 660;

static int variabl26730;

static int[] 记录条数n = null;

static Graphics g;

static Graphics2D g2;

static Insets inset;

static int variabl2661 = 100, variabl2657 = variabl1783;

private static JTable table;

static String variabl2603;

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

static String[] sk;

static int variabl2483 = 1300, variabl2503 = 700, variabl2387 = 0,

variabl2061 = 0;

static String[] variabl26151;

static int variabl19631, variabl19632;

static String[] variabl1501;

static double[][] variabl2115 = new double[20][2];

static String[] variabl21150 = new String[20];

static int variabl4037 = 20, variabl2559 = 0;

static int variabl4013 = 2;

static int[] variabl4055 = null, variabl40550 = null;

static String[][] variabl2197;

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

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

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

static TableModel model;

static JScrollPane scrollPane = new JScrollPane();

static JButton Button1, Button2, Button3, Button5;

private static Connection cont4;

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

static String[] variabl2517;

static int variabl1853, variabl2651, variabl1739;

private static int[] variabl1489;

private static String[][] variabl21970;

private static String variabl2049 = "";

private static String variabl1633 = "";

public static void 求新中心值() {

String[] d03 = null;

double d01[][];

for (int i = 1; i < variabl4013 + 1; i++) {

variabl21150[i] = "";

d01 = new double[variabl4013 + 1][variabl2061];

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

d03 = variabl2197[j][i].split(",");

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

d01[i][j1] = d01[i][j1] + Double.parseDouble(d03[j1]);

}

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

if (j1 == 0)

variabl21150[i] = d01[i][j1] / variabl4055[i] + "";

else

variabl21150[i] = variabl21150[i] + "," + d01[i][j1]

/ variabl4055[i] + "";

}

public static void variabl4015() {

double[][] d01 = new double[20][variabl4013 + 1];

double[] d02 = new double[variabl4013 + 1];

String[] d03 = new String[variabl4013 + 1];

double[] x = new double[variabl4013 + 1];

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

x[i] = variabl4055[i];

variabl4055[i] = 0;

}

for (int i = 1; i < variabl4013 + 1; i++) {

d03 = variabl21150[i].split(",");

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

d01[j][i] = Double.parseDouble(d03[j]);

}

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

for (int j = 1; j < variabl4013 + 1; j++) {

variabl2197[i][j] = "";

}

int k0 = 0, k1 = 0;

double x1 = 0, x0 = 0;

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

x1 = 0;

x0 = 0;

k1 = 0;

d03 = 表格数据m[i][0].split(",");

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

d02[j1] = Double.parseDouble(d03[j1]);

for (int j = 1; j < variabl4013 + 1; j++) {

x1 = 0;

for (int j2 = 0; j2 < d02.length; j2++) {

if (j2 == 0)

x1 = (d02[j2] - d01[j2][j]) * (d02[j2] - d01[j2][j]);

else {

x1 = x1 + (d02[j2] - d01[j2][j])

* (d02[j2] - d01[j2][j]);

}

if (j == 1) {

x0 = x1;

k1 = 1;

} else {

if (x1 < x0) {

x0 = x1;

k1 = j;

}

variabl2197[variabl4055[k1]][k1] = 表格数据m[i][0];

variabl4055[k1]++;

}

k0 = 0;

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

if (x[i] != variabl4055[i])

k0 = 1;

if (k0 == 0) {

Button1.setVisible(false);

Button2.setVisible(false);

variabl2559 = 1;

return;

}

static void means(String parameter[]) {

frame1 = new dataMining4();

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.setTitle("聚类分析作者：程学先");

frame1.setBounds(10, 10, variabl1727, variabl1783 + 50);

frame1.setLayout(null);

variabl2483 = 1300;

variabl2503 = 700;

set1 = new HashSet<String>();

variabl2603 = parameter[4];

String variabl1325 = parameter[19];

String variabl2009 = parameter[8];

if (variabl2603.indexOf(",") > 0)

variabl2049 = " where " + parameter[20];

else

variabl2049 = "";

if (variabl2009.trim().length() > 0) {

String[] s1 = variabl1325.split(",");

String[] s2 = variabl2009.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])];

} else

variabl1633 = variabl1325;

variabl2861(variabl2603);

variabl2061 = variabl2651;

variabl4013 = 2;

JLabel fl0 = new JLabel("预期分类数");

frame1.add(fl0);

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

frame1.add(fa0);

fl0.setBounds(10, 10, 80, 20);

fa0.setBounds(90, 10, 60, 20);

Button5 = new JButton("更新表格");

Button5.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

Button1.setVisible(true);

Button2.setVisible(true);

variabl2559 = 0;

variabl26730 = 0;

fa1.setText("1");

variabl4013 = Integer.parseInt(fa0.getText());

variabl2197 = new String[variabl1853][variabl4013 + 1];

variabl4055 = new int[variabl4013 + 1];

int x0 = variabl1489[0];

variabl1489 = new int[variabl4013 + 1];

variabl1489[0] = x0;

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

variabl2197[i][0] = 表格数据m[i][0];

for (int j = 1; j < variabl4013 + 1; j++) {

variabl2197[i][j] = "";

}

variabl2517 = new String[variabl4013 + 1];

variabl2517[0] = "原始数据";

for (int i = 1; i < variabl4013 + 1; i++) {

variabl2517[i] = "第" + i + "类数据";

}

for (int i = 1; i < variabl4013 + 1; i++)

variabl1489[i] = variabl1489[0];

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 < variabl4013 + 1; i++) {

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

tc.setPreferredWidth(variabl1489[i] * 12);

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

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

}

});

Button5.setBounds(160, 10, 120, 20);

frame1.add(Button5);

Button5.setVisible(false);

fa0.addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {

Button5.setVisible(true);

variabl1739 = 0;

}

});

JLabel fl1 = new JLabel("迭代次数");

frame1.add(fl1);

fa1 = new JTextField("1", 20);

frame1.add(fa1);

fl1.setBounds(340, 10, 80, 20);

fa1.setBounds(420, 10, 80, 20);

fa1.addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {

variabl1739 = 0;

}

});

Button1 = new JButton("单步");

Button1.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl2559 == 1)

return;

variabl4037 = Integer.parseInt(fa1.getText());

variabl4013 = Integer.parseInt(fa0.getText());

int[] kd = new int[variabl4013 + 1];

int i1 = 0;

if (variabl26730 == 0) {

variabl21150 = new String[variabl4013 + 1];

variabl4055 = new int[variabl4013 + 1];

variabl40550 = new int[variabl4013 + 1];

String[] variabl21151 = new String[variabl4013 + 1];

variabl2197 = new String[variabl1853][variabl4013 + 1];

for (i1 = 0; i1 < variabl4013; i1++) {

variabl21150[i1 + 1] = 表格数据m[i1][0];

variabl2197[0][i1 + 1] = 表格数据m[i1][0];

variabl4055[i1 + 1] = 1;

}

i1 = 1;

for (int i = variabl4013; i < variabl1853; i++) {

variabl2197[i1][variabl4013] = 表格数据m[i][0];

variabl4055[variabl4013]++;

i1++;

}

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 < variabl4013 + 1; i++) {

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

tc.setPreferredWidth(variabl1489[i] * 12);

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

variabl4037 = variabl4037 + 1;

fa1.setText(variabl4037 + "");

variabl26730++;

calc05.frame2.setVisible(false);

return;

}

variabl4015();

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 < variabl4013 + 1; i++) {

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

tc.setPreferredWidth(variabl1489[i] * 12);

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

variabl4037 = variabl4037 + 1;

variabl26730++;

fa1.setText(variabl4037 + "");

求新中心值();

calc05.frame2.setVisible(false);

}

});

Button1.setBounds(510, 10, 120, 20);

frame1.add(Button1);

Button2 = new JButton("完成迭代");

Button2.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

variabl4037 = Integer.parseInt(fa1.getText());

variabl4037 = 0;

variabl2559 = 0;

variabl4013 = Integer.parseInt(fa0.getText());

variabl21150 = new String[variabl4013 + 1];

variabl4055 = new int[variabl4013 + 1];

variabl40550 = new int[variabl4013 + 1];

variabl2197 = new String[variabl1853][variabl4013 + 1];

int i1 = 0;

if (variabl26730 == 0) {

for (i1 = 0; i1 < variabl4013; i1++) {

variabl21150[i1 + 1] = 表格数据m[i1][0];

variabl2197[0][i1 + 1] = 表格数据m[i1][0];

variabl4055[i1 + 1] = 1;

}

i1 = 1;

for (int i = variabl4013; i < variabl1853; i++) {

variabl2197[i1][variabl4013] = 表格数据m[i][0];

variabl4055[variabl4013]++;

i1++;

}

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 < variabl4013 + 1; i++) {

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

tc.setPreferredWidth(variabl1489[i] * 12);

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

variabl4037 = variabl4037 + 1;

fa1.setText(variabl4037 + "");

variabl26730++;

calc05.frame2.setVisible(false);

}

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

variabl2197[i][0] = 表格数据m[i][0];

while (variabl2559 == 0) {

variabl4015();

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 < variabl4013 + 1; i++) {

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

tc.setPreferredWidth(variabl1489[i] * 12);

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

variabl4037 = variabl4037 + 1;

variabl26730++;

fa1.setText(variabl4037 + "");

求新中心值();

calc05.frame2.setVisible(false);

variabl4037++;

fa1.setText(variabl4037 + "");

if (variabl2559 != 0)

break;

}

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 < variabl4013 + 1; i++) {

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

tc.setPreferredWidth(variabl1489[i] * 12);

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

calc05.frame2.setVisible(false);

}

});

Button2.setBounds(630, 10, 120, 20);

frame1.add(Button2);

Button3 = new JButton("显示图形");

Button3.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

variabl1841 = new double[variabl1853];

variabl1661 = new double[variabl1853];

int b = 0;

记录条数n = new int[variabl4013 + 1];

String[][] sg = new String[variabl1853][variabl4013 + 1];

for (int i = 1; i < variabl4013 + 1; i++) {

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

sg[b] = variabl2197[j][i].split(",");

variabl1661[b] = Double.parseDouble(sg[b][0]);

if (variabl2061 > 1)

variabl1841[b] = Double.parseDouble(sg[b][1]);

b++;

}

记录条数n[i] = b - 1;

}

calc05.calc011();

}

});

Button3.setBounds(750, 10, 120, 20);

frame1.add(Button3);

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

Button4.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

calc05.frame2.setVisible(false);

calc05.frame2.dispose();

frame1.setVisible(false);

frame1.dispose();

System.exit(0);

}

});

Button4.setBounds(870, 10, 120, 20);

frame1.add(Button4);

set1.clear();

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

String s0 = "";

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

if (j == 0)

s0 = variabl2197[i][j];

else

s0 = s0 + "," + variabl2197[i][j];

}

set1.add(s0);

}

variabl2387 = variabl1853;

variabl1853 = set1.size();

Object[] s10 = set1.toArray();

variabl2197 = new String[variabl1853][variabl4013 + 1];

variabl21970 = new String[variabl1853][variabl2061];

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

variabl2197[i][0] = s10[i].toString();

for (int j = 1; j < variabl4013 + 1; j++)

variabl2197[i][j] = "";

}

表格数据m = new String[variabl1853][variabl4013 + 1];

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

for (int j = 0; j < variabl4013 + 1; j++)

表格数据m[i][j] = variabl2197[i][j];

variabl1489 = new int[variabl4013 + 1];

variabl2517 = new String[variabl4013 + 1];

variabl2517[0] = "原始数据";

variabl4055 = new int[variabl4013 + 1];

for (int i = 1; i < variabl4013 + 1; i++) {

variabl2517[i] = "第" + i + "类数据";

}

variabl1489[0] = variabl2517[0].length();

String sk0 = "";

String[] sk;

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

sk = variabl2197[i][0].split(",");

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

variabl21970[i][j] = sk[j];

}

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

if (variabl1489[0] < variabl2197[i][0].trim().length())

variabl1489[0] = variabl2197[i][0].trim().length();

}

for (int i = 1; i < variabl4013 + 1; i++)

variabl1489[i] = variabl1489[0];

variabl2559 = 0;

fa1.setText("1");

if (variabl2061 < 3)

Button3.setVisible(true);

else

Button3.setVisible(false);

scrollPane.setVisible(false);

scrollPane = new JScrollPane();

scrollPane.setBounds(10, 40, variabl2483 - 60, 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 < variabl4013 + 1; i++) {

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

tc.setPreferredWidth(variabl1489[i] * 12);

tc.setMaxWidth(1500);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

variabl4055 = new int[variabl4013 + 1];

variabl40550 = new int[variabl4013 + 1];

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

inset = frame1.getInsets();

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

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 ((variabl21970[c][b] == null)

|| (variabl21970[c][b].trim().length() == 0))

if ((main1.variabl1545.lastIndexOf("," + variabl1501[b]

+ ",")) >= 0)

variabl21970[c][b] = "0";

else

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

private static final long serialVersionUID = 1L;

static calc05 frame2 = new calc05();

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 yyy;

static double xxx;

static double[] yyy1;

static double[] xxx1;

static int[] 记录条数n1;

static int variabl4013, variabl2061;

static double[][] variabl2115 = new double[20][2];

static String[] variabl21150 = new String[20];

static void calc011() {

calc05 frame2 = new calc05();

frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

variabl1853 = dataMining4.variabl1853;

variabl1841 = new double[variabl1853];

variabl1661 = new double[variabl1853];

variabl1519 = dataMining4.variabl1841[0];

variabl1305 = dataMining4.variabl1661[0];

variabl2061 = dataMining4.variabl2061;

记录条数n1 = new int[dataMining4.variabl4013 + 1];

variabl4013 = dataMining4.variabl4013;

variabl1415 = 20;

variabl1395 = 10;

variabl2115 = new double[20][2];

variabl21150 = new String[20];

for (int i = 1; i < variabl4013 + 1; i++) {

variabl21150[i] = dataMining4.variabl21150[i];

}

int h = 10;

if (variabl2061 > 1) {

variabl1727 = 1200;

variabl1783 = 700;

} else {

variabl1727 = 1200;

variabl1783 = 220;

h = 550;

}

frame2.setBounds(10, h, variabl1727, variabl1783 - 50);

frame2.setVisible(true);

}

public void paint(Graphics g1) {

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

variabl1841[i] = dataMining4.variabl1841[i];

variabl1661[i] = dataMining4.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];

}

记录条数n1 = new int[variabl4013 + 1];

for (int i = 1; i < variabl4013 + 1; i++) {

记录条数n1[i] = dataMining4.记录条数n[i];

}

g1.setColor(Color.WHITE);

g1.fillRect(0, 0, getWidth(), getHeight());

g = g1;

brokenLine();

}

static void brokenLine() {

g.setColor(Color.BLACK);

variabl1617 = variabl1783 - 200;

if (variabl3647 - variabl1519 != 0) {

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;

}

Graphics2D g2 = (Graphics2D) g;

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

if (variabl2061 > 1) {

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

double x2, y2, z1;

int x = 0, y = 0;

String z0;

g.setColor(Color.RED);

if (variabl2061 > 1)

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("第1类数据", 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);

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

}

String sg[];

double sh[][] = new double[variabl4013 + 1][2];

xxx1 = new double[variabl4013 + 1];

yyy1 = new double[variabl4013 + 1];

for (int j = 1; j < variabl4013 + 1; j++) {

sg = variabl21150[j].split(",");

sh[j][0] = Double.parseDouble(sg[0]);

if (sg.length > 1) {

sh[j][1] = Double.parseDouble(sg[1]);

}

xxx1[j] = (sh[j][0] - variabl1305) * variabl1027 + variabl1529;

yyy1[j] = (sh[j][1] - variabl1519) * variabl1019;

yyy1[j] = variabl1617 + variabl1437 - yyy1[j];

g.setColor(Color.CYAN);

g.fillOval((int) xxx1[j], (int) yyy1[j] - 15, w0 + 30, h0 + 30);

g.setColor(Color.BLACK);

}

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

yyy = (variabl1841[i] - variabl1519) * variabl1019;

yyy = variabl1617 + variabl1437 - yyy;

xxx = (variabl1661[i] - variabl1305) * variabl1027 + variabl1529;

for (int j = 1; j < variabl4013 + 1; j++) {

if ((i > 0) && (记录条数n1[j] == i - 1)) {

if (j / 2 == (j / 2.0)) {

g.setColor(Color.RED);

} else {

g.setColor(Color.BLACK);

}

g.fillOval((int) xxx, (int) yyy - 5, w0 + 10, h0 + 10);

}

g.setColor(Color.RED);

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

xxx1 = variabl1305;

variabl2355 = 1;

yyy3 = (yyy1 - variabl1519) * variabl1019;

yyy3 = variabl1617 + variabl1437 - yyy3;

int variabl1781 = 200;

for (int i = 1; i < variabl1781; i++) {

xxx = xxx1 + (variabl3685 - variabl1305) / variabl1781;

xxx2 = xxx;

yyy2 = yyy;

yyy = (yyy - variabl1519) * variabl1019;

yyy = variabl1617 + variabl1437 - yyy;

xxx = (xxx - variabl1305) * variabl1027 + variabl1529;

xxx1 = xxx2;

yyy1 = yyy2;

yyy3 = yyy;

}

108.源码108，实验程序，仅供参考。读取数据表中的若干个字段数据进行条件熵绘制决策树。

* 程序文件名：dataMining5.java

* 作者：程学先

* 程序功能：读取数据表中的若干个字段数据进行条件熵绘制决策树。

* 必须输入的参数：表名、类属性、描述属性，其中类属性限单字段，其值限为是、否

* 描述属性可以为多个，其值均为有限离散型数据。

* 例如：某数据表中数据:

* 年龄输入层次学生信用等级是否购买电脑

* 青少年 variabl2707 否一般否

* 青少年 variabl2707 否良好否

* 中年 variabl2707 否一般是

* 老年中否一般是

* 老年低是一般是

* 老年低是良好否

* 中年低是良好是

* 青少年中否一般否

* 青少年低是一般是

* 老年中是一般是

* 青少年中是良好是

* 中年中否良好是

* 中年 variabl2707 是一般是

* 老年中否良好否

* ………………

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

class 存储结构I3 {

int variabl2673;

String variabl2343;

int variabl2409;

int variabl2547;

int variabl1763;

int variabl4005;

String variabl1335;

String variabl4007;

String variabl2541;

int variabl4053;

public 存储结构I3(int variabl2673, String variabl2343, int variabl2409,

int variabl2547, int variabl1763, int variabl4005,

String variabl1335, String variabl4007, String variabl2541,

int variabl4053) {

this.variabl2673 = variabl2673;

this.variabl2343 = variabl2343;

this.variabl2409 = variabl2409;

this.variabl2547 = variabl2547;

this.variabl1763 = variabl1763;

this.variabl4005 = variabl4005;

this.variabl1335 = variabl1335;

this.variabl4007 = variabl4007;

this.variabl2541 = variabl2541;

this.variabl4053 = variabl4053;

}

public class dataMining5 extends JFrame {

static dataMining5 frame1 = new dataMining5();

static String[] variabl2517;

static int variabl1727 = 1050, variabl1783 = 600;

static int variabl1853, variabl2651, variabl1739;

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, variabl2503 = 600, variabl2387 = 0;

static String[] variabl26151;

static int variabl2113 = 2;

static String[] variabl1913;

static int variabl19631, variabl19632;

static String[] variabl1501;

static int[] variabl2529 = new int[2];

static Object[][] variabl2197;

static Object[][][] variabl4003;

static JTextField fb1, fc1;

static JTextArea fa0;

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

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

static TableModel model;

static JScrollPane scrollPane;

static int[][][] variabl1921;

static int variabl26730 = 0;

static ArrayList<存储结构I3> variabl1955 = new ArrayList<存储结构I3>();

static int[] variabl4021;

static int[][] variabl4023;

static int variabl4057 = 0, variabl25470 = 0, variabl4049 = 0,

variabl4031 = 0;

static String variabl4051 = "";

static String[] variabl4001, variabl4025;

static int variabl4033 = 0, variabl4061 = 0;

static int variabl4043 = 0;

static String[] variabl4027;

static int variabl2203 = 0;

private static Connection cont4;

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

private static String[][] variabl21970;

static String variabl4009;

private static String variabl2049 = "";

private static String variabl1633 = "";

public static void variabl12531() {

variabl1853 = variabl2387;

variabl2113 = variabl2529.length;

int[] variabl1489 = new int[variabl2113];

scrollPane = new JScrollPane();

scrollPane.setBounds(810, 40, 400, 430);

model = new DefaultTableModel(variabl2197, variabl1913);

table = new JTable(model);

table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

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

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

if (variabl2529[i] < variabl1913[i].length())

variabl2529[i] = variabl1913[i].length();

tc.setPreferredWidth(variabl2529[i] * 15);

tc.setMaxWidth(1000);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

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

inset = frame1.getInsets();

}

public static void means(String[] parameter) {

frame1 = new dataMining5();

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.setTitle("ID3条件熵计算程序作者：程学先");

frame1.setBounds(10, 10, 1300, variabl1783 + 50);

frame1.setLayout(null);

variabl2603 = parameter[4];

String variabl1325 = parameter[19];

String variabl4009 = parameter[9];

if (variabl4009.indexOf(",") > 0)

variabl4009 = variabl4009.substring(0, variabl4009.indexOf(","));

String variabl2009 = parameter[8] + "," + variabl4009;

if (variabl2603.indexOf(",") > 0)

variabl2049 = " where " + parameter[20];

else

variabl2049 = "";

String[] s1 = variabl1325.split(",");

String[] s2 = variabl2009.split(",");

variabl1633 = s1[Integer.parseInt(s2[0])];

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

variabl1633 = variabl1633 + "," + s1[Integer.parseInt(s2[i])];

variabl2861(variabl2603);

variabl12531();

variabl26730 = 0;

variabl1921 = new int[15][15][2];

variabl1921[0][0][0] = 15;

int y1 = 200;

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

variabl1921[i][0][1] = 10 + (15 - i) * (y1 / 15);

}

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;

}

variabl4003 = new Object[100][][];

variabl4021 = new int[100];

variabl4023 = new int[100][5];

variabl4001 = new String[100];

variabl4025 = new String[100];

variabl4027 = new String[100];

variabl4061 = 1;

JLabel fl1 = new JLabel("子集名称");

fl1.setBounds(310, 40, 60, 20);

frame1.add(fl1);

fc1 = new JTextField(" 全集 ");

fc1.setBounds(370, 40, 280, 20);

frame1.add(fc1);

JLabel fl0 = new JLabel("条件熵计算式与计算值");

frame1.add(fl0);

fa0 = new JTextArea("");

frame1.add(fa0);

fl0.setBounds(10, 40, 300, 20);

fa0.setBounds(10, 70, 800, 430);

fa0.addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {

variabl1739 = 0;

}

});

final JButton Button0 = new JButton("单步");

Button0.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if ((variabl26730 > 0) && (variabl4061 <= variabl4043 + 1)) {

fc1.setText("迭代结束，请查看图形！");

return;

}

String variabl4045 = "", variabl4047 = "";

if (variabl26730 == 0) {

variabl4057 = 0;

variabl25470 = 0;

variabl4049 = -1;

variabl4051 = "";

variabl4031 = -1;

variabl4033 = 0;

variabl4043 = 0;

variabl4003[variabl4033] = new Object[variabl1853][variabl2113];

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

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

variabl4003[variabl4033][i][j] = variabl2197[i][j];

variabl4021[variabl4057] = variabl25470;

variabl4023[variabl4033][0] = variabl4033;

variabl4023[variabl4033][1] = variabl4057;

variabl4023[variabl4033][2] = variabl4049;

variabl4023[variabl4033][3] = variabl1853;

variabl4023[variabl4033][4] = variabl2113;

variabl4003[variabl4033] = new Object[variabl1853][variabl2113];

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

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

variabl4003[variabl4033][i][j] = variabl2197[i][j];

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

if (variabl4045.length() == 0)

variabl4045 = variabl1913[j];

else

variabl4045 = variabl4045 + "," + variabl1913[j];

}

variabl4001[variabl4033] = "";

variabl4025[variabl4033] = variabl4045;

} else {

variabl4043++;

variabl4057 = variabl4023[variabl4043][1];

variabl4049 = variabl4023[variabl4043][2];

variabl1853 = variabl4023[variabl4043][3];

variabl2113 = variabl4023[variabl4043][4];

variabl4031 = variabl4057 - 1;

variabl4051 = variabl4001[variabl4043];

variabl4045 = variabl4025[variabl4043];

variabl4047 = variabl4027[variabl4043];

fc1.setText(variabl4047);

}

variabl2197 = new Object[variabl1853][variabl2113];

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

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

variabl2197[i][j] = variabl4003[variabl4043][i][j];

}

if (variabl26730 > 0) {

variabl1913 = variabl4045.split(",");

scrollPane = new JScrollPane();

scrollPane.setBounds(810, 40, 400, 430);

model = new DefaultTableModel(variabl2197, variabl1913);

table = new JTable(model);

table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

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

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

tc.setPreferredWidth(variabl1913[i].length() * 20);

tc.setMaxWidth(1000);

tc.sizeWidthToFit();

}

scrollPane.setViewportView(table);

frame1.getContentPane()

.add(scrollPane, BorderLayout.CENTER);

inset = frame1.getInsets();

}

if (variabl4061 <= variabl4043)

return;

variabl4035(variabl2197, variabl1853, variabl2113, variabl4057,

variabl25470, variabl4049, variabl4031, variabl4051,

variabl4043, variabl4045, variabl4047);

}

});

Button0.setBounds(850, variabl2503 - 110, 300, 20);

frame1.add(Button0);

final JButton Button1 = new JButton("绘图");

Button1.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

variabl2203 = 5;

id3grap1.frame2.setVisible(true);

id3grap1.id3grap1();

}

});

Button1.setBounds(850, variabl2503 - 80, 300, 20);

frame1.add(Button1);

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

Button2.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

frame1.setVisible(false);

frame1.dispose();

id3grap1.frame2.setVisible(false);

id3grap1.frame2.dispose();

System.exit(0);

}

});

Button2.setBounds(850, variabl2503 - 50, 300, 20);

frame1.add(Button2);

id3grap1.frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

id3grap1.frame2.setBounds(10, 30, 800, 650);

id3grap1.frame2.setVisible(true);

frame1.setVisible(true);

}

public static void variabl4035(Object[][] variabl2197, int variabl1853,

int variabl2113, int variabl4057, int variabl25470,

int variabl4049, int variabl4031, String variabl4051,

int variabl40590, String variabl4045, String variabl4047) {

double variabl2333 = 0;

if ((variabl1853 == 0) || (variabl2113 <= 1))

return;

double variabl2371 = 1;

String variabl2075 = "";

String variabl4009 = "";

String[] s10 = null;

set1.removeAll(set1);

String[] s1 = null;

String[] s2 = null;

int[] t1 = null;

int[] t2 = null;

int[][] t20 = null;

String variabl2125 = "";

String variabl21251 = "";

int variabl1509 = 0, variabl1243 = 0;

char x1 = 10, x2 = 13;

variabl1913 = variabl4045.split(",");

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

set2.removeAll(set2);

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

if (i == 0) {

set1.add(variabl2197[j][variabl2113 - 1].toString());

variabl4009 = variabl2197[j][variabl2113 - 1].toString();

}

if (j > 0) {

set2.add(variabl2197[j - 1][i].toString());

}

if (i == 0) {

variabl1509 = set1.size();

s1 = new String[variabl1509];

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

t1 = new int[variabl1509];

}

variabl1243 = set2.size();

s2 = new String[variabl1243];

s2 = set2.toArray(new String[0]);

t2 = new int[variabl1243];

t20 = new int[variabl1243][variabl1509];

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

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

if ((i == 0)

&& (s1[k].equals(variabl2197[j][variabl2113 - 1]))) {

t1[k]++;

}

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

if (s2[k].equals(variabl2197[j][i])) {

t2[k]++;

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

if (s1[k1].equals(variabl2197[j][variabl2113 - 1])) {

t20[k][k1]++;

}

variabl2125 = variabl2125 + variabl1913[i] + "条件熵=";

int k1 = 0, k = 0;

double[] variabl2269 = new double[variabl1509];

double[] variabl23330 = new double[variabl1243];

double[] variabl23331 = new double[variabl1509];

double variabl23332 = 0;

double variabl2709 = 0;

for (k = 0; k < variabl1243; k++) {

variabl2125 = variabl2125 + "-" + t2[k] + "/" + variabl1853

+ "*( ";

variabl21251 = variabl21251 + "+" + t2[k] + "/" + variabl1853

+ "*( ";

variabl23330[k] = t2[k] / variabl1853;

variabl2333 = 0;

double x = 0;

for (k1 = 0; k1 < variabl1509; k1++) {

variabl2125 = variabl2125 + t20[k][k1] + "/" + t2[k]

+ "*ln( ";

variabl21251 = variabl21251 + t20[k][k1] + "/" + t2[k]

+ "*";

x = (t20[k][k1] + 0.0000) / t2[k];

if (x < 0.001)

x = 0.001;

variabl2269[k1] = -(Math.log10(x) / Math.log10(2));

variabl2125 = variabl2125 + t20[k][k1] + "/" + t2[k] + " )";

variabl21251 = variabl21251

+ (variabl2269[k1] + " ").substring(0, 8);

if (k1 < variabl1509 - 1)

variabl21251 = variabl21251 + "+";

variabl23331[k1] = variabl2269[k1] * x;

variabl2333 = variabl2333 + variabl23331[k1];

if (k1 < variabl1509 - 1)

variabl2125 = variabl2125 + "+";

}

variabl2125 = variabl2125 + " )";

variabl21251 = variabl21251 + " )";

variabl23332 = variabl23332 + variabl2333 * t2[k] / variabl1853;

variabl2709 = variabl2709 + variabl2333 * t2[k] / variabl1853;

}

variabl2125 = variabl2125 + " )" + x1 + x2 + " =";

variabl21251 = variabl21251 + " )" + x1 + x2 + " =";

variabl2125 = variabl2125 + variabl21251 + variabl2709 + x1 + x2;

if (variabl2709 < variabl2371) {

variabl2371 = variabl2709;

variabl2075 = variabl1913[i];

}

variabl2709 = 0;

}

variabl2125 = variabl2125 + x1 + x2 + "比较上述数据，可见" + variabl2075

+ "的条件熵最小，其值为：" + variabl2371 + "。选为下一级的根。";

fa0.setText(variabl2125);

variabl2075 = variabl2075.replaceAll(" ", "");

if (variabl4049 >= 0) {

if (variabl1955.get(variabl4049).variabl4007.length() == 0)

variabl1955.get(variabl4049).variabl4007 = variabl26730 + "";

else

variabl1955.get(variabl4049).variabl4007 = variabl1955

.get(variabl4049).variabl4007 + "," + variabl26730;

}

if (variabl2333 != 0) {

variabl1955.add(new 存储结构I3(variabl26730, variabl2075, variabl4057,

variabl25470, variabl4049, variabl4031, variabl4051, "",

variabl2125, variabl40590));

variabl4057++;

variabl4049 = variabl26730;

variabl26730++;

variabl2113--;

String[] sl1 = variabl4045.split(",");

variabl4045 = "";

String 序号集 = "";

int h0 = 0;

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

if (sl1[i].equals(variabl2075)) {

h0 = i;

continue;

}

if (variabl4045.length() == 0) {

variabl4045 = sl1[i];

序号集 = i + "";

} else {

variabl4045 = variabl4045 + "," + sl1[i];

序号集 = 序号集 + "," + i;

}

set1.removeAll(set1);

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

set1.add(variabl2197[i][h0].toString());

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

Object[][] sj = new Object[100][variabl2113];

int sj1 = 0, sj2 = 0, sj3 = 0;

String sj4 = "";

for (int i = 0; i < set1.size(); i++) {

sj2 = 0;

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

if (!sj0[i].equals(variabl2197[j][h0]))

continue;

sj3 = 0;

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

if (k != h0) {

sj[sj2][sj3] = variabl2197[j][k];

sj3++;

}

sj2++;

}

variabl4033++;

variabl4003[variabl4033] = new Object[sj2][variabl2113];

for (int i1 = 0; i1 < sj2; i1++)

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

variabl4003[variabl4033][i1][j] = sj[i1][j];

variabl4021[variabl4057] = variabl25470;

variabl4023[variabl4033][0] = variabl4033;

variabl4023[variabl4033][1] = variabl4057;

variabl4023[variabl4033][2] = variabl4049;

variabl4023[variabl4033][3] = sj2;

variabl4023[variabl4033][4] = variabl2113;

variabl4061++;

variabl4001[variabl4033] = variabl2075;

variabl4025[variabl4033] = variabl4045;

variabl4027[variabl4033] = variabl4047 + sj0[i];

}

} else {

fa0.setText("本" + variabl4047 + "子集决策数据相同，分枝结束！");

variabl1955.add(new 存储结构I3(variabl26730, variabl4047, variabl4057,

variabl25470, variabl4049, variabl4031, variabl4009, "",

"本" + variabl4047 + "子集决策数据相同，分枝结束！", -1));

variabl26730++;

}

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

variabl1913 = new String[variabl2651];

variabl1501 = new String[variabl2651];

variabl2529 = new int[variabl2651];

for (int i1 = 0; i1 < variabl2651; i1++) {

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

variabl1501[i1] = rsmdt4.getColumnTypeName(i1 + 1);

variabl2529[i1] = rsmdt4.getColumnDisplaySize(i1 + 1);

}

rs.last();

variabl1853 = rs.getRow();

variabl26151 = new String[variabl1853];

variabl2387 = variabl1853;

char x6 = '"';

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

static id3grap1 frame2 = new id3grap1();

static Graphics g;

static void id3grap1() {

frame2.repaint();

}

public void paint(Graphics g1) {

g = g1;

if (dataMining5.variabl2203 == 0) {

g1.setColor(Color.WHITE);

g1.fillRect(0, 0, getWidth(), getHeight());

g1.setColor(Color.black);

dataMining5.variabl2203 = 1;

} else if (dataMining5.variabl2203 == 5) {

Graphics2D g2 = (Graphics2D) g;

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

g1.setColor(Color.WHITE);

g1.fillRect(0, 0, getWidth(), getHeight());

h();

dataMining5.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;

int variabl4011 = 0;

for (int i = 0; i < dataMining5.variabl1955.size(); i++) {

if (dataMining5.variabl1955.get(i).variabl2409 > variabl4011)

variabl4011 = dataMining5.variabl1955.get(i).variabl2409;

dataMining5.variabl4021[dataMining5.variabl1955.get(i).variabl2409] = 0;

}

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

for (int j = 0; j < dataMining5.variabl1955.size(); j++) {

if (dataMining5.variabl1955.get(j).variabl2409 == i) {

dataMining5.variabl1955.get(j).variabl2547 = dataMining5.variabl4021[i];

dataMining5.variabl4021[i]++;

}

for (int i = 0; i < dataMining5.variabl1955.size(); i++) {

w1 = dataMining5.variabl1955.get(i).variabl2409;

w2 = dataMining5.variabl1955.get(i).variabl2547;

w01 = dataMining5.variabl1921[w1][w2][1];

w02 = dataMining5.variabl1921[w1][w2][0];

st1 = dataMining5.variabl1955.get(i).variabl2343;

st2 = dataMining5.variabl1955.get(i).variabl4007;

g.drawString(st1, w01, w02);

}

for (int i = 0; i < dataMining5.variabl1955.size(); i++) {

w1 = dataMining5.variabl1955.get(i).variabl2409;

w2 = dataMining5.variabl1955.get(i).variabl2547;

w01 = dataMining5.variabl1921[w1][w2][1];

w02 = dataMining5.variabl1921[w1][w2][0];

st1 = dataMining5.variabl1955.get(i).variabl2343;

st2 = dataMining5.variabl1955.get(i).variabl4007;

sr1 = st2.split(",");

if (st2.length() > 0)

for (int k = 0; k < sr1.length; k++) {

w4 = dataMining5.variabl1955.get(Integer.parseInt(sr1[k])).variabl2409;

w5 = dataMining5.variabl1955.get(Integer.parseInt(sr1[k])).variabl2547;

w03 = dataMining5.variabl1921[w4][w5][1];

w04 = dataMining5.variabl1921[w4][w5][0];

g.drawLine(w01 + 10, w02 + 10, w03 + 10, w04 - 12);

}

else if (dataMining5.variabl1955.get(i).variabl2541.indexOf("结束") >= 0)

g.drawString(dataMining5.variabl1955.get(i).variabl1335,

w01 + 10, w02 + 13);

}

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

上一篇：管理信息系统软件生产线源码104-106
下一篇：管理信息系统软件生产线系统建模程序源码9-11

收藏 IP: 183.94.47.*| 热度|

当前推荐数：0

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

数据加载中...

返回顶部

程学先

扫一扫，分享此博文

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

博文

管理信息系统软件生产线源码107-108

当前推荐数：0

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

程学先

全部作者的精选博文

全部作者的其他最新博文

全部精选博文导读

相关博文

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

博文

管理信息系统软件生产线源码107-108

当前推荐数：0

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

程学先

全部作者的精选博文

全部作者的其他最新博文

全部精选博文导读

相关博文

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

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