对英雄联盟比赛预测（四）- 数据清洗

最新推荐文章于 2023-02-25 14:57:18 发布
最新推荐文章于 2023-02-25 14:57:18 发布
阅读量1.1k 收藏 6
点赞数 2
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/majixiang1996/article/details/114381471
版权

 

系列文章目录

对英雄联盟比赛预测（一）- 特征分析

对英雄联盟比赛预测（二）- 数据获取api分析

对英雄联盟比赛预测（三）- 数据获取Java实现

对英雄联盟比赛预测（四）- 数据清洗

 

 

前言

本文主要对前文获取的数据，做清洗，去除脏数据，并格式化。

文章三中最新代码：https://github.com/majixiang/riotgames-spider ，欢迎大家指正。

 

一、数据原型

通过前面第三篇文章，介绍从官网获取数据，本人已经获取了26万条数据，也就是13万场比赛，因这些数据都是json格式的，不适合后续处理，所以需要将这些数据合并成csv文件

二、步骤

1. 引入相关依赖

项目使用gradle编译,commons-io用来读写文件，fastjson用来解析json，hutool用来生成csv文件流。

    compileOnly 'org.projectlombok:lombok:1.18.18'
    implementation 'org.apache.commons:commons-lang3:3.11'
    implementation 'commons-io:commons-io:2.6'
    implementation 'com.jayway.jsonpath:json-path:2.4.0'
    implementation 'com.alibaba:fastjson:1.2.75'
    implementation 'cn.hutool:hutool-all:5.5.7'

 

2. 相关实体类

实体类和文章三里一致，并新增一个Game类，用来存放csv的行数据，如下：


import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
 * @author jixiang.ma
 * @date 2021/2/4 11:39
 **/
@Getter
@Setter
@ToString
public class Game {
    private long gameId;
    private long gameCreation;
    private int gameDuration;
    private int queueId;
    private int mapId;
    private int seasonId;

    private int win;
    private int firstBlood;
    private int firstTower;
    private int firstInhibitor;
    private int firstBaron;
    private int firstDragon;
    private int firstRiftHerald;

    private int t1_towerKills;
    private int t1_inhibitorKills;
    private int t1_baronKills;
    private int t1_dragonKills;
    private int t1_vilemawKills;
    private int t1_riftHeraldKills;
    private int t1_dominionVictoryScore;

    // 总击杀数
    private int t1_kills;
    private int t1_deaths;
    private int t1_assists;
    // 整个团队的最大连杀数
    private int t1_largestKillingSpree;
    private int t1_largestMultiKill;
    private int t1_killingSprees;
    private int t1_longestTimeSpentLiving;
    //整个团队双杀的次数
    private int t1_doubleKills;
    private int t1_tripleKills;
    private int t1_quadraKills;
    private int t1_pentaKills;
    private int t1_unrealKills;
    // 团队总伤害
    private int t1_totalDamageDealt;
    // 魔法伤害
    private int t1_magicDamageDealt;
    // 物理伤害
    private int t1_physicalDamageDealt;
    // 真实伤害
    private int t1_trueDamageDealt;
    // 造成的最大伤害
    private int t1_largestCriticalStrike;
    // 对英雄的总伤害
    private int t1_totalDamageDealtToChampions;
    private int t1_magicDamageDealtToChampions;
    private int t1_physicalDamageDealtToChampions;
    private int t1_trueDamageDealtToChampions;
    private int t1_totalHeal;
    private int t1_totalUnitsHealed;
    private int t1_damageSelfMitigated;
    private int t1_damageDealtToObjectives;
    private int t1_damageDealtToTurrets;
    private int t1_visionScore;
    private int t1_timeCCingOthers;
    private int t1_totalDamageTaken;
    private int t1_magicalDamageTaken;
    private int t1_physicalDamageTaken;
    private int t1_trueDamageTaken;
    private int t1_goldEarned;
    private int t1_goldSpent;
    // 补兵数
    private int t1_totalMinionsKilled;
    // 野怪数
    private int t1_neutralMinionsKilled;
    private int t1_totalTimeCrowdControlDealt;
    private int t1_champLevel;
    private int t1_visionWardsBoughtInGame;
    private int t1_sightWardsBoughtInGame;

    private int t2_towerKills;
    private int t2_inhibitorKills;
    private int t2_baronKills;
    private int t2_dragonKills;
    private int t2_vilemawKills;
    private int t2_riftHeraldKills;
    private int t2_dominionVictoryScore;

