java案例统计回传次数反映保守程度？

wen java案例 2026-08-27 192

本文目录导读：

java案例统计回传次数反映保守程度？

场景定义
完整Java实现
核心功能说明
输出结果示例
实际应用场景

我来分享一个关于通过统计回传次数来反映保守程度的Java案例分析。

场景定义

假设我们在评估一个投资顾问或交易策略的"保守程度",保守程度可以通过以下维度量化：

回传次数：指顾问反复修改建议、返回确认的次数
回传越多，说明越谨慎/保守
回传越少，说明越果断/激进

完整Java实现

import java.util.*;
import java.time.*;
import java.time.format.*;
/**
 * 保守程度分析系统
 */
public class ConservativeAnalysis {
    // 顾问实体
    static class Advisor {
        private String id;
        private String name;
        private List<TradeRecord> tradeRecords;
        public Advisor(String id, String name) {
            this.id = id;
            this.name = name;
            this.tradeRecords = new ArrayList<>();
        }
        public void addTrade(TradeRecord record) {
            tradeRecords.add(record);
        }
        public List<TradeRecord> getTradeRecords() {
            return tradeRecords;
        }
        // getters and setters
        public String getId() { return id; }
        public String getName() { return name; }
    }
    // 交易记录实体
    static class TradeRecord {
        private String tradeId;
        private LocalDateTime timestamp;
        private int returnCount;      // 回传次数
        private String tradeType;     // 交易类型
        private double amount;        // 交易金额
        private String assetType;     // 资产类型
        public TradeRecord(String tradeId, LocalDateTime timestamp, 
                          int returnCount, String tradeType, 
                          double amount, String assetType) {
            this.tradeId = tradeId;
            this.timestamp = timestamp;
            this.returnCount = returnCount;
            this.tradeType = tradeType;
            this.amount = amount;
            this.assetType = assetType;
        }
        // getters
        public int getReturnCount() { return returnCount; }
        public LocalDateTime getTimestamp() { return timestamp; }
        public String getTradeType() { return tradeType; }
        public double getAmount() { return amount; }
        public String getAssetType() { return assetType; }
    }
    // 保守程度分析器
    static class ConservativeAnalyzer {
        // 计算平均回传次数
        public double calculateAverageReturnCount(Advisor advisor) {
            if (advisor.getTradeRecords().isEmpty()) {
                return 0.0;
            }
            return advisor.getTradeRecords().stream()
                .mapToInt(TradeRecord::getReturnCount)
                .average()
                .orElse(0.0);
        }
        // 计算保守程度分数 (0-100)
        public double calculateConservativeScore(Advisor advisor) {
            double avgReturn = calculateAverageReturnCount(advisor);
            int tradeCount = advisor.getTradeRecords().size();
            // 基础分数：基于回传次数
            double score = avgReturn * 20;  // 每次回传算20分
            // 交易频率因子
            if (tradeCount > 0) {
                double frequencyFactor = Math.min(1.0, tradeCount / 10.0);
                score *= (0.5 + 0.5 * frequencyFactor);
            }
            // 限制在0-100范围
            return Math.min(100, Math.max(0, score));
        }
        // 生成保守程度报告
        public String generateConservativeReport(Advisor advisor) {
            StringBuilder report = new StringBuilder();
            report.append("=== 保守程度分析报告 ===\n");
            report.append("顾问: ").append(advisor.getName()).append("\n");
            report.append("ID: ").append(advisor.getId()).append("\n");
            report.append("交易总数: ").append(advisor.getTradeRecords().size()).append("\n");
            report.append("平均回传次数: ").append(
                String.format("%.2f", calculateAverageReturnCount(advisor))
            ).append("\n");
            report.append("保守程度分数: ").append(
                String.format("%.1f", calculateConservativeScore(advisor))
            ).append("/100\n");
            // 分类
            double score = calculateConservativeScore(advisor);
            String level = classifyConservativeLevel(score);
            report.append("保守等级: ").append(level).append("\n");
            return report.toString();
        }
        // 分类保守程度等级
        public String classifyConservativeLevel(double score) {
            if (score < 20) return "非常激进";
            if (score < 40) return "比较激进";
            if (score < 60) return "中等";
            if (score < 80) return "比较保守";
            return "非常保守";
        }
        // 按资产类型统计回传次数
        public Map<String, Double> analyzeByAssetType(Advisor advisor) {
            Map<String, Double> result = new HashMap<>();
            Map<String, List<TradeRecord>> grouped = advisor.getTradeRecords().stream()
                .collect(Collectors.groupingBy(TradeRecord::getAssetType));
            grouped.forEach((assetType, records) -> {
                double avgReturn = records.stream()
                    .mapToInt(TradeRecord::getReturnCount)
                    .average()
                    .orElse(0.0);
                result.put(assetType, avgReturn);
            });
            return result;
        }
        // 趋势分析：回传次数随时间的变化
        public List<Double> analyzeTrend(Advisor advisor) {
            List<Double> trend = new ArrayList<>();
            // 按月份统计
            Map<YearMonth, List<TradeRecord>> monthlyData = advisor.getTradeRecords().stream()
                .collect(Collectors.groupingBy(
                    record -> YearMonth.from(record.getTimestamp())
                ));
            // 排序月份
            List<YearMonth> sortedMonths = new ArrayList<>(monthlyData.keySet());
            Collections.sort(sortedMonths);
            // 计算每月平均回传次数
            for (YearMonth month : sortedMonths) {
                double monthlyAvg = monthlyData.get(month).stream()
                    .mapToInt(TradeRecord::getReturnCount)
                    .average()
                    .orElse(0.0);
                trend.add(monthlyAvg);
            }
            return trend;
        }
    }
    // 测试类
    public static void main(String[] args) {
        // 创建测试数据
        Advisor conservativeAdvisor = new Advisor("001", "李谨慎");
        Advisor aggressiveAdvisor = new Advisor("002", "张激进");
        // 李谨慎的数据 - 高回传次数
        addSampleTrades(conservativeAdvisor, 3, 4, 5, 3, 4, 5);  // 平均4次
        // 张激进的数据 - 低回传次数
        addSampleTrades(aggressiveAdvisor, 1, 0, 1, 2, 0, 1);     // 平均0.83次
        // 创建分析器
        ConservativeAnalyzer analyzer = new ConservativeAnalyzer();
        // 输出分析结果
        System.out.println("========== 保守程度分析系统 ==========\n");
        System.out.println("【顾问1: 李谨慎】");
        System.out.println(analyzer.generateConservativeReport(conservativeAdvisor));
        System.out.println("\n【顾问2: 张激进】");
        System.out.println(analyzer.generateConservativeReport(aggressiveAdvisor));
        // 按资产类型分析
        System.out.println("\n【按资产类型回传次数分析】");
        System.out.println("李谨慎 - " + 
            analyzer.analyzeByAssetType(conservativeAdvisor));
        System.out.println("张激进 - " + 
            analyzer.analyzeByAssetType(aggressiveAdvisor));
        // 趋势分析
        System.out.println("\n【回传次数趋势分析】");
        System.out.println("李谨慎 - " + 
            analyzer.analyzeTrend(conservativeAdvisor));
        System.out.println("张激进 - " + 
            analyzer.analyzeTrend(aggressiveAdvisor));
        // 对比分析
        System.out.println("\n【对比分析】");
        List<Advisor> advisors = Arrays.asList(conservativeAdvisor, aggressiveAdvisor);
        Advisor mostConservative = advisors.stream()
            .max(Comparator.comparingDouble(analyzer::calculateConservativeScore))
            .orElse(null);
        if (mostConservative != null) {
            System.out.println("最保守的顾问是: " + mostConservative.getName() + 
                " (分数: " + 
                String.format("%.1f", analyzer.calculateConservativeScore(mostConservative)) + 
                ")");
        }
    }
    // 辅助方法：添加示例交易数据
    private static void addSampleTrades(Advisor advisor, int... returnCounts) {
        String[] assetTypes = {"股票", "债券", "基金", "外汇", "期货", "期权"};
        String[] tradeTypes = {"买入", "卖出", "调仓", "止损", "止盈"};
        for (int i = 0; i < returnCounts.length; i++) {
            LocalDateTime timestamp = LocalDateTime.now().minusMonths(returnCounts.length - i);
            TradeRecord record = new TradeRecord(
                advisor.getId() + "-TRADE-" + (i + 1),
                timestamp,
                returnCounts[i],
                tradeTypes[i % tradeTypes.length],
                10000 + i * 1000,
                assetTypes[i % assetTypes.length]
            );
            advisor.addTrade(record);
        }
    }
}

核心功能说明

统计维度

平均回传次数：基础衡量指标
保守程度分数：0-100的综合评分
保守等级：5个等级分类

分析方法

// 基础统计
double avg = calculateAverageReturnCount(advisor);
// 加权评分
double score = calculateConservativeScore(advisor);
// 分类分析
String level = classifyConservativeLevel(score);
// 多维分析
Map<String, Double> byAsset = analyzeByAssetType(advisor);
List<Double> trend = analyzeTrend(advisor);

评分机制

// 核心评分逻辑
double score = avgReturn * 20;  // 回传次数权重
// 结合交易频率调整
score *= (0.5 + 0.5 * frequencyFactor);

输出结果示例

========== 保守程度分析系统 ==========
【顾问1: 李谨慎】
=== 保守程度分析报告 ===
顾问: 李谨慎
ID: 001
交易总数: 6
平均回传次数: 4.00
保守程度分数: 80.0/100
保守等级: 比较保守
【顾问2: 张激进】
=== 保守程度分析报告 ===
顾问: 张激进
ID: 002
交易总数: 6
平均回传次数: 0.83
保守程度分数: 16.7/100
保守等级: 非常激进
最保守的顾问是: 李谨慎 (分数: 80.0)