企业官网建设流程全解析

简介：基于Java决策树算法的大学生就业预测系统设计与实现，是一份面向高校就业指导人员、计算机相关专业毕业生及数据挖掘初学者的完整设计文档。文档围绕决策树算法在就业趋势预测中的应用，详细阐述了利用专业、成绩、实习经历、社会活动等因素构建预测模型的思路，并给出了基于MyEclipse、JSP与MySQL的技术实现方案，包括动态网页开发、用户密码与手机验证码双重安全保护等具体设计。内容从系统需求分析到技术路线、关键功能实现均有涉及，可作为课程设计、毕业设计或课题研究的参考底稿。这份资源为单个Word格式文档，体积1.37MB，当前已有270人学习下载。文档结构规范，包含中英文摘要、目录及正文，读者可直接学习系统整体框架，也可以摘取决策树特征选择、JSP页面交互、数据库表设计等模块进行二次开发或论文改写，适合需要快速上手就业预测类系统设计的读者。

1. 这个“基于Java决策树的大学生就业预测系统”到底要做什么

每年毕业季，就业指导中心的老师都会面对一堆问题：哪些学生可能找不到工作？要不要提前做帮扶？如果一份学生历史数据放在眼前，用 Java 写一个决策树算法程序，就能自动从成绩、实习、证书这些字段里学出规律，预测新一届学生的就业结果——这就是“基于 Java 决策树算法的大学生就业预测系统”的核心价值。这个项目在毕业设计和实际业务里都很常见，适合计算机专业学生拿来做综合训练，也适合刚入职的 Java 工程师当作入门机器学习的第一课。它的难点不在算法本身，而在怎么把算法和 Web 系统、数据库串起来，同时保证预测结果可信。

2. 决策树选型与 Java 实现：为什么用 C4.5 而不是 ID3，以及三种落地方式

2.1 决策树算法怎么选：信息增益、增益率、基尼系数的差别

决策树算法的本质是一连串“如果……那么……”的规则。比如“如果 GPA 大于 3.5 且实习次数大于 0，则预测就业成功”。关键在于每一步选择哪个特征来分裂数据。常见的三种指标对应三种经典算法：

信息增益的计算公式是：分裂前熵减去分裂后加权熵。熵越高，数据越混乱。ID3 直接选信息增益最大的特征，但会偏爱“学号”这种取值很多的特征——每个学生的学号都不同，分裂后每个子集只剩一条数据，熵直接降到 0，于是学号被选中。这在就业预测里毫无意义。C4.5 用信息增益率，除以一个“内在信息”惩罚项，能抑制这种偏好。CART 用基尼系数，计算代价更小，也是很多库的默认实现。

在大学生就业预测场景里，特征有连续值（GPA、实习月数）、有缺失值（部分学生没填证书信息），所以最少要用 C4.5 或 CART。如果项目要求你写“基于 Java 决策树算法”，最常见的选择是 C4.5 的思想，或者直接调用 Weka 里的 J48 分类器——J48 就是 C4.5 的 Java 开源实现。我一般建议：如果论文重点在算法分析，就用 C4.5，并解释为什么不用 ID3；如果重点在系统功能，就直接用 J48，把精力放在 Web 和数据库上。

2.2 Java 里跑决策树的三种常见姿势

在企业里做这类项目，很少有人从零写决策树，除非是教学需要。Java 生态里跑决策树，常见的有三条路：

第一条，调用 Weka 的 J48 分类器。Weka 是一个 Java 机器学习库，J48 封装好了 C4.5 算法，只需要把数据转成 ARFF 格式，然后几行代码就能训练。适合想快速看到结果的人，也适合论文里对比多个算法（比如决策树和贝叶斯对比）。

第二条，自己写算法。适合毕业设计需要展示核心代码、需要讲清楚原理的场景。自研决策树的核心代码大概 200 行左右，包括计算熵、选择特征、递归分裂、剪枝。优点是论文查重时代码是你自己的，缺点是容易写出 bug，比如连续值排序、递归终止条件。