    // 总击杀数
    private int t2_kills;
    private int t2_deaths;
    private int t2_assists;
    // 整个团队的最大连杀数
    private int t2_largestKillingSpree;
    private int t2_largestMultiKill;
    private int t2_killingSprees;
    private int t2_longestTimeSpentLiving;
    //整个团队双杀的次数
    private int t2_doubleKills;
    private int t2_tripleKills;
    private int t2_quadraKills;
    private int t2_pentaKills;
    private int t2_unrealKills;
    // 团队总伤害
    private int t2_totalDamageDealt;
    // 魔法伤害
    private int t2_magicDamageDealt;
    // 物理伤害
    private int t2_physicalDamageDealt;
    // 真实伤害
    private int t2_trueDamageDealt;
    // 造成的最大伤害
    private int t2_largestCriticalStrike;
    // 对英雄的总伤害
    private int t2_totalDamageDealtToChampions;
    private int t2_magicDamageDealtToChampions;
    private int t2_physicalDamageDealtToChampions;
    private int t2_trueDamageDealtToChampions;
    private int t2_totalHeal;
    private int t2_totalUnitsHealed;
    private int t2_damageSelfMitigated;
    private int t2_damageDealtToObjectives;
    private int t2_damageDealtToTurrets;
    private int t2_visionScore;
    private int t2_timeCCingOthers;
    private int t2_totalDamageTaken;
    private int t2_magicalDamageTaken;
    private int t2_physicalDamageTaken;
    private int t2_trueDamageTaken;
    private int t2_goldEarned;
    private int t2_goldSpent;
    // 补兵数
    private int t2_totalMinionsKilled;
    // 野怪数
    private int t2_neutralMinionsKilled;
    private int t2_totalTimeCrowdControlDealt;
    private int t2_champLevel;
    private int t2_visionWardsBoughtInGame;
    private int t2_sightWardsBoughtInGame;

}

 

3. 清洗


import cn.hutool.Hutool;
import cn.hutool.core.text.csv.CsvUtil;
import cn.hutool.core.text.csv.CsvWriter;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSONPath;
import com.jayway.jsonpath.JsonPath;
import io.transwarp.entity.Match;
import io.transwarp.entity.MatchDetail;
import io.transwarp.entity.Participants;
import io.transwarp.entity.Win;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

/**
 * @author jixiang.ma
 * @date 2021/2/4 10:15
 **/
