如何在ArrayList中找到具有最大属性值的对象（使用不同的类）

Question

Java 初学者在这里。我应该找到参与者在活动中的最佳结果（然后将这个结果与其他人进行比较以找到获胜者等）。

我为一个事件（带有事件结果列表）、参与者（带有参与者的总结果列表）和结果（带有事件 obj、参与者 obj 和结果（double））+命令的程序类创建了类。

到目前为止，我已经编写了一个方法，它将参与者在事件中的最佳结果作为双精度返回，但我需要返回整个结果对象。不确定哪个类应该对此负责（？），但我现在将此方法放在事件类中。

public double getBestResultDouble(Participant p) {
        double best = 0;

        if (hasResult(p)) {
            for (Result r : eventResults) {
                
                if (p.equals(r.getParticipant())) {

                    double res = r.getResult();

                    if (res > best) {
                        best = res;
                    }
                }
            }
        }
        return best;
    } 

Answer 1

在Java中，最常用的方法是创建Comparator<Result>的实例，它比较Result的实例。您将比较委托给 Comparator，而不是自己比较。

然后您可以使用标准 Java 方法进行排序。

标准：

  List<Result> = ....
  Comparator<Result> cmp = ....;
  list.sort(cmp);
  Result max = list.get(0);

使用流

  List<Result> = ....
  Comparator<Result> cmp = ....;
  Result max = list.stream().max(cmp);

Double 已经是 Comparable，因此您可以像这样编写 Comparator：

Comparator<Result> cmp = new Comparator() {
    public int compare(Result r1, Result r2)
    {
        return r1.getResult().compareTo(r2.getResult());
    }      
}

Answer 2

尝试从 OOP（面向对象编程）的角度多思考。

一个Participant可以参与多个Event的。每次Participant 参与Event，都会为特定的Participant 生成一个Result，并获得相应的分数。

现在我已经了解了如何布局类的基本结构，因此我们可以定义我们希望每个类如何进行的具体行为。

public class Participant
{

    private List<Event> events;
    private String name;

    public Participant( String name )
    {
        this.name = name;
        events = new ArrayList<Event>();
    }

    //... other methods

    public void participate( Event event )
    {
        double score;

        //... get the score

        events.add( event );
        event.recordResult( this, score );
    }
}

所以现在Participant 可以参与您定义的某些Event。

现在看看我在那个参与方法中做了什么，我们需要有一种方法将Result 存储在Event 中。

public class Event
{
   private List<Result> results;

   public Event()
   {
      results = new ArrayList<Result>();
   }

   // ...

   public void scoreResult( Participant participant, double score )
   {
       //if a participant cannot participate multiple times in an event, probably need a check to see if 
       //the participant is already in the list, otherwise update the score isntead of adding a new Result

       results.add( new Result( participant, score ) ); 
   }
}

因此，现在您定义的每个 Event 都可以为特定的 Participant 评分 Result。

我只会为Result 类做基本大纲

public class Result
{

   private Participant participant;
   private double score;

   public Result( Participant participant, double score )
   {
      this.participant = participant;
      this.score = score;
   }


   // ... getters and setters
}

这可能是您的对象的基本轮廓。现在您可以在Participant 中定义一个方法，以获得他参与的所有Event 中最好的Result。类似：

public Result getBestResult()
{
   Result bestResult = null;
   for( Event event : events )
   {
      if( bestResult == null )
         bestResult = event.getResult();
      if( bestResult.getScore() < event.getResult().getScore() )
         bestResult = event.getResult();
   }

   //if the participant hasn't participated in any event, then this will return a null result.

   return bestResult;
}

我希望这是有道理的，并能帮助您以更面向对象的方式思考问题。这样您就可以为Event 定义其他方法，例如如何获取Participant 最高的Result。

当然，这只是布局类的一种方式，我强烈建议您在编码之前尝试提前考虑您希望对象如何相互交互。考虑对象之间的关系。我知道你只是一个初学者，所以这可能有点高级，但如果你认真学习如何高效地编码，这绝对是值得研究的。

Answer 3

只需将相应的（最佳）结果保存为另一个局部变量并在最后返回：

public Result getBestResultDouble(Participant p) {
    double best = 0;
    Result bestResult = null;

    if (hasResult(p)) {
        for (Result r : eventResults) {

            if (p.equals(r.getParticipant())) {

                double res = r.getResult();

                if (res > best) {
                    best = res;
                    bestResult = r;
                }
            }
        }
    }
    return bestResult;
}