第三条，用 Spark MLlib 的决策树。适合数据量很大（比如全校几万学生）而且系统部署在集群上。但大部分毕业设计和中小型系统用不到，单机跑就够了。

这三条路不冲突。我见过很多同学先自研一个简单版本跑通，再用 Weka 的 J48 做对照实验。下面我会给出一个可运行的自研骨架，让你理解原理，再用 Weka 做实际预测。

2.3 自研一个可运行的决策树核心代码：从数据到树的 Java 骨架

这里给一个简化版的自研决策树代码，只支持标称特征（离散值），但足以说明决策树构建过程。完整项目里你还需要加连续值分箱、缺失值处理和剪枝，这些在后续章节讲。

// 决策树节点：存储分裂特征、分支和预测结果 public class TreeNode { int featureIndex; // 当前节点使用的特征索引 Map<String, TreeNode> children; // 特征值 -> 子节点 String prediction; // 如果是叶子节点，存储预测类别 boolean isLeaf; public TreeNode() { children = new HashMap<>(); isLeaf = false; } } // 决策树构建器：用信息增益选择特征 public class DecisionTree { private List<String[]> data; // 每行是特征+标签，最后一列是标签 private TreeNode root; public DecisionTree(List<String[]> dataset) { this.data = dataset; } public void buildTree() { List<Integer> featureIndexes = new ArrayList<>(); for (int i = 0; i < data.get(0).length - 1; i++) { featureIndexes.add(i); } root = build(data, featureIndexes); } private TreeNode build(List<String[]> subset, List<Integer> featureIndexes) { TreeNode node = new TreeNode(); // 如果所有样本标签相同，生成叶子节点 Set<String> labels = new HashSet<>(); for (String[] row : subset) { labels.add(row[row.length - 1]); } if (labels.size() == 1) { node.isLeaf = true; node.prediction = labels.iterator().next(); return node; } // 如果没有可用特征，取多数类作为叶子节点 if (featureIndexes.isEmpty()) { node.isLeaf = true; node.prediction = getMajorityLabel(subset); return node; } // 选择信息增益最大的特征 int bestFeature = selectBestFeature(subset, featureIndexes); node.featureIndex = bestFeature; // 按特征值划分数据，递归构建 Map<String, List<String[]>> split = splitByFeature(subset, bestFeature); for (Map.Entry<String, List<String[]>> entry : split.entrySet()) { List<Integer> remainingFeatures = new ArrayList<>(featureIndexes); remainingFeatures.remove(Integer.valueOf(bestFeature)); node.children.put(entry.getKey(), build(entry.getValue(), remainingFeatures)); } return node; } private int selectBestFeature(List<String[]> subset, List<Integer> featureIndexes) { double baseEntropy = calcEntropy(subset); double bestGain = -1; int bestFeature = -1; for (int idx : featureIndexes) { double condEntropy = 0; Map<String, List<String[]>> split = splitByFeature(subset, idx); for (List<String[]> part : split.values()) { condEntropy += (part.size() / (double) subset.size()) * calcEntropy(part); } double gain = baseEntropy - condEntropy; if (gain > bestGain) { bestGain = gain; bestFeature = idx; } } return bestFeature; } // 熵的计算：-p*log2(p) 累加 private double calcEntropy(List<String[]> subset) { Map<String, Integer> labelCount = new HashMap<>(); for (String[] row : subset) { String label = row[row.length - 1]; labelCount.put(label, labelCount.getOrDefault(label, 0) + 1); } double entropy = 0; for (int count : labelCount.values()) { double p = count / (double) subset.size(); entropy -= p * Math.log(p) / Math.log(2); } return entropy; } private Map<String, List<String[]>> splitByFeature(List<String[]> subset, int featureIndex) { Map<String, List<String[]>> split = new HashMap<>(); for (String[] row : subset) { String value = row[featureIndex]; split.computeIfAbsent(value, k -> new ArrayList<>()).add(row); } return split; } private String getMajorityLabel(List<String[]> subset) { Map<String, Integer> count = new HashMap<>(); for (String[] row : subset) { count.put(row[row.length - 1], count.getOrDefault(row[row.length - 1], 0) + 1); } return count.entrySet().stream() .max(Map.Entry.comparingByValue()) .get().getKey(); } }