public class DataClean {
    public static void main(String[] args) throws IOException {
        // json数据源
        String jsonPath = "E:\\data\\data\\";
        File jsonPathFile = new File(jsonPath);

        if (jsonPathFile.isDirectory()) {
            File[] files = jsonPathFile.listFiles();
            // 要输出的csv路径
            CsvWriter writer = CsvUtil.getWriter(new File("D:/games.csv"), Charset.forName("UTF-8"), true);
            writer.writeLine("gameId",
                    "gameCreation",
                    "gameDuration",
                    "queueId",
                    "mapId",
                    "seasonId",
                    "win",
                    "firstBlood",
                    "firstTower",
                    "firstInhibitor",
                    "firstBaron",
                    "firstDragon",
                    "firstRiftHerald",
                    "t1_towerKills",
                    "t1_inhibitorKills",
                    "t1_baronKills",
                    "t1_dragonKills",
                    "t1_riftHeraldKills",
                    "t1_dominionVictoryScore",
                    "t1_kills",
                    "t1_deaths",
                    "t1_assists",
                    "t1_largestKillingSpree",
                    "t1_largestMultiKill",
                    "t1_killingSprees",
                    "t1_longestTimeSpentLiving",
                    "t1_doubleKills",
                    "t1_tripleKills",
                    "t1_quadraKills",
                    "t1_pentaKills",
                    "t1_unrealKills",
                    "t1_totalDamageDealt",
                    "t1_magicDamageDealt",
                    "t1_physicalDamageDealt",
                    "t1_trueDamageDealt",
                    "t1_largestCriticalStrike",
                    "t1_totalDamageDealtToChampions",
                    "t1_magicDamageDealtToChampions",
                    "t1_physicalDamageDealtToChampion",
                    "t1_trueDamageDealtToChampions",
                    "t1_totalHeal",
                    "t1_totalUnitsHealed",
                    "t1_damageSelfMitigated",
                    "t1_damageDealtToObjectives",
                    "t1_damageDealtToTurrets",
                    "t1_visionScore",
                    "t1_timeCCingOthers",
                    "t1_totalDamageTaken",
                    "t1_magicalDamageTaken",
                    "t1_physicalDamageTaken",
                    "t1_trueDamageTaken",
                    "t1_goldEarned",
                    "t1_goldSpent",
                    "t1_totalMinionsKilled",
                    "t1_neutralMinionsKilled",
                    "t1_totalTimeCrowdControlDealt",
                    "t1_champLevel",
                    "t1_visionWardsBoughtInGame",
                    "t1_sightWardsBoughtInGame",


                    "t2_towerKills",
                    "t2_inhibitorKills",
                    "t2_baronKills",
                    "t2_dragonKills",
                    "t2_riftHeraldKills",
                    "t2_dominionVictoryScore",
                    "t2_kills",
                    "t2_deaths",
                    "t2_assists",
                    "t2_largestKillingSpree",
                    "t2_largestMultiKill",
                    "t2_killingSprees",
                    "t2_longestTimeSpentLiving",
                    "t2_doubleKills",
                    "t2_tripleKills",
                    "t2_quadraKills",
                    "t2_pentaKills",
                    "t2_unrealKills",
                    "t2_totalDamageDealt",
                    "t2_magicDamageDealt",
                    "t2_physicalDamageDealt",
                    "t2_trueDamageDealt",
                    "t2_largestCriticalStrike",
                    "t2_totalDamageDealtToChampions",
                    "t2_magicDamageDealtToChampions",
                    "t2_physicalDamageDealtToChampions",
                    "t2_trueDamageDealtToChampions",
                    "t2_totalHeal",
                    "t2_totalUnitsHealed",
                    "t2_damageSelfMitigated",
                    "t2_damageDealtToObjectives",
                    "t2_damageDealtToTurrets",
                    "t2_visionScore",
                    "t2_timeCCingOthers",
                    "t2_totalDamageTaken",
                    "t2_magicalDamageTaken",
                    "t2_physicalDamageTaken",
                    "t2_trueDamageTaken",
                    "t2_goldEarned",
                    "t2_goldSpent",
                    "t2_totalMinionsKilled",
                    "t2_neutralMinionsKilled",
                    "t2_totalTimeCrowdControlDealt",
                    "t2_champLevel",
                    "t2_visionWardsBoughtInGame",
                    "t2_sightWardsBoughtInGame");
            for (File file : files) {
                if (file.getName().contains("detail")) {
                    System.out.println("current file is : " + file.getName());
                    String data = FileUtils.readFileToString(file, Charset.forName("UTF-8"));
                    MatchDetail matchDetail = JSONObject.toJavaObject(JSONObject.parseObject(data), MatchDetail.class);
                    if(null == matchDetail.getGameId()) {
                        continue;
                    }
                    writer.writeLine(matchDetail.getGameId().toString(),
                            matchDetail.getGameCreation().toString(),
                            matchDetail.getGameDuration().toString(),
                            matchDetail.getQueueId().toString(),
                            matchDetail.getMapId().toString(),
                            matchDetail.getSeasonId().toString(),
                            getWin(matchDetail),
                            getFirstBlood(matchDetail),
                            getFirstTower(matchDetail),
                            getFirstInhibitor(matchDetail),
                            getFirstBaron(matchDetail),
                            getFirstDragon(matchDetail),
                            getFirstRiftHerald(matchDetail),
                            getTowerKills(matchDetail, 1),
                            getInhibitorKills(matchDetail, 1),
                            getBaronKills(matchDetail, 1),
                            getDragonKills(matchDetail, 1),
                            getRiftHeraldKills(matchDetail, 1),
                            getDominionVictoryScore(matchDetail, 1),
                            getKills(matchDetail, 1),
                            getDeaths(matchDetail, 1),
                            getAssists(matchDetail, 1),
                            getLargestKillingSpree(matchDetail, 1),
                            getLargestMultiKill(matchDetail, 1),
                            getKillSprees(matchDetail, 1),
                            getLongestTimeSpentLiving(matchDetail, 1),
                            getDoubleKills(matchDetail, 1),
                            getTripleKills(matchDetail, 1),
                            getQuadraKills(matchDetail, 1),
                            getPentaKills(matchDetail, 1),
                            getTotalDamageDealt(matchDetail, 1),
                            getMagicDamageDealt(matchDetail, 1),
                            getPhysicalDamageDealt(matchDetail, 1),
                            getTrueDamageDealt(matchDetail, 1),
                            getLargestCriticalStrike(matchDetail, 1),
                            getTotalDamageDealtToChampions(matchDetail, 1),
                            getMagicDamageDealtToChampions(matchDetail, 1),
                            getPhysicalDamageDealtToChampions(matchDetail, 1),
                            getTrueDamageDealtToChampions(matchDetail, 1),
                            getTotalHeal(matchDetail, 1),
                            getTotalUnitsHealed(matchDetail, 1),
                            getDamageSelfMitigated(matchDetail, 1),
                            getDamageDealtToObjectives(matchDetail, 1),
                            getDamageDealtToTurrets(matchDetail, 1),
                            getVisionScore(matchDetail, 1),
                            getTimeCCingOthers(matchDetail, 1),
                            getTotalDamageTaken(matchDetail, 1),
                            getMagicalDamageTaken(matchDetail, 1),
                            getPhysicalDamageTaken(matchDetail, 1),
                            getTrueDamageTaken(matchDetail, 1),
                            getGoldEarned(matchDetail, 1),
                            getGoldSpent(matchDetail, 1),
                            getTotalMinionsKilled(matchDetail, 1),
                            getNeutralMinionsKilled(matchDetail, 1),
                            getTotalTimeCrowdControlDealt(matchDetail, 1),
                            getChampLevel(matchDetail, 1),
                            getVisionWardsBoughtInGame(matchDetail, 1),
                            getSightWardsBoughtInGame(matchDetail, 1),

                            getTowerKills(matchDetail, 2),
                            getInhibitorKills(matchDetail, 2),
                            getBaronKills(matchDetail, 2),
                            getDragonKills(matchDetail, 2),
                            getRiftHeraldKills(matchDetail, 2),
                            getDominionVictoryScore(matchDetail, 2),
                            getKills(matchDetail, 2),
                            getDeaths(matchDetail, 2),
                            getAssists(matchDetail, 2),
                            getLargestKillingSpree(matchDetail, 2),
                            getLargestMultiKill(matchDetail, 2),
                            getKillSprees(matchDetail, 2),
                            getLongestTimeSpentLiving(matchDetail, 2),
                            getDoubleKills(matchDetail, 2),
                            getTripleKills(matchDetail, 2),
                            getQuadraKills(matchDetail, 2),
                            getPentaKills(matchDetail, 2),
                            getTotalDamageDealt(matchDetail, 2),
                            getMagicDamageDealt(matchDetail, 2),
                            getPhysicalDamageDealt(matchDetail, 2),
                            getTrueDamageDealt(matchDetail, 2),
                            getLargestCriticalStrike(matchDetail, 2),
                            getTotalDamageDealtToChampions(matchDetail, 2),
                            getMagicDamageDealtToChampions(matchDetail, 2),
                            getPhysicalDamageDealtToChampions(matchDetail, 2),
                            getTrueDamageDealtToChampions(matchDetail, 2),
                            getTotalHeal(matchDetail, 2),
                            getTotalUnitsHealed(matchDetail, 2),
                            getDamageSelfMitigated(matchDetail, 2),
                            getDamageDealtToObjectives(matchDetail, 2),
                            getDamageDealtToTurrets(matchDetail, 2),
                            getVisionScore(matchDetail, 2),
                            getTimeCCingOthers(matchDetail, 2),
                            getTotalDamageTaken(matchDetail, 2),
                            getMagicalDamageTaken(matchDetail, 2),
                            getPhysicalDamageTaken(matchDetail, 2),
                            getTrueDamageTaken(matchDetail, 2),
                            getGoldEarned(matchDetail, 2),
                            getGoldSpent(matchDetail, 2),
                            getTotalMinionsKilled(matchDetail, 2),
                            getNeutralMinionsKilled(matchDetail, 2),
                            getTotalTimeCrowdControlDealt(matchDetail, 2),
                            getChampLevel(matchDetail, 2),
                            getVisionWardsBoughtInGame(matchDetail, 2),
                            getSightWardsBoughtInGame(matchDetail, 2)
                    );
                }
            }
        }
    }

