我有一个作业，我必须编程，从比赛列表输入创建一个排名表。我使用“无限”这个词是因为输入大小未知，所以我必须创建一个程序，直到没有匹配项为止。我为此创建了一个足球类（输入包含两个其他运动和他们自己的比赛和球队，用运动的第一个字母“f，b，v”表示运动类型，例如，他们只是在得分部分不同，所以我认为如果我能使足球工作，我可以使任何其他工作），它包含了积分表中所需的所有内容，匹配结果的方法如下所示：

public class Football {
    private int scoredGoals;
    private int receivedGoals;
    private String teamName;
    private int Score;
    private int wins;
    private int losses;
    private int MatchCount;
    private int draws;

    public void teamValues(String teamName, int Sgoals, int Rgoals) {
        this.teamName = teamName;
        this.scoredGoals = Sgoals;
        this.receivedGoals = Rgoals;

    }           

    public void matched() {
        MatchCount++;
    }

    public void winner() {
        wins++;
    }

    public void draw() {
        draws++;
    }

    public void loser() {
        losses++;
    }

    public void winScore() {
        Score += 3;
    }

    public void drawScore() {
        Score += 1;
    }

    public String showTeams() {
        return (teamName + "    " + MatchCount + "  " + wins + "    " + draws + "   " + losses + "  " + scoredGoals+":"+receivedGoals + "   " + Score);
    }

}

在main类中，我调用if块中的方法来计算获胜、得分、比赛计数等，main如下所示：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.HashSet;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) throws FileNotFoundException {

        File file = new File("input.txt");
        Scanner scan = new Scanner(file);
        String fileString = "";
        Football teams[] = new Football[2];
        HashSet<String> teamsArray = new HashSet<String>();

        while(scan.hasNextLine()) {
            fileString = scan.nextLine();
            String[] match = fileString.split("\\t|:");

            if(match[0].equals("F")) {
                int team1score = Integer.valueOf(match[3].trim());
                int team2score = Integer.valueOf(match[4].trim());

                teams[0] = new Football();
                teams[0].teamValues(match[1], team1score, team2score);
                teams[1] = new Football();
                teams[1].teamValues(match[2], team2score, team1score);
                teams[0].matched();
                teams[1].matched();
                if(team1score>team2score) {

                    teams[0].winner();
                    teams[1].loser();

                    teams[0].winScore();
                }

                if(team1score==team2score) {
                    teams[0].draw();
                    teams[1].draw();

                    teams[0].drawScore();
                    teams[1].drawScore();
                }

                if(team1score<team2score) {
                    teams[1].winner();
                    teams[0].loser();

                    teams[1].winScore();
                }

            String team0 = teams[0].showTeams();
            String team1 = teams[1].showTeams();

            teamsArray.add(team0);
            teamsArray.add(team1);

        }   
    }
        scan.close();
    }   
}

因为输入是静态的，所以我使用数组来处理。我的代码的问题是，我找不到一种方法来存储我的团队，而没有重复项和变量，只要团队有另一个匹配项，这些变量就会出现并更新。
我试过了；
将它们存储在2d字符串数组中，但由于团队数量未知，我认为这不是解决问题的一种健康方法。
将它们存储在string[]数组列表中，最后存储的是地址而不是团队的值。
我仍然使用它来检查至少这些方法是否按预期工作。
我觉得这个计划触礁了，我需要重新开始，所以任何建议都很感激。
下面是一个输入和输出示例：

Input:
    Home Team       Guest Team         H : G
F   Manchester U.   Chelsea            2 : 2
F   Liverpool       Manchester City    3 : 2
F   Leicester City  Everton            1 : 3
V   Team A          Team B             3 : 0
F   Tottenham       Liverpool          3 : 1
B   Team B          Team A            90 : 96
F   West Ham        Manchester U.      2 : 1
F   Arsenal         Manchester City    0 : 2
F   Chelsea         Arsenal            3 : 3

Output: 
    Name          Matches Wins Draw Lose   Scored:Received Score
1.  Manchester U.   10     6    2    2         27:22        20
2.  Arsenal         10     6    2    2         25:24        20 
3.  Chelsea         10     5    3    2         28:20        18
4.  Liverpool       10     4    4    2         22:19        16
5.  Tottenham       10     4    4    2         22:21        16

有些球队的得分是相同的，因为计算得分和收到的进球的平均数是对球队进行排序的另一种方法。