这段代码构建了一个二叉树结构，实际上多叉树。build方法是递归的：先检查是不是所有样本类别一致，是就直接做叶子；否则从可用特征里挑信息增益最大的，然后按特征值切成多个子集，递归下降。selectBestFeature计算分裂前后的熵差，注意它里面用了Math.log(p) / Math.log(2)，这是把自然对数转成以 2 为底。如果特征值很多，split的每个子集样本量会很小，这也是为什么信息增益容易选到“学号”这类特征——你可以在这个骨架里改成增益率，只需要在gain上除以一个内在信息值。

运行这个骨架前，你要确保数据格式是List<String[]>，每行的最后一列是就业结果标签（比如“找到工作”和“未找到”）。另外，这个实现没有剪枝，实际使用时容易过拟合，后面我会讲怎么补。

3. 大学生就业预测的特征工程：决定预测准确率的上限

3.1 特征怎么定义：从就业数据里能挖出哪些有效字段

算法再强，喂进去的字段没营养，预测就是瞎猜。就业预测系统里，常见可用的特征分三类：

学生基本情况：性别、生源地、民族、政治面貌、是否学生干部。这些数据从学生信息表里直接拿。

学业表现：GPA、专业排名百分比、挂科门数、英语四级六级成绩、专业技能证书数量。这类特征在大多数样本里表现最强，因为就业机会确实和学业水平强相关。

实践经历：是否有实习经历、实习月数、参加竞赛次数、获奖等级、参与项目数量。这些数据往往要手工录入或从实践系统导入。

不需要的特征要果断丢掉：学号、身份证号、班级编号。决策树会把它们当成分裂特征，产生无意义的规则。我见过一个案例，系统把“学号第一位”当作最强特征——因为学校把就业好的学生排在了前面的学号段，这纯粹是巧合，换一届学生就失效了。

3.2 数据清洗与离散化：连续变量分箱的 Java 方法

GPA、实习月数这类连续值，决策树也能直接处理（C4.5 支持连续值），但要排序后找最优切分点，实现复杂。更简单的做法是分箱，把连续值变成离散区间。

GPA 通常可以分成四个区间：0-2.0 为“困难”，2.0-2.5 为“及格”，2.5-3.5 为“良好”，3.5 以上为“优秀”。实习月数可以分 0、1-3、4-6、6 以上。分箱的关键是让每组样本量不要太少，否则叶子节点统计不稳定。

// 连续值分箱：将GPA转换为离散等级 public class FeatureDiscretizer { // 输入GPA，输出等级字符串 public static String discretizeGpa(double gpa) { if (gpa < 0 || gpa > 4.0) { return "unknown"; // 数据异常 } if (gpa < 2.0) { return "lower"; } else if (gpa < 2.5) { return "pass"; } else if (gpa < 3.5) { return "good"; } else { return "excellent"; } } // 实习月数分箱 public static String discretizeInternshipMonths(int months) { if (months <= 0) { return "none"; } else if (months <= 3) { return "short"; } else if (months <= 6) { return "medium"; } else { return "long"; } } }

这段代码把连续值变成有序的标称值。注意discretizeGpa里对小于 0 和大于 4 的数据返回"unknown"，这是为了在后续建模时统一处理异常值。分箱边界怎么定？最简单的是等宽分箱，但更好的做法是按分位数分箱——把数据排序后按样本数切，保证每个区间样本量近似相等。你在实际项目里可以先看一眼数据分布，再用Arrays.sort或者流式统计找出 25%、50%、75% 分位点。

