Java 如何按特定值对数组进行排序？

我希望通过将字符串分组到特定类别来对输出进行排序。 从我的代码中可以看出，我在一个字符串/行中有球队名称、联赛、教练、分区和全职类别的值。我想按联盟名称对每个字符串/行进行排序。例如，所有联赛“西部”的球队将分组在一起，所有联赛“东部”的球队将分组在一起

代码：

Team.java：

public class Team 
{
private String name;
private String league;
private String[] coaches;
private String division;
private boolean fullTime;

public Team(String dataLine)
{
    String[] data = dataLine.split(",");
    this.name = data[0];

    this.coaches = getStringAsArray(data[1], ":");

    this.league = data[2];

    this.division = data[3];

    this.fullTime = data[4].equals("yes");      

}

public Team(){

}

private String[] getStringAsArray(String t, String delimiter)
{
    String[] result = t.split(delimiter);
    return result;
}

private String getArrayAsString(String[] coaches)
{

    coaches = this.getCoaches();
    String result = "";
    for(int i = 0; i<coaches.length; i++)
    {
        result += coaches[i] +" ";
    }
    result = result.trim();
    return result;
}

public void setName(String name)
{
    this.name = name;
}

public String getName()
{
    return this.name;
}

public void setCoaches(String coaches)
{
    this.coaches = getStringAsArray(coaches, ":");
}

public String getCoachesAsString()
{

    String result = getArrayAsString(coaches);
    return result;
}

public boolean isFullTime() {
    return fullTime;
}

public void setFullTime(boolean fullTime) {
    this.fullTime = fullTime;
}

public String getDivision() {
    return division;
}

public void setDivision(String division) {
    this.division = division;
}

public String[] getCoaches() {
    return coaches;
}

public void setCoaches(String[] coaches) {
    this.coaches = coaches;
}

public String getLeague() {
    return league;
}

public void setLeague(String league) {
    this.league = league;
}

@Override
public String toString() {
    return " Team name: " + name + ", League: " + this.league + ", Coaches: " + Arrays.toString(this.coaches) +  ", Division: " + this.division + ", Full Time: " + this.fullTime + "\n ";
}
}

ReadCSV.java：

public class ReadCsv {

public void readCsv() {

    String csvFileToRead = "H:/Desktop/FootballRepo/TestData/football_teams_phase1.csv";
    BufferedReader br = null;
    String line = "";

    try {

        br = new BufferedReader(new FileReader(csvFileToRead));
        int i = 0;
        while ((line = br.readLine()) != null) {
            Team one = new Team(line);
            if(i > 0){
                 StoreData.teams.add(new Team(line));
            }else{
               i++;
            }
        }
    }
    catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (br != null) {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public static ArrayList<Team> getTeams() {
    return StoreData.teams;
}

public static void setTeams(ArrayList<Team> teams) {
    StoreData.teams = teams;
}
}

公共类ReadCsv{
public void readCsv（）{
字符串csvFileToRead=“H:/Desktop/FootballRepo/TestData/football\u teams\u phase1.csv”；
BufferedReader br=null；
字符串行=”；
试一试{
br=新的BufferedReader（新文件读取器（csvFileToRead））；
int i=0；
而（（line=br.readLine（））！=null）{
第一队=新队（线）；
如果（i>0）{
StoreData.teams.add（新团队（行））；
}否则{
i++；
}
}
}
catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}最后{
如果（br！=null）{
试一试{
br.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
}
公共静态数组列表getTeams（）{
返回StoreData.teams；
}
公共静态组（ArrayList组）{
StoreData.teams=团队；
}
}

像这样的东西怎么样：

final String[] input = /* get input from anywhere */;
Arrays.sort(input, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        String[] dataA = a.split(",");
        String leagueA = dataA[2];
        String[] dataB = b.split(",");
        String leagueB = dataB[2];
        return leagueA.compareTo(leagueB);
    }
});

{
    public static Map<String, List<Team>> makeGroup(List<Team> teams) {
        Map<String, List<Team>> teamMap = new HashMap<String, List<Team>>();
        for (Team team : teams) {
            if (!teamMap.containsKey(team.getLeague())) {
                teamMap.put(team.getLeague(), new ArrayList<Team>());
            }

            List<Team> list = teamMap.get(team.getLeague());
            list.add(team);
        }
        return teamMap;
    }
}

final String[]input=/*从任何地方获取输入*；
sort（输入，新的比较器（）{
@凌驾
公共整数比较（字符串a、字符串b）{
字符串[]dataA=a.split（“，”）；
字符串leagueA=dataA[2]；
字符串[]数据b=b.split（“，”）；
字符串leagueB=dataB[2]；
返回leagueA.compareTo（leagueB）；
}
});

---

它甚至可以在创建相应的对象之前对您的团队进行排序。

假设team.league不为空

分类：

teams.stream()
        .sorted(Comparator.comparing(Team::getLeague))
        .forEach(System.out::println);

分组：

teams.stream()
        .collect(Collectors.groupingBy(Team::getLeague))
        .forEach((l,t) -> System.out.println("League: " + l + ", Teams: " + t));

---

一旦有了团队列表，就可以按如下方式对对象进行分组：

final String[] input = /* get input from anywhere */;
Arrays.sort(input, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        String[] dataA = a.split(",");
        String leagueA = dataA[2];
        String[] dataB = b.split(",");
        String leagueB = dataB[2];
        return leagueA.compareTo(leagueB);
    }
});

{
    public static Map<String, List<Team>> makeGroup(List<Team> teams) {
        Map<String, List<Team>> teamMap = new HashMap<String, List<Team>>();
        for (Team team : teams) {
            if (!teamMap.containsKey(team.getLeague())) {
                teamMap.put(team.getLeague(), new ArrayList<Team>());
            }

            List<Team> list = teamMap.get(team.getLeague());
            list.add(team);
        }
        return teamMap;
    }
}

{
公共静态映射生成组（列表团队）{
Map teamMap=newhashmap（）；
对于（团队：团队）{
如果（！teamMap.containsKey（team.getLeague（）））{
teamMap.put（team.getLeague（），newArrayList（））；
}
List List=teamMap.get（team.getLeague（））；
列表。添加（团队）；
}
返回团队地图；
}
}

---

此外，如果您想对团队进行排序，您可以按照上面提到的方法进行。

您要求什么？分组还是排序？它不是数组，而是集合

ArrayList teams

，因此Java 8 stream API在分组和排序方面应该都能很好地工作，试试看[note-很好地取代了这个样板