    private static String getWin(MatchDetail matchDetail) {
        return Win.Win.equals(matchDetail.getTeams().get(0).getWin()) ? "1" : "2";
    }

    private static String getFirstBlood(MatchDetail matchDetail) {
        return matchDetail.getTeams().get(0).getFirstBlood() ? "1" : "2";
    }

    private static String getFirstTower(MatchDetail matchDetail) {
        return matchDetail.getTeams().get(0).getFirstTower() ? "1" : "2";
    }

    private static String getFirstInhibitor(MatchDetail matchDetail) {
        return matchDetail.getTeams().get(0).getFirstInhibitor() ? "1" : "2";
    }

    private static String getFirstBaron(MatchDetail matchDetail) {
        return matchDetail.getTeams().get(0).getFirstBaron() ? "1" : "2";
    }

    private static String getFirstDragon(MatchDetail matchDetail) {
        return matchDetail.getTeams().get(0).getFirstDragon() ? "1" : "2";
    }

    private static String getFirstRiftHerald(MatchDetail matchDetail) {
        return matchDetail.getTeams().get(0).getFirstRiftHerald() ? "1" : "2";
    }

    private static String getTowerKills(MatchDetail matchDetail, int team) {
        return matchDetail.getTeams().get(team - 1).getTowerKills() + "";
    }

