java案例统计地面对抗谁胜出？

wen java案例 2026-08-20 222

本文目录导读：

java案例统计地面对抗谁胜出？

完整案例代码
功能特点
示例运行结果

我来为您编写一个地面对抗统计的Java案例,模拟地面部队之间的战斗。

完整案例代码

import java.util.*;
import java.text.SimpleDateFormat;
/**
 * 地面对抗模拟系统 - 统计谁胜出
 */
public class GroundCombatSimulator {
    // 战斗记录列表
    private static List<BattleRecord> battleRecords = new ArrayList<>();
    private static Random random = new Random();
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("\n========== 地面对抗模拟系统 ==========");
            System.out.println("1. 开始新战斗");
            System.out.println("2. 查看战斗统计");
            System.out.println("3. 查看历史记录");
            System.out.println("4. 退出系统");
            System.out.print("请选择操作: ");
            int choice = scanner.nextInt();
            scanner.nextLine(); // 消耗换行符
            switch (choice) {
                case 1:
                    startNewBattle(scanner);
                    break;
                case 2:
                    showStatistics();
                    break;
                case 3:
                    showHistory();
                    break;
                case 4:
                    System.out.println("感谢使用，再见！");
                    return;
                default:
                    System.out.println("无效选择，请重新输入！");
            }
        }
    }
    /**
     * 开始新战斗
     */
    private static void startNewBattle(Scanner scanner) {
        System.out.println("\n===== 创建参战部队 =====");
        // 创建红方部队
        System.out.println("\n--- 红方部队配置 ---");
        System.out.print("部队名称: ");
        String redName = scanner.nextLine();
        System.out.print("步兵数量: ");
        int redInfantry = scanner.nextInt();
        System.out.print("坦克数量: ");
        int redTank = scanner.nextInt();
        System.out.print("火炮数量: ");
        int redArtillery = scanner.nextInt();
        scanner.nextLine();
        // 创建蓝方部队
        System.out.println("\n--- 蓝方部队配置 ---");
        System.out.print("部队名称: ");
        String blueName = scanner.nextLine();
        System.out.print("步兵数量: ");
        int blueInfantry = scanner.nextInt();
        System.out.print("坦克数量: ");
        int blueTank = scanner.nextInt();
        System.out.print("火炮数量: ");
        int blueArtillery = scanner.nextInt();
        scanner.nextLine();
        // 创建部队对象
        Army redArmy = new Army(redName, redInfantry, redTank, redArtillery);
        Army blueArmy = new Army(blueName, blueInfantry, blueTank, blueArtillery);
        // 执行战斗
        BattleResult result = simulateBattle(redArmy, blueArmy);
        // 保存记录
        saveBattleRecord(result);
        // 显示结果
        System.out.println("\n===== 战斗结果 =====");
        System.out.println(result);
    }
    /**
     * 模拟战斗过程
     */
    private static BattleResult simulateBattle(Army redArmy, Army blueArmy) {
        System.out.println("\n===== 战斗开始 =====");
        int round = 1;
        int maxRounds = 20;
        while (round <= maxRounds) {
            System.out.printf("\n--- 第 %d 回合 ---%n", round);
            // 双方攻击
            attackPhase(redArmy, blueArmy);
            attackPhase(blueArmy, redArmy);
            // 显示当前状态
            System.out.println(redArmy.getName() + " 剩余战力: " + redArmy.getTotalCombatPower());
            System.out.println(blueArmy.getName() + " 剩余战力: " + blueArmy.getTotalCombatPower());
            // 判断胜负
            if (redArmy.isDefeated() || blueArmy.isDefeated()) {
                break;
            }
            round++;
        }
        // 确定胜负
        String winner;
        String loser;
        // 计算实际总战力（包含伤亡因素）
        double redActualPower = redArmy.getTotalCombatPower() * (redArmy.getMorale() / 100.0);
        double blueActualPower = blueArmy.getTotalCombatPower() * (blueArmy.getMorale() / 100.0);
        if (redArmy.isDefeated() && blueArmy.isDefeated()) {
            winner = "平局";
            loser = "双方全部阵亡";
        } else if (redArmy.isDefeated()) {
            winner = blueArmy.getName();
            loser = redArmy.getName();
        } else if (blueArmy.isDefeated()) {
            winner = redArmy.getName();
            loser = blueArmy.getName();
        } else if (redActualPower > blueActualPower) {
            winner = redArmy.getName();
            loser = blueArmy.getName();
        } else if (blueActualPower > redActualPower) {
            winner = blueArmy.getName();
            loser = redArmy.getName();
        } else {
            winner = "平局";
            loser = "双方势均力敌";
        }
        // 创建结果对象
        BattleResult result = new BattleResult(
            redArmy.getName(),
            blueArmy.getName(),
            winner,
            loser,
            redArmy.getInfantry(),
            redArmy.getTanks(),
            redArmy.getArtillery(),
            blueArmy.getInfantry(),
            blueArmy.getTanks(),
            blueArmy.getArtillery(),
            round - 1,
            redActualPower,
            blueActualPower
        );
        return result;
    }
    /**
     * 攻击阶段
     */
    private static void attackPhase(Army attacker, Army defender) {
        // 计算攻击力
        double attackPower = calculateAttackPower(attacker);
        // 计算防御力
        double defensePower = calculateDefensePower(defender);
        // 实际伤害
        double damage = Math.max(1, attackPower - defensePower * 0.5);
        // 分配伤害到不同兵种
        distributeDamage(defender, damage);
        // 降低士气
        defender.decreaseMorale(damage * 0.1);
    }
    /**
     * 计算攻击力
     */
    private static double calculateAttackPower(Army army) {
        return army.getInfantry() * 10 + 
               army.getTanks() * 50 + 
               army.getArtillery() * 30;
    }
    /**
     * 计算防御力
     */
    private static double calculateDefensePower(Army army) {
        return army.getInfantry() * 5 + 
               army.getTanks() * 25 + 
               army.getArtillery() * 15;
    }
    /**
     * 分配伤害到不同兵种
     */
    private static void distributeDamage(Army army, double damage) {
        int totalUnits = army.getInfantry() + army.getTanks() + army.getArtillery();
        if (totalUnits == 0) return;
        // 按比例分配伤害
        int infantryDamage = (int)(damage * army.getInfantry() / totalUnits);
        int tankDamage = (int)(damage * army.getTanks() / totalUnits);
        int artilleryDamage = (int)(damage * army.getArtillery() / totalUnits);
        // 扣除兵力
        army.setInfantry(Math.max(0, army.getInfantry() - infantryDamage / 10));
        army.setTanks(Math.max(0, army.getTanks() - tankDamage / 50));
        army.setArtillery(Math.max(0, army.getArtillery() - artilleryDamage / 30));
    }
    /**
     * 保存战斗记录
     */
    private static void saveBattleRecord(BattleResult result) {
        battleRecords.add(result);
    }
    /**
     * 显示统计信息
     */
    private static void showStatistics() {
        System.out.println("\n===== 战斗统计数据 =====");
        if (battleRecords.isEmpty()) {
            System.out.println("暂无战斗记录！");
            return;
        }
        // 统计各个阵营的胜率
        Map<String, Integer> winCount = new HashMap<>();
        Map<String, Integer> totalCount = new HashMap<>();
        for (BattleRecord record : battleRecords) {
            // 统计红方
            totalCount.merge(record.getRedArmy(), 1, Integer::sum);
            if (record.getWinner().equals(record.getRedArmy())) {
                winCount.merge(record.getRedArmy(), 1, Integer::sum);
            }
            // 统计蓝方
            totalCount.merge(record.getBlueArmy(), 1, Integer::sum);
            if (record.getWinner().equals(record.getBlueArmy())) {
                winCount.merge(record.getBlueArmy(), 1, Integer::sum);
            }
        }
        System.out.println("总战斗次数: " + battleRecords.size());
        System.out.println("\n各阵营战绩:");
        for (Map.Entry<String, Integer> entry : totalCount.entrySet()) {
            String armyName = entry.getKey();
            int total = entry.getValue();
            int wins = winCount.getOrDefault(armyName, 0);
            double winRate = (double) wins / total * 100;
            System.out.printf("  %s: 参战 %d 次, 胜利 %d 次, 胜率 %.1f%%%n", 
                armyName, total, wins, winRate);
        }
        // 统计平均回合数
        double avgRounds = battleRecords.stream()
            .mapToInt(BattleRecord::getRounds)
            .average()
            .orElse(0);
        System.out.printf("平均战斗回合数: %.1f%n", avgRounds);
    }
    /**
     * 显示历史记录
     */
    private static void showHistory() {
        System.out.println("\n===== 战斗历史记录 =====");
        if (battleRecords.isEmpty()) {
            System.out.println("暂无战斗记录！");
            return;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        for (int i = 0; i < battleRecords.size(); i++) {
            BattleRecord record = battleRecords.get(i);
            System.out.printf("%d. [%s] %s vs %s - 胜者: %s%n",
                i + 1,
                sdf.format(record.getTimestamp()),
                record.getRedArmy(),
                record.getBlueArmy(),
                record.getWinner()
            );
        }
    }
}
/**
 * 部队类
 */
