Java指标预测案例

wen java案例 2026-07-30 178

我来为您提供一个Java指标预测的完整案例,使用简单的线性回归算法来预测数据趋势。

Java指标预测案例

案例：销售数据预测系统

线性回归预测模型

import java.util.ArrayList;
import java.util.List;
public class LinearRegressionPredictor {
    private double slope;      // 斜率
    private double intercept;  // 截距
    private double[] xValues;
    private double[] yValues;
    /**
     * 训练线性回归模型
     * @param x X轴数据（时间/序列）
     * @param y Y轴数据（指标值）
     */
    public void train(double[] x, double[] y) {
        if (x.length != y.length || x.length < 2) {
            throw new IllegalArgumentException("数据长度不足或数据不匹配");
        }
        this.xValues = x;
        this.yValues = y;
        int n = x.length;
        double sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
        for (int i = 0; i < n; i++) {
            sumX += x[i];
            sumY += y[i];
            sumXY += x[i] * y[i];
            sumX2 += x[i] * x[i];
        }
        // 计算斜率和截距
        slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
        intercept = (sumY - slope * sumX) / n;
        System.out.println("模型训练完成：");
        System.out.printf("斜率: %.4f, 截距: %.4f\n", slope, intercept);
    }
    /**
     * 预测未来值
     * @param futureX 未来的X值
     * @return 预测的Y值
     */
    public double predict(double futureX) {
        return slope * futureX + intercept;
    }
    /**
     * 批量预测未来多个值
     * @param futureSteps 预测步数
     * @return 预测值数组
     */
    public double[] predictFuture(int futureSteps) {
        double[] predictions = new double[futureSteps];
        double lastX = xValues[xValues.length - 1];
        for (int i = 0; i < futureSteps; i++) {
            predictions[i] = predict(lastX + i + 1);
        }
        return predictions;
    }
    /**
     * 计算R平方（拟合优度）
     */
    public double calculateR2() {
        double meanY = 0;
        for (double y : yValues) {
            meanY += y;
        }
        meanY /= yValues.length;
        double ssRes = 0, ssTot = 0;
        for (int i = 0; i < yValues.length; i++) {
            double predicted = predict(xValues[i]);
            ssRes += Math.pow(yValues[i] - predicted, 2);
            ssTot += Math.pow(yValues[i] - meanY, 2);
        }
        return 1 - (ssRes / ssTot);
    }
}

时间序列数据处理器

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.*;
public class TimeSeriesProcessor {
    private List<DataPoint> dataPoints;
    public TimeSeriesProcessor() {
        this.dataPoints = new ArrayList<>();
    }
    /**
     * 添加数据点
     */
    public void addDataPoint(LocalDate date, double value) {
        dataPoints.add(new DataPoint(date, value));
    }
    /**
     * 将日期转换为数值序列
     */
    public double[] convertToNumericArray() {
        double[] numericValues = new double[dataPoints.size()];
        LocalDate startDate = dataPoints.get(0).getDate();
        for (int i = 0; i < dataPoints.size(); i++) {
            long daysDiff = ChronoUnit.DAYS.between(startDate, dataPoints.get(i).getDate());
            numericValues[i] = daysDiff;
        }
        return numericValues;
    }
    /**
     * 获取指标值数组
     */
    public double[] getValueArray() {
        return dataPoints.stream()
                .mapToDouble(DataPoint::getValue)
                .toArray();
    }
    /**
     * 数据平滑处理（移动平均）
     */
    public double[] movingAverage(int windowSize) {
        double[] values = getValueArray();
        double[] smoothed = new double[values.length - windowSize + 1];
        for (int i = 0; i < smoothed.length; i++) {
            double sum = 0;
            for (int j = 0; j < windowSize; j++) {
                sum += values[i + j];
            }
            smoothed[i] = sum / windowSize;
        }
        return smoothed;
    }
    // 数据点内部类
    private static class DataPoint {
        private LocalDate date;
        private double value;
        public DataPoint(LocalDate date, double value) {
            this.date = date;
            this.value = value;
        }
        public LocalDate getDate() { return date; }
        public double getValue() { return value; }
    }
}

异常检测和预警系统

import java.util.*;
public class AnomalyDetectionSystem {
    private LinearRegressionPredictor predictor;
    private double threshold;
    public AnomalyDetectionSystem(double threshold) {
        this.predictor = new LinearRegressionPredictor();
        this.threshold = threshold;
    }
    /**
     * 检测异常值
     */
    public List<AnomalyResult> detectAnomalies(double[] x, double[] y) {
        List<AnomalyResult> anomalies = new ArrayList<>();
        predictor.train(x, y);
        double[] residuals = new double[y.length];
        double meanResidual = 0;
        // 计算残差
        for (int i = 0; i < y.length; i++) {
            double predicted = predictor.predict(x[i]);
            residuals[i] = Math.abs(y[i] - predicted);
            meanResidual += residuals[i];
        }
        meanResidual /= y.length;
        // 检测异常
        for (int i = 0; i < y.length; i++) {
            if (residuals[i] > threshold * meanResidual) {
                anomalies.add(new AnomalyResult(
                    x[i], y[i], predictor.predict(x[i]), 
                    "异常值检测", residuals[i]
                ));
            }
        }
        return anomalies;
    }
    /**
     * 生成预警报告
     */
    public String generateAlertReport(List<AnomalyResult> anomalies) {
        StringBuilder report = new StringBuilder();
        report.append("=== 异常预警报告 ===\n");
        report.append("检测时间: ").append(new Date()).append("\n\n");
        if (anomalies.isEmpty()) {
            report.append("状态: 正常，未检测到异常\n");
        } else {
            report.append("检测到 ").append(anomalies.size()).append(" 个异常点:\n");
            for (AnomalyResult anomaly : anomalies) {
                report.append(anomaly.toString()).append("\n");
            }
        }
        return report.toString();
    }
    // 异常结果内部类
    public static class AnomalyResult {
        private double x;
        private double actualValue;
        private double predictedValue;
        private String reason;
        private double deviation;
        public AnomalyResult(double x, double actual, double predicted, 
                           String reason, double deviation) {
            this.x = x;
            this.actualValue = actual;
            this.predictedValue = predicted;
            this.reason = reason;
            this.deviation = deviation;
        }
        @Override
        public String toString() {
            return String.format("x=%.0f: 实际值=%.2f, 预测值=%.2f, 偏差=%.2f, 原因=%s", 
                x, actualValue, predictedValue, deviation, reason);
        }
    }
}