    private static String getInhibitorKills(MatchDetail matchDetail, int team) {
        return matchDetail.getTeams().get(team - 1).getTowerKills() + "";
    }

    private static String getBaronKills(MatchDetail matchDetail, int team) {
        return matchDetail.getTeams().get(team - 1).getBaronKills() + "";
    }

    private static String getDragonKills(MatchDetail matchDetail, int team) {
        return matchDetail.getTeams().get(team - 1).getDragonKills() + "";
    }

    private static String getRiftHeraldKills(MatchDetail matchDetail, int team) {
        return matchDetail.getTeams().get(team - 1).getRiftHeraldKills() + "";
    }

    private static String getDominionVictoryScore(MatchDetail matchDetail, int team) {
        return matchDetail.getTeams().get(team - 1).getDominionVictoryScore() + "";
    }

    private static String getKills(MatchDetail matchDetail, int team) {
        int totalKills = filter(matchDetail, team).mapToInt(p -> p.getStats().getKills()).sum();
        return totalKills + "";
    }

    private static String getDeaths(MatchDetail matchDetail, int team) {
        int totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getDeaths()).sum();
        return totalDeaths + "";
    }

    private static String getAssists(MatchDetail matchDetail, int team) {
        int totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getAssists()).sum();
        return totalDeaths + "";
    }

    private static String getLargestKillingSpree(MatchDetail matchDetail, int team) {
        int totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getLargestKillingSpree()).max().orElse(0);
        return totalDeaths + "";
    }

    private static String getLargestMultiKill(MatchDetail matchDetail, int team) {
        int totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getLargestMultiKill()).max().orElse(0);
        return totalDeaths + "";
    }

    private static String getKillSprees(MatchDetail matchDetail, int team) {
        int totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getKillingSprees()).max().orElse(0);
        return totalDeaths + "";
    }

    private static String getLongestTimeSpentLiving(MatchDetail matchDetail, int team) {
        int totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getLongestTimeSpentLiving()).max().orElse(0);
        return totalDeaths + "";
    }

    private static String getDoubleKills(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getDoubleKills()).sum();
        return totalDeaths + "";
    }

    private static String getTripleKills(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTripleKills()).sum();
        return totalDeaths + "";
    }

    private static String getQuadraKills(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTripleKills()).sum();
        return totalDeaths + "";
    }

    private static String getPentaKills(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getPentaKills()).sum();
        return totalDeaths + "";
    }

    private static String getTotalDamageDealt(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTotalDamageDealt()).sum();
        return totalDeaths + "";
    }

    private static String getMagicDamageDealt(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getMagicDamageDealt()).sum();
        return totalDeaths + "";
    }

    private static String getPhysicalDamageDealt(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getPhysicalDamageDealt()).sum();
        return totalDeaths + "";
    }

    private static String getTrueDamageDealt(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTrueDamageDealt()).sum();
        return totalDeaths + "";
    }

    private static String getLargestCriticalStrike (MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getLargestCriticalStrike()).sum();
        return totalDeaths + "";
    }

    private static String getTotalDamageDealtToChampions(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTotalDamageDealtToChampions()).sum();
        return totalDeaths + "";
    }

    private static String getMagicDamageDealtToChampions(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getMagicDamageDealtToChampions()).sum();
        return totalDeaths + "";
    }

    private static String getPhysicalDamageDealtToChampions(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getPhysicalDamageDealtToChampions()).sum();
        return totalDeaths + "";
    }

    private static String getTrueDamageDealtToChampions (MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTrueDamageDealtToChampions()).sum();
        return totalDeaths + "";
    }

    private static String getTotalHeal(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTotalHeal()).sum();
        return totalDeaths + "";
    }

    private static String getTotalUnitsHealed(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTotalUnitsHealed()).sum();
        return totalDeaths + "";
    }

    private static String getDamageSelfMitigated (MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getDamageSelfMitigated()).sum();
        return totalDeaths + "";
    }

    private static String getDamageDealtToObjectives(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getDamageDealtToObjectives()).sum();
        return totalDeaths + "";
    }

    private static String getDamageDealtToTurrets (MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getDamageDealtToTurrets()).sum();
        return totalDeaths + "";
    }

    private static String getVisionScore(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getVisionScore()).sum();
        return totalDeaths + "";
    }

    private static String getTimeCCingOthers(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTimeCCingOthers()).sum();
        return totalDeaths + "";
    }

    private static String getTotalDamageTaken(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTotalDamageTaken()).sum();
        return totalDeaths + "";
    }

    private static String getMagicalDamageTaken(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getMagicalDamageTaken()).sum();
        return totalDeaths + "";
    }

    private static String getPhysicalDamageTaken(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getPhysicalDamageTaken()).sum();
        return totalDeaths + "";
    }

    private static String getTrueDamageTaken(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTrueDamageTaken()).sum();
        return totalDeaths + "";
    }

    private static String getGoldEarned(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getGoldEarned()).sum();
        return totalDeaths + "";
    }

    private static String getGoldSpent(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getGoldSpent()).sum();
        return totalDeaths + "";
    }

    private static String getTotalMinionsKilled(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTotalMinionsKilled()).sum();
        return totalDeaths + "";
    }

    private static String getNeutralMinionsKilled(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getNeutralMinionsKilled()).sum();
        return totalDeaths + "";
    }

    private static String getTotalTimeCrowdControlDealt(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getTotalTimeCrowdControlDealt()).sum();
        return totalDeaths + "";
    }

    private static String getChampLevel (MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getChampLevel()).sum();
        return totalDeaths + "";
    }

    private static String getVisionWardsBoughtInGame(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getVisionWardsBoughtInGame()).sum();
        return totalDeaths + "";
    }

    private static String getSightWardsBoughtInGame(MatchDetail matchDetail, int team) {
        long totalDeaths = filter(matchDetail, team).mapToInt(p -> p.getStats().getSightWardsBoughtInGame()).sum();
        return totalDeaths + "";
    }


    private static Stream<Participants> filter(MatchDetail matchDetail, int team) {
        return matchDetail.getParticipants().stream()
                .filter(participants -> {
                    if (participants.getTeamId() == (team * 100)) {
                        return true;
                    } else {
                        return false;
                    }
                });
    }
}

 

