3

我有两节课

public class PopularSports {    
    public int Rank;    
    public String Sport;
}

public class Medals {
    public String Sport    
    public String Medal    
    public int Year    
    public String Game    
    public String Athlete
}

当我尝试引导他们的 csv 并在每个班级的列表中获得结果时，我想按以下顺序对它们进行排序。

PopularSports 类应按以下顺序排序：

  1. 秩
  2. 运动

Medals 类应按以下顺序排序：

  1. 运动
  2. 勋章
  3. 年
  4. 游戏
  5. 运动员

我已经创建了这样的压实机

Collections.sort(medalReportList, new Comparator<Medals >() {
  @Override
  public int compare(Medals o1, Medals o2) {
   return getRankOfSportBySportName(o1.getSport()) > getRankOfSportBySportName(o2.getSport())
          ? +1
          : getRankOfSportBySportName(o1.getSport()) < getRankOfSportBySportName(o2.getSport())
          ? -1
          : o1.getAthlete().compareToIgnoreCase(o2.getAthlete());
    }
  });

但这并没有让它发生，而是根据运动员的名字进行排序。

4

4 回答 4

2

您需要嵌套这些检查。我将编写 PopularSports 方法，其他的留给你。

我建议您学习 Java 编码标准并将这些类名设为单数：PopularSport和Medal. 我将在下面演示：

public int compareTo(PopularSport other) {
    if (this.rank < other.rank) return -1;
    else if (this.rank > other.rank) return +1;
    else {
        // This is where the nesting happens to break the ties.
        if (this.sport.compareTo(other.sport) < 0) return -1;
        else if (this.sport.compareTo(other.sport) > 0) return +1;
        else return 0;  // You'll have deeper nesting for the other values in Medal.
    }
}

您选择的顺序决定了首先检查哪些。您嵌套在else子句中以打破关系。

于 2013-10-31T14:13:51.440 回答
0

我会稍微简化你的逻辑。

public int compare(Medals o1, Medals o2) {
  int rankDifference = getRankOfSportBySportName(o1.getSport()) 
                             - getRankOfSportBySportName(o2.getSport());
  return rankDifference != 0 
      ? rankDifference
      : o1.getAthlete().compareToIgnoreCase(o2.getAthlete());
  }
于 2013-10-31T14:08:54.247 回答
0

其他人已经为您提供了三元运算符的解决方案。另一方面，我不鼓励您在复杂的情况下使用它 - 它根本不可读且难以维护。

要么使用 if/else 块（如果要比较这么多字段，看起来会很糟糕），或者更好的是，使用第三方库。在Guava中，您可以像这样使用ComparisionChain：

new Comparator<Medals>() {
    @Override
    public int compare(Medals m1, Medals m1) {
        return ComparisonChain.start()
         .compare(m1.getSport(), m2.getSport())
         .compare(m1.getMedal(), m2.getMedal())
         .compare(m1.getYear(), m2.getYear())
         .compare(m1.getGame(), m2.getGame())
         .compare(m1.getAthlete(), m2.getAthlete(), String.CASE_INSENSITIVE_ORDER)
         .result();
    }
}

这不是更可读吗？！

于 2013-10-31T14:33:20.917 回答
-1

对第一个列表进行排序对您来说没有问题。如果你想排序，如果运动名称相同，则根据奖牌排序，如果奖牌名称相同，则根据年份排序，则解决方案是：

最好的办法： 

public void sortAccordingToAboveRequirement(List<Medal> medals){

 Collections.sort(medals,myComparator);

 }


  static Comparator<Medal> myComparator=new Comparator<Medal>() {
    @Override
        public int compare(Medal medal1, Medal medal2) {
        int value=0;
        value=medal1.getSport().compareTo(medal2.getSport());
        if(value!=0) return value;
        value=medal1.getMedal().compareTo(medal2.getMedal());
        if(value!=0) return value;
        value=medal1.getYear().compareTo(medal2.getYear());
        if(value!=0) return value;
        value=medal1.getGame().compareTo(medal2.getGame());
        if(value!=0) return value;
        value=medal1.getAthlete().compareTo(medal2.Athlete());
        return value;
    }
};

如果您愿意，请使用 compareToIgnoreCase() :)

于 2013-10-31T14:08:55.573 回答