分箱的坏处是丢失了部分信息，比如 GPA 3.49 和 3.51 被分到不同区间但差别很小。不过对毕业论文级别的项目，分箱带来的可解释性提升远远大于精度损失。

3.3 特征编码：把字符串变成决策树能吃的数字

决策树算法本身会处理字符串特征，但如果你自研的代码不支持字符串，或者要用 Weka，就得把字符串转成数值或标称值。注意：决策树不像神经网络那样需要 One-Hot 编码，直接给每个类别分配一个整数也是可以的。但分配整数时要小心——如果类别本身没有大小关系，比如专业“计算机”和“土木”，你用 1 和 2 表示，模型可能误以为 2 比 1 更大。不过决策树每次只做等于判断，不会比较大小，所以影响不大。为了保险，我建议在自研代码里直接用字符串做分裂，在 Weka 里用nominal属性。

// 把性别和生源地等字符串特征统一编码 public class FeatureEncoder { // 性别映射：男/女 -> M/F public static String encodeGender(String gender) { if ("男".equals(gender)) { return "M"; } else if ("女".equals(gender)) { return "F"; } else { return "U"; // unknown } } // 生源地按省份编码，这里只示例几个 public static String encodeProvince(String province) { switch (province) { case "北京": return "BJ"; case "上海": return "SH"; case "广东": return "GD"; default: return "OTHER"; } } // 证书特征：按数量分箱 public static String encodeCertificates(int count) { if (count == 0) { return "none"; } else if (count <= 2) { return "few"; } else { return "many"; } } }

这里的关键是编码顺序要全局一致。我见过一个翻车案例：训练数据里“女”编码成 0，“男”编码成 1，预测时新数据里“女”编码成了 1，结果完全反了。解决办法是写一个统一字典类，或者直接用字符串，不要转换。如果非要用数值，把所有特征映射表写在配置文件里，加载时校验一遍。

4. 从算法到系统：数据库设计与 Spring Boot 接口实现

4.1 功能模块怎么拆：数据导入、训练、预测、可视化

一个完整的就业预测系统，不能只放一个算法类。标准的模块划分是：

1. 学生数据管理：录入、导入导出 Excel、修改。
2. 特征管理：维护分箱规则、特征编码字典。
3. 模型训练：选择算法参数，触发训练，显示准确率。
4. 就业预测：输入单个学生的特征，调用模型输出预测结果和概率。
5. 统计分析：按学院、专业统计就业率，展示饼图柱状图。

训练模块和预测模块是核心。训练是离线操作，预测是在线操作。训练时要把训练数据从数据库捞出来，构建决策树，然后保存模型对象。预测时读取新学生特征，走一遍树的分支，到达叶子节点得出结果。

4.2 数据库表设计：学生信息表与预测结果表的 SQL

数据库设计要围绕特征和预测需求。下面是一组常见的建表 SQL，可以直接用在 MySQL 8 或 5.7 里。