4. 结果

经过清洗后，最终生成了一个116186行数据的csv文件

总结

本文主要讲述从前文获得的json文件，清洗后转换成方便后续使用的csv文件。

 

下一节将介绍预测中的特征工程。

爱技术的小马哥
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
英雄联盟数据分析专题（一）
chaunceyliu30的博客
06-12 8192
写在前面的话 英雄联盟是一款在世界范围内拥有众多玩家的MOBA游戏，它陪伴了我们这一代人的成长。在游戏中以五人一队为单位分为红方和蓝方两个阵营，最先推掉对方基地水晶的队伍为胜者。队内每个玩家分担不同职责：上单，中单，ADC，辅助以及打野各司其职，不仅要专注于兵线运营和进攻对方防御塔还要掠夺地图资源来为队伍取得更大优势。英雄联盟这款游戏经历了这么多年已经发展出了各种不同的玩法，每个玩家也对...
某腾LOL开发负责人教你如何用Java实现一把 LOL 案例，学会模板设计模式！
weixin_55932015的博客
03-31 626
前言 假如开一把lol，必须要做哪些事呢？可以简化位这三个步骤。选择英雄，开始游戏，投降。这三个步骤必须按照顺序执行。映射到代码中可以想到socket信息传输，建立连接，传输数据，关闭连接。 [这就是模板模式了大概的样子，在模板模式中，一个抽象类公开定义了执行它的方法的方式模板，它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。] [比如玩一把lol,选择什么英雄都可以，开始游戏后，每个人也有自己的发育路线，最后是15分钟投降，还是20分钟投降，每一局也都不一定（赢了暂时不算）不管谁来玩，
牛逼！Python分析5万多场英雄联盟比赛，教你轻松预测胜负！
机器学习算法与Python学习
10-25 7013
（给机器学习算法与Python学习加星标，提升AI技能）作者：真达、Mika，数据：真达，后期：MikaCDA数据分析师 出品今天教大家用Python预测英雄联盟比赛胜负。公众号后...
对英雄联盟比赛预测（三）- 数据获取Java实现
majixiang1996的博客
01-17 1315
系列文章目录 对英雄联盟比赛预测（一）- 特征分析 对英雄联盟比赛预测（二）- 数据获取api分析 文章目录系列文章目录声明前言一、基本框架二、基本配置1. maven依赖配置2. properties配置三、模块详解1. client2. config3. entity4. pipeline5. scheduler6. service总结重启会造成资源浪费速度慢apikey有效期数据不全 声明 本文所提到的爬虫方法仅供学习研究使用，不得用于商业用途 前言 前面几篇文章，主要讲述lol比赛的影响因素
对英雄联盟比赛预测（二）- 数据获取api分析
majixiang1996的博客
01-09 4338
文章目录声明前言一、数据源分析？二、使用步骤1.申请拳头开发者2.分析api数据入口查找比赛分析返回体分析json最外层分析两队情况首先是蓝色方接着是红色方分析双方的比赛玩家首先分析蓝色方的玩家红色方时间线分析玩家的关联分析总结 声明 本文中所涉及到的所有数据及使用方法仅供学习使用，不得用于商业用途 前言 上篇文章对英雄联盟比赛预测（一）- 特征分析对比赛的数据类型进行了分析，接下来，我们就要开始获取各个比赛的具体数据。 提示：以下是本篇文章正文内容，下面案例可供参考 一、数据源分析？ 目前已知可以
【ML】英雄联盟对局胜负预测任务
Esperanto.的博客
10-14 3160
本样例以英雄联盟对局胜负预测任务为基础，简单展示了机器学习任务的大致流程，为机器学习入门者提供参考。 任务介绍 英雄联盟（League of Legends，LoL）是一个多人在线竞技游戏，由拳头游戏（Riot Games）公司出品。在游戏中，每位玩家控制一位有独特技能的英雄，红蓝两支队伍各有五位玩家进行对战，目标是摧毁对方的基地水晶。水晶有多座防御塔保护，通常需要先摧毁一些防御塔再摧毁水晶。玩家所控制的英雄起初非常弱，需要不断击杀小兵、野怪和对方英雄来获得金币、经验。经验可以提升英雄等级和技能等级，金币可
【飞桨学习赛: 英雄联盟大师预测】0.8595方案.zip
01-04
【飞桨学习赛: 英雄联盟大师预测】0.8595方案.zip这个压缩包文件包含了使用飞桨框架进行英雄联盟比赛胜负预测的项目。飞桨（PaddlePaddle）是由百度开发的深度学习平台，它支持大规模的深度学习模型训练和高效的部署...
英雄联盟胜负预测.zip
最新发布
01-04
本项目“英雄联盟预测课设程序”旨在利用编程技术，结合游戏数据，对比赛的胜负进行预测，提供一种科学的分析方法。通过深入学习和理解游戏机制，我们可以构建模型来预测比赛结果，从而提升玩家的战略理解与游戏体验...
英雄联盟赛事数据.zip
01-04
本篇将深入探讨一个以“英雄联盟”为背景的预测课设程序，通过对相关源码的分析，揭示其中蕴含的数据处理和预测模型的构建方法。 首先，我们要理解“英雄联盟赛事数据.zip”这个压缩包的核心内容。它包含了两个主要...
使用决策树对英雄联盟胜率进行预测.zip
01-04
本项目“使用决策树对英雄联盟胜率进行预测”正是基于这种模型，利用飞桨（PaddlePaddle）这一深度学习框架进行实现。飞桨是中国首个开源的深度学习平台，具有易用、高效、全面支持GPU和CPU等优势，特别适合于大数据...
Python爬虫：英雄联盟近期战绩查询
bouIevard的博客
07-09 9111
c语言选手早已听说Python的方便和其各大爬虫模块的实用性，于是暑假无所事事的我决定在没有系统学习Python语法的情况下，一边写一个和自己兴趣有关的爬虫，一边学习一下Python方便的语法，体验Python的方便之处。 一·用到的语法 1.requests.get() 这个是常用的爬虫模块，可以爬取网页的json文件，语法为request.get(url,param,headers) 其中url是必须要的，用来给网络文件定位；param不一定需要，具体是干啥的我也没遇到过；headers是防止被
Python | 英雄联盟游戏数据分析
PbPbbb的博客
11-16 1万+
一、项目背景 二、数据预处理 1.数据来源 数据源：(LoL) League of Legends Ranked Games （LoL）英雄联盟排名游戏 2.理解数据 3.数据清洗 三、分析角度 四、分析过程 五、分析总结
飞桨学习赛：英雄联盟大师预测2023年2月85.365分方案
m0_63642362的博客
02-25 4154
本赛题属于典型的分类问题，以英雄联盟手游为背景，要求选手根据英雄联盟玩家的实时游戏数据，预测玩家在本局游戏中的输赢情况。事实上项目仍然有很多能够改进的地方模型可以利用进一步优化网络结构尽管180000条样本可以一次性训练，修改训练批数仍有可能进步项目并没有做明确的训练集/测试集划分，可以尝试采用交叉验证来减少过拟合。
英雄联盟大师预测赛方案分享-模型融合
m0_63642362的博客
02-12 1888
实现sklearn的交叉验证以及3个弱分类器与paddle网络模型的融合。
爬虫之爬取英雄联盟战绩详细数据
热门推荐
QNMLGB2的博客
03-11 2万+
爬虫之爬取英雄联盟战绩详细数据 思路解析: 我们首先打开LOL游戏官网,登录自己的账号(因为牵扯到账号,所以需要用到cookie),然后选择你想爬取数据的大区! 在这个界面我们按下F12查看源代码,在Network下的JS里,刚开始什么都没有,我们需要重新加载网页然后才会显示各种数据 如果你看下除了第一个?c=Battle的其他相同名字数据就会发现,下面的每一条数据正好对应着左侧的每一局游戏,我们...
使用nginx对集群模式的minio做负载均衡
majixiang1996的博客
04-18 6113
前言 上篇文章：kubenetes集群模式部署minio 中讲述了如何在kubenetes集群中部署minio，但是遗留问题是未使用service，导致minio集群缺少负载均衡效应，本文将讲述如何通过nginx为minio做负载均衡。 部署nginx 关于nginx的部署，就不多说了，参考本人文章： 记一次Kubenetes部署Nginx的全过程 需要注意的一点是：当前集群版本是1.18.1，故...
kubenetes集群模式部署minio
majixiang1996的博客
04-18 4455
环境准备 一个部署完整的k8s集群，版本1.18.1 系统版本：CentOS7.2 docker版本：1.13.1 172.22.21.77 dev-learn-77 master 172.22.21.78 dev-learn-78 slave 172.22.21.79 dev-learn-79 slave [root@dev-learn-77 ~]# kubectl get node -o wi...
大数据管理平台（一）概述
majixiang1996的博客
03-05 4145
系列文章目录 文章目录系列文章目录前言一、功能概述二、使用步骤2.1 安装2.2 监控2.3 管理2.4 用户管理2.5 应用市场2.6 操作系统三、总结 前言 做大数据有几年了，这些年耳濡目染了一些大数据管理平台的使用，但是或多或少使用起来，都不怎么方便，所以决定自己来实现一个简单的大数据平台 一、功能概述 大数据应用组件往往很多，可能几百台服务器组成一个Hadoop集群，当部署这些节点时，需要一个节点一个节点的操作，简直不敢想象。同时在这些服务器上可能还部署着Spark、Flink、Hive
英雄联盟排位比赛数据不同算法预测分析
05-23
英雄联盟排位比赛数据可以通过多种算法进行预测分析，以下是几种常用的算法： 1. 逻辑回归（Logistic Regression） 逻辑回归是一种二分类算法，可以根据比赛数据预测胜负。通过对历史数据的分析，可以得到一组影响...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值