笔试题收集：某学院发起对校园歌手的投票活动，对投票数据进行分析与计算

某学院发起对校园歌手的投票活动，由学生嘉宾和专业评委2部分组成投票团。部分投票数据如下所示，现需要小明对投票数据进行处理和分析。

歌手编号    投票时间    投票类型    投票人座位号
22    2019-05-10 14:32:11    评委    143
12    2019-05-10 14:30:45    学生代表    008
11    2019-05-10 14:41:59    学生代表    009
9    2019-05-10 14:32:34    评委    019
22    2019-05-10 14:31:22    评委    124
9    2019-05-10 14:31:32    评委    124
22    2019-05-10 14:33:01    学生代表    009

请根据以上信息（以上数据请使用文本附件复制进入代码，字段间使用\t进行分割），并对以下题目进行作答：
1.多次投票只计算一次有效，按照最新时间，请统计有效票。
2.投票从14:30:00开始，10分钟内投票算为有效，多次投票仍只计算一次，请统计有效票。
3.学生代表最多投 1 票，专业评委最多给 2个不同的候选人分别投 1 票，按照最新时间，请统计有效票。
4.若学生代表最多投 2票，不可投给1位选手。专业评委可以投给同一位选手2票，请统计有效票。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class VoteAnalysis {
    public static void main(String[] args) {
        // 存储投票数据的列表
        List<Vote> votes = new ArrayList<>();
        try (BufferedReader br = new BufferedReader(new FileReader("vote_data.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                String[] parts = line.split("\t");
                int singerId = Integer.parseInt(parts[0]);
                String voteTime = parts[1];
                String voterType = parts[2];
                int seatNumber = Integer.parseInt(parts[3]);
                votes.add(new Vote(singerId, voteTime, voterType, seatNumber));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 问题 1：多次投票只计算一次有效，按照最新时间，请统计有效票
        Map<String, Vote> validVotes1 = new HashMap<>();
        vote.forEach(vote -> {
            String key = vote.getVoterType() + vote.getSeatNumber();
            if (!validVotes1.containsKey(key) || vote.getVoteTime().compareTo(validVotes1.get(key).getVoteTime()) > 0) {
                validVotes1.put(key, vote);
            }
        };
        Map < Integer, Integer > singerVotes1 = new HashMap<>();
        validVotes.forEach(validVote -> {
            singerVotes1.put(validVote.getSingerId(), singerVotes1.getOrDefault(validVote.getSingerId(), 0) + 1);

        };
        List < singerVotes > VotesList = new ArrayList<>();
        singerVotes1.forEach((k, v) -> VotesList.add(k, v));

    }

    // 问题 2：投票从 14:30:00 开始，10 分钟内投票算为有效，多次投票仍只计算一次，请统计有效票
    Map<String, Vote> validVotes2 = new HashMap<>();
        votes.forEach(vote ->{
        String key = vote.getVoterType() + vote.getSeatNumber();
        if (!validVotes2.containsKey(key) ||isValidTime(key,vote.getVoteTime())

)) {

            validVotes2.put(key, vote);
        }
    };

    Map<Integer, Integer> singerVotes2 = new HashMap<>();
        votes.forEach(validVote ->{
        singerVotes2.put(validVote.getSingerId(), singerVotes2.getOrDefault(validVote.getSingerId(), 0) + 1);
        };
        System.out.println("问题 2 有效票统计：");
        List<singerVotes> sortVoteList = new ArrayList<>();
        singerVotes2.forEach((k,v)->sortVoteList.add(new
        singerVotes(k, v)));

    // 问题 3：学生代表最多投 1 票，专业评委最多给 2 个不同的候选人分别投 1 票，按照最新时间，请统计有效票
    Map<String, Integer> studentVotes = new HashMap<>();
    Map<String, List<Integer>> judgeVotes = new HashMap<>();
    votes.forEach(vote ->{
        if ("学生代表".equals(vote.getVoterType())) {
            String key = String.valueOf(vote.getSeatNumber());
            if (!studentVotes.containsKey(key)) {
                studentVotes.put(key, vote.getSingerId());
            }
        } else {
            String key = String.valueOf(vote.getSeatNumber());
            judgeVotes.putIfAbsent(key, new ArrayList<>());
            List<Integer> judgeVoteList = judgeVotes.get(key);
            if (judgeVoteList.size() < 2 && !judgeVoteList.contains(vote.getSingerId())) {
                judgeVoteList.add(vote.getSingerId());
            }
        }
    };

    Map<Integer, Integer> singerVotes3 = new HashMap<>();
    List<VoteResult> sortedVotesList = new ArrayList<>();
    List<Integer> VotesList = new ArrayList<>();
    uV1.forEach((k1,v1)->v1.forEach((k2,v2)->{
        if (VotesList.contains(k2)) {
            VotesList.forEach(t -> {
                voteResult.setVotingPaperNum(t.getVotingPaperNum() + v2);
            });
        } else {
            candidateVotesList.add(k2);
            sortedVotesList.add(new VoteResult(k2, v2));
        }
        System.out.println("问题 3 有效票统计：");
        List<singerVotes> sortVoteList = new ArrayList<>();
        judgeVotes.forEach((k, v) -> sortVoteList.add(new singerVotes(k, v)));

    };

    // 问题 4：若学生代表最多投 2 票，不可投给 1 位选手。专业评委可以投给同一位选手 2 票，请统计有效票
    Map<String, List<Integer>> studentVotes4 = new HashMap<>();
    Map<String, Integer> judgeVotes4 = new HashMap<>();
    votes.forEach(vote ->{
        if ("学生代表".equals(vote.getVoterType())) {
            String key = String.valueOf(vote.getSeatNumber());
            studentVotes4.putIfAbsent(key, new ArrayList<>());
            List<Integer> studentVoteList = studentVotes4.get(key);
            if (studentVoteList.size() < 2 &&
                    (!studentVoteList.contains(vote.getSingerId()) || studentVoteList.size() == 1)) {
                studentVoteList.add(vote.getSingerId());
            }
        } else {
            String key = vote.getVoterType() + vote.getSeatNumber();
            judgeVotes4.put(key, judgeVotes4.getOrDefault(key, 0) + 1);
        }
    };


   private static boolean isValidTime(String time, String startTime) {

    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    String[] timeParts = time.split(" ")[0];
    String[] startParts = startTime.split(" ")[0];
    try {
        Date date1 = dateFormat.parse(timeParts+ " 14:30:00");

        Date date2 = new Date(dateFormat.getTime() / 1000L + 24 * 60 * 60);
        Date date3 = dateFormat.parse(date2);
        if ((date1.compareTo(dateFormat.parse(date1)) > 0 && date1.compareTo(date3) < 0)
                || date1.compareTo(date3) < 0) {
            return true;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return false;
    }

    static class Vote {
        private int singerId;
        private String voteTime;
        private String voterType;
        private int seatNumber;

    public Vote(int singerId, String voteTime, String voterType, int seatNumber) {
        this.singerId = singerId;
        this.voteTime = voteTime;
        this.voterType = voterType;
        this.seatNumber = seatNumber;
    }

    public int getSingerId() {
        return singerId;
    }

    public String getVoteTime() {
        return voteTime;
    }

    public String getVoterType() {
        return voterType;
    }

    public int getSeatNumber() {
        return seatNumber;
    }
}