完整示例：销售预测系统

import java.time.LocalDate;
import java.util.*;
public class SalesPredictionSystem {
    public static void main(String[] args) {
        // 创建时间序列处理器
        TimeSeriesProcessor processor = new TimeSeriesProcessor();
        // 模拟历史销售数据（过去12个月）
        System.out.println("=== 销售数据 ===");
        LocalDate startDate = LocalDate.of(2023, 1, 1);
        double[] salesData = {100, 110, 120, 115, 130, 140, 
                             135, 145, 155, 150, 160, 170};
        for (int i = 0; i < salesData.length; i++) {
            LocalDate date = startDate.plusMonths(i);
            processor.addDataPoint(date, salesData[i]);
            System.out.printf("月份: %s, 销售额: %.0f\n", date, salesData[i]);
        }
        // 训练预测模型
        System.out.println("\n=== 模型训练 ===");
        LinearRegressionPredictor predictor = new LinearRegressionPredictor();
        double[] xValues = processor.convertToNumericArray();
        double[] yValues = processor.getValueArray();
        predictor.train(xValues, yValues);
        // 计算R平方值
        double r2 = predictor.calculateR2();
        System.out.printf("R平方值（拟合优度）: %.4f\n", r2);
        // 预测未来3个月
        System.out.println("\n=== 预测未来3个月 ===");
        double[] futurePredictions = predictor.predictFuture(3);
        for (int i = 0; i < futurePredictions.length; i++) {
            LocalDate futureDate = startDate.plusMonths(salesData.length + i);
            System.out.printf("预测月份: %s, 预测销售额: %.0f\n", 
                futureDate, futurePredictions[i]);
        }
        // 异常检测
        System.out.println("\n=== 异常检测 ===");
        AnomalyDetectionSystem detectionSystem = new AnomalyDetectionSystem(2.0);
        List<AnomalyDetectionSystem.AnomalyResult> anomalies = 
            detectionSystem.detectAnomalies(xValues, yValues);
        System.out.println(detectionSystem.generateAlertReport(anomalies));
        // 数据平滑处理
        System.out.println("=== 3个月移动平均 ===");
        double[] smoothedData = processor.movingAverage(3);
        System.out.println("平滑后的数据: " + Arrays.toString(smoothedData));
        // 趋势分析报告
        System.out.println("\n=== 趋势分析报告 ===");
        generateTrendReport(predictor, salesData, r2);
    }
    /**
     * 生成趋势分析报告
     */
    private static void generateTrendReport(LinearRegressionPredictor predictor, 
                                          double[] historicalData, double r2) {
        System.out.println("销售趋势分析：");
        System.out.printf("模型斜率为 %.2f，表示每月平均增长 ", predictor.getSlope());
        System.out.printf("从 %.0f 开始基准线", predictor.getIntercept());
        if (predictor.getSlope() > 0) {
            System.out.println("\n趋势: 上升趋势 ↑");
        } else if (predictor.getSlope() < 0) {
            System.out.println("\n趋势: 下降趋势 ↓");
        } else {
            System.out.println("\n趋势: 稳定趋势 →");
        }
        if (r2 > 0.8) {
            System.out.println("模型预测准确性: 高 (R² > 0.8)");
        } else if (r2 > 0.6) {
            System.out.println("模型预测准确性: 中等 (R² > 0.6)");
        } else {
            System.out.println("模型预测准确性: 低 (R² < 0.6)");
        }
    }
}

使用说明和扩展建议

## 使用说明
1. **数据准备**：将您的指标数据按时间顺序输入
2. **模型训练**：调用 `train()` 方法训练模型
3. **预测未来**：使用 `predict()` 或 `predictFuture()` 方法
4. **异常检测**：自动检测数据中的异常值
5. **结果分析**：通过 R² 值评估预测可靠性
## 扩展方向
1. **添加更多算法**：
   - 多项式回归
   - 指数平滑
   - ARIMA 时间序列模型
2. **数据可视化**：
   - 集成 JFreeChart 或 JavaFX
   - 生成趋势图表
3. **数据库支持**：
   - 从数据库读取历史数据
   - 存储预测结果
4. **Web接口**：
   - 使用 Spring Boot 创建 REST API
   - 提供预测服务

这个完整的指标预测系统包括了数据预处理、线性回归预测、异常检测和趋势分析功能，可以直接用于销售、库存、流量等各种业务指标的预测场景。

本文地址： https://www.bmjup.com/post/34201.html