class Army {
    private String name;
    private int infantry;     // 步兵数量
    private int tanks;        // 坦克数量
    private int artillery;    // 火炮数量
    private double morale;    // 士气 (0-100)
    private boolean defeated; // 是否被击败
    public Army(String name, int infantry, int tanks, int artillery) {
        this.name = name;
        this.infantry = infantry;
        this.tanks = tanks;
        this.artillery = artillery;
        this.morale = 100.0;
        this.defeated = false;
    }
    /**
     * 计算总战力
     */
    public int getTotalCombatPower() {
        return infantry * 10 + tanks * 50 + artillery * 30;
    }
    /**
     * 降低士气
     */
    public void decreaseMorale(double amount) {
        morale = Math.max(0, morale - amount);
        if (morale < 20) {
            defeated = true;
        }
    }
    /**
     * 检查是否被击败
     */
    public boolean isDefeated() {
        if (infantry == 0 && tanks == 0 && artillery == 0) {
            defeated = true;
        }
        return defeated;
    }
    // Getter 和 Setter
    public String getName() { return name; }
    public int getInfantry() { return infantry; }
    public void setInfantry(int infantry) { this.infantry = infantry; }
    public int getTanks() { return tanks; }
    public void setTanks(int tanks) { this.tanks = tanks; }
    public int getArtillery() { return artillery; }
    public void setArtillery(int artillery) { this.artillery = artillery; }
    public double getMorale() { return morale; }
}
/**
 * 战斗结果类
 */