-- 学生基本信息表 CREATE TABLE student ( id INT PRIMARY KEY AUTO_INCREMENT, student_no VARCHAR(20) NOT NULL UNIQUE, -- 学号 name VARCHAR(50) NOT NULL, gender CHAR(1) DEFAULT 'U', -- M/F/U province VARCHAR(20), -- 生源地 is_cadre TINYINT DEFAULT 0, -- 是否学生干部 gpa DOUBLE DEFAULT 0, -- GPA internship_months INT DEFAULT 0, -- 实习月数 certificate_count INT DEFAULT 0, -- 证书数量 competition_count INT DEFAULT 0, -- 竞赛次数 is_employed TINYINT, -- 真实就业标签，训练用 created_at DATETIME DEFAULT CURRENT_TIMESTAMP, INDEX idx_gpa (gpa), INDEX idx_employed (is_employed) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4; -- 就业预测结果表 CREATE TABLE prediction ( id INT PRIMARY KEY AUTO_INCREMENT, student_no VARCHAR(20) NOT NULL, model_version VARCHAR(50), -- 模型版本，方便回滚 predict_result TINYINT NOT NULL, -- 1:就业成功, 0:未就业 predict_probability DOUBLE, -- 就业成功概率 predict_time DATETIME DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (student_no) REFERENCES student(student_no) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

设计时注意几点：student_no设成唯一索引，避免同一条记录重复训练导致数据泄漏。is_employed字段是训练用的标签，只有历史学生有值，新学生是 NULL，预测时不能把 NULL 当特征。prediction表里加model_version字段，因为模型迭代后，你要能追溯某次预测是哪个版本产生的。所有字符串字段都用utf8mb4，不然中文会乱码。

4.3 模型训练接口与预测接口：把算法接到 Web 层

现在把决策树算法暴露成 HTTP 接口。用一个DecisionTreeService封装训练和预测。这里给出 Spring Boot Controller 的核心代码。

@RestController @RequestMapping("/api/predict") public class PredictController { private final DecisionTreeService treeService; public PredictController(DecisionTreeService treeService) { this.treeService = treeService; } // 训练接口：从数据库读取历史数据，构建决策树，保存模型文件 @PostMapping("/train") public Map<String, Object> train() { List<Student> students = studentRepository.findByIsEmployedNotNull(); List<String[]> dataset = convertToDataset(students); treeService.train(dataset); Map<String, Object> res = new HashMap<>(); res.put("code", 0); res.put("message", "训练完成，准确率 " + treeService.getAccuracy()); return res; } // 预测接口：传入学号，返回预测结果 @PostMapping("/{studentNo}") public Map<String, Object> predict(@PathVariable String studentNo) { Student student = studentRepository.findByStudentNo(studentNo); String[] features = buildFeatureArray(student); Prediction p = treeService.predict(features); Map<String, Object> res = new HashMap<>(); res.put("result", p.isEmployed()); res.put("probability", p.getProbability()); return res; } }

convertToDataset方法负责把Student实体转成特征数组，顺序必须和训练时完全一致。我一般的做法是把特征顺序定义成一个常量列表，比如[gender, province, gpaLevel, internshipLevel, certificateLevel]，训练和预测都用同一个列表去取值，避免顺序错乱。buildFeatureArray里同样调用分箱和编码工具类。

这里要注意：训练接口不要每次请求都触发，因为训练一棵深树可能要几秒甚至几十秒。常见做法是训练完成把TreeNode对象序列化到磁盘，预测时读文件。下一章会讲序列化的坑。

5. 必踩的坑与排查：就业预测系统里常见的五个翻车场景

5.1 准确率虚高：训练集和测试集不分开的后果

现象：跑训练时显示准确率 98%，但拿一批新学生预测，结果惨不忍睹。

原因：很多初学项目在训练时直接把所有数据喂给决策树，不预留测试集。决策树把每个样本的特征和标签都记住了，尤其是没有剪枝时，训练集准确率必然接近 100%，但泛化能力极差。这就是常说的“用自己的卷子考自己”。

解决：把数据按 7:3 或 8:2 划分成训练集和测试集。用训练集建树，用测试集算准确率。划分时要随机打乱，不能按学号顺序切。Java 里可以用Collections.shuffle再取前 N 条。如果样本量小，用十折交叉验证更可靠。

5.2 样本不平衡：就业成功样本只有 15% 时模型全预测“不就业”

现象：学校整体就业率 90%，但你们数据集里只有 15% 的学生没找到工作。决策树训练完，把所有学生都预测成“找到工作”，模型准确率 85%，看起来不错，但你想预测的“找不到工作”群体一个都没识别出来。

原因：决策树分裂时熵降低最快的方式是偏向多数类。叶子节点预测的标签往往就是训练集里的多数类。

解决：三种办法。一是欠采样，把找到工作的样本随机删掉一部分，让两类样本数量接近；二是过采样，复制未就业样本（注意要用 SMOTE 这种合成方式，单纯复制容易过拟合）；三是调整阈值，不直接用叶子节点的多数类，而是用叶子节点的概率，判断时把阈值从 0.5 调低，比如预测就业概率低于 0.3 才判为未就业。我建议先做欠采样，最简单且可解释。

5.3 树模型持久化：Java 序列化保存决策树

现象：系统重启后，训练好的模型丢了，每次都要重新训练，页面响应很慢。

原因：决策树对象只存在于内存里。服务一重启，所有TreeNode对象被回收。

解决：用 Java 内置序列化把树对象写到文件。

// 保存决策树对象到文件 public static void saveModel(TreeNode root, String modelPath) throws IOException { try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(modelPath))) { oos.writeObject(root); } } // 从文件加载模型 public static TreeNode loadModel(String modelPath) throws IOException, ClassNotFoundException { try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(modelPath))) { return (TreeNode) ois.readObject(); } }

注意TreeNode类必须实现Serializable接口，否则会抛NotSerializableException。另外，模型文件要放在系统配置文件指定的路径，不能放在临时目录。如果用了 Weka 的 J48，建议用weka.core.SerializationHelper，它能处理更多内部状态。这里提醒一下：序列化版本号要显式指定，否则类结构一变，加载时反序列化失败。

5.4 过拟合：决策树深度太大，100% 准确率不可信

现象：生成的决策树深度达到十几层，每个叶子节点只有一两条记录，训练准确率 100%，测试准确率反而很低。

原因：递归分裂没有终止条件，每个样本都被分到独立的叶子。

解决：剪枝。预剪枝是在分裂前判断：如果当前节点样本数小于minSamples，就不split；或者分裂后增益小于某个阈值，就不split。后剪枝是树建好后自底向上合并叶子节点。Weka J48 的-M 2参数设置最小叶子样本数为 2，-C 0.25设置置信度阈值，都是控制过拟合的常用手段。自研代码里最简单的是限制树最大深度，比如超过 5 层就不再分裂。

// 在build方法里增加深度和最小样本数控制 private TreeNode build(List<String[]> subset, List<Integer> featureIndexes, int depth) { // 达到最大深度或样本数太少，生成叶子 if (depth >= maxDepth || subset.size() < minSamples) { node.isLeaf = true; node.prediction = getMajorityLabel(subset); return node; } // ... 原有递归逻辑，调用时 depth + 1 }

具体参数怎么设？我一般先试maxDepth=5, minSamples=10，再根据训练集和测试集准确率差距调整。如果训练准确率很高、测试准确率明显低，说明过拟合，增大minSamples或减小maxDepth；如果两边都低，说明欠拟合，反向调整。

5.5 中文乱码和数值映射错位

现象：从数据库读出的中文变成“???”，预测结果和实际名称对不上。

原因：JDBC 连接没有指定 UTF-8，或者 MySQL 表结构是latin1，或者特征编码顺序在训练和预测时不一致。

解决：JDBC URL 末尾加?useUnicode=true&characterEncoding=utf8。建表时统一用utf8mb4。特征编码不要散落在各个方法里，定义一个FeatureMapper类，把所有特征值映射到整数，训练和预测共用同一个实例。乱码问题还有一个隐秘来源是 Excel 导入，如果用户上传的是 GBK 编码的 CSV，要用InputStreamReader指定GBK读取，而不是用默认编码。

6. 从“能跑”到“能答辩”：模型评估与可视化验证的几个技巧

6.1 用交叉验证得出可信准确率：十折交叉验证的写法

单次划分训练集和测试集受随机影响大。比如你切出的测试集碰巧都是容易就业的学生，准确率就虚高。十折交叉验证是论文里最常用的方法：把数据分成 10 份，轮流拿 9 份训练、1 份测试，最后算 10 次准确率的平均值和标准差。

// 用Weka J48做十折交叉验证 public void evaluate(Instances data) throws Exception { data.setClassIndex(data.numAttributes() - 1); J48 classifier = new J48(); classifier.setOptions(new String[]{"-C", "0.25", "-M", "2"}); Evaluation eval = new Evaluation(data); eval.crossValidateModel(classifier, data, 10, new Random(1)); System.out.println("准确率: " + eval.pctCorrect()); System.out.println("混淆矩阵: \n" + eval.toMatrixString()); }

Weka 的Evaluation类会帮我们完成折交叉验证。特别注意Random(1)这个种子，固定种子能让实验可复现——每次跑结果一样，答辩时老师问到也说得出原因。如果不用 Weka，自研十折交叉验证就是切 10 份循环调用，代码会比较长，但逻辑一样。

6.2 把决策树画出来：用 Graphviz 导出树结构给论文加分

决策树最大的优势是可解释性。论文里放一张决策树图，比放一堆准确率数字更有说服力。常见做法是把训练好的树输出成 DOT 文件，再用 Graphviz 转成 PNG。

// 递归输出DOT文件内容 public void toDot(TreeNode node, StringBuilder sb, int nodeId) { if (node.isLeaf) { sb.append(" node").append(nodeId) .append(" [label=\"").append(node.prediction).append("\"];\n"); } else { for (Map.Entry<String, TreeNode> child : node.children.entrySet()) { int childId = nodeId * 10 + childIndex++; sb.append(" node").append(nodeId) .append(" -> node").append(childId) .append(" [label=\" ").append(child.getKey()).append(" \"];\n"); toDot(child.getValue(), sb, childId); } } }

注意，这个简单的 ID 生成方式有 bug，当子节点多时可能重复，实际写的时候建议用全局自增 ID。生成的 DOT 文件内容类似：

digraph Tree { node0 [label="gpaLevel"]; node0 -> node1 [label="good"]; node1 [label="1"]; }

然后在命令行执行dot -Tpng tree.dot -o tree.png，就能得到树图。如果环境里没有 Graphviz，也可以用-Tsvg输出矢量图。Weka 自带的可视化工具也能看到树结构，写论文时截图更快捷。

6.3 混淆矩阵与 ROC 曲线：让预测结果一目了然

准确率只能说明整体正确比例。在就业预测里，你更关心“没找到工作的学生中有多少被成功预测出来了”。这就需要用到混淆矩阵。以二分类为例，把预测结果分成四类：真阳性（TP）、假阳性（FP）、真阴性（TN）、假阴性（FN）。对“预测未就业”这个阳性事件，召回率 = TP / (TP + FN)，精确率 = TP / (TP + FP)。

// 计算预测结果的混淆矩阵 public void printConfusionMatrix(int[] actual, int[] predicted) { int tp = 0, fp = 0, tn = 0, fn = 0; for (int i = 0; i < actual.length; i++) { if (predicted[i] == 1) { if (actual[i] == 1) tp++; else fp++; } else { if (actual[i] == 0) tn++; else fn++; } } System.out.printf("TP=%d FP=%d FN=%d TN=%d%n", tp, fp, fn, tn); System.out.printf("召回率=%.3f 精确率=%.3f%n", tp / (double)(tp + fn), tp / (double)(tp + fp)); }

ROC 曲线要遍历不同阈值，画出召回率和误报率的关系。自研麻烦，建议用 Weka 的eval.toThumbNail()或eval.getCurve()。论文里放 ROC 曲线，然后计算 AUC 值——AUC 大于 0.8 说明模型有区分能力。如果 AUC 只有 0.5 左右，那基本等于抛硬币，赶紧回去检查特征。

我做过两届带毕业设计的项目，最大的体会是：决策树算法本身不是瓶颈，真正让人熬夜的是特征对齐和模型持久化。每次新学生数据进来，你都要确认分箱规则是否一致、编码字典是否更新，否则模型再漂亮也是空中楼阁。希望这篇文章能帮你把就业预测系统从“跑通”做到“能答辩、能落地”这一步，少踩几个坑。

本文还有配套的精品资源，点击获取