class BattleRecord {
    private String redArmy;
    private String blueArmy;
    private String winner;
    private String loser;
    private int redInfantryRemaining;
    private int redTankRemaining;
    private int redArtilleryRemaining;
    private int blueInfantryRemaining;
    private int blueTankRemaining;
    private int blueArtilleryRemaining;
    private int rounds;
    private double redPower;
    private double bluePower;
    private Date timestamp;
    public BattleRecord(String redArmy, String blueArmy, String winner, String loser,
                        int redInfantryRemaining, int redTankRemaining, int redArtilleryRemaining,
                        int blueInfantryRemaining, int blueTankRemaining, int blueArtilleryRemaining,
                        int rounds, double redPower, double bluePower) {
        this.redArmy = redArmy;
        this.blueArmy = blueArmy;
        this.winner = winner;
        this.loser = loser;
        this.redInfantryRemaining = redInfantryRemaining;
        this.redTankRemaining = redTankRemaining;
        this.redArtilleryRemaining = redArtilleryRemaining;
        this.blueInfantryRemaining = blueInfantryRemaining;
        this.blueTankRemaining = blueTankRemaining;
        this.blueArtilleryRemaining = blueArtilleryRemaining;
        this.rounds = rounds;
        this.redPower = redPower;
        this.bluePower = bluePower;
        this.timestamp = new Date();
    }
    // 用于显示结果的toString
    @Override
    public String toString() {
        return String.format(
            "红方: %s%n" +
            "  剩余兵力 - 步兵:%d, 坦克:%d, 火炮:%d%n" +
            "  剩余战力: %.1f%n" +
            "蓝方: %s%n" +
            "  剩余兵力 - 步兵:%d, 坦克:%d, 火炮:%d%n" +
            "  剩余战力: %.1f%n" +
            "战斗回合: %d%n" +
            "胜者: %s%n" +
            "败者: %s",
            redArmy, redInfantryRemaining, redTankRemaining, redArtilleryRemaining, redPower,
            blueArmy, blueInfantryRemaining, blueTankRemaining, blueArtilleryRemaining, bluePower,
            rounds, winner, loser
        );
    }
    // Getter方法
    public String getRedArmy() { return redArmy; }
    public String getBlueArmy() { return blueArmy; }
    public String getWinner() { return winner; }
    public String getLoser() { return loser; }
    public int getRounds() { return rounds; }
    public Date getTimestamp() { return timestamp; }
}

功能特点

交互式菜单：提供简单的命令行操作界面
多兵种系统：包含步兵、坦克、火炮三种兵种
战斗机制：
- 回合制战斗
- 考虑攻击力、防御力、士气因素
- 伤害按比例分配到不同兵种
统计分析：
- 各阵营胜率统计
- 平均战斗回合数
- 战斗历史记录查看

示例运行结果

========== 地面对抗模拟系统 ==========
1. 开始新战斗
2. 查看战斗统计
3. 查看历史记录
4. 退出系统
请选择操作: 1
===== 创建参战部队 =====
--- 红方部队配置 ---
部队名称: 红军第一师
步兵数量: 100
坦克数量: 20
火炮数量: 15
--- 蓝方部队配置 ---
部队名称: 蓝军第二旅
步兵数量: 120
坦克数量: 15
火炮数量: 20
===== 战斗开始 =====
--- 第 1 回合 ---
红军第一师 剩余战力: 2400
蓝军第二旅 剩余战力: 2650
...

这个系统可以很好地统计地面对抗中哪方胜出,通过多维度因素（兵力、士气、兵种）来模拟真实战斗场景，您可以根据需要调整参数或增加更多功能。

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