How do I write an equals method that compares one team to another?

Question

public class Team {

    private String name, sport;
    private int numOfWins, numOfLosses;
    public Team(String name, String Sport){
        this.name= name;
        this.sport= Sport;
        numOfWins= 0;
        numOfLosses= 0;
    }

    public int addAnotherWin(){
        return numOfWins++;
    }

    public int addAnotherLoss(){
        return numOfLosses++;
    }

    public int getNumWins(){
        return numOfWins;
    }

    public int getNumLosses(){
        return numOfLosses;
    }

    public void resetWinsAndLosses(){
        numOfWins= numOfWins*0;
        numOfLosses= numOfLosses*0;
    }

    public double getPercentOfGamesWon(){
        double z= numOfWins/ numOfWins+numOfLosses;
        return z;
    }

    public boolean equals(){    

    }

    public String toString(){

    }
} 

So my equals method is suppose to compare two teams and return if they are equals if their PercentOfGamesWon is equal to each other, but I don't know how to write that, any help please? Another thing i need help with is the toString, i'm not sure what its for and what i'm suppose to write in it. I just started coding so sorry if this is a noob question.

Answer 1

I highly suggest referring to the answers in What issues should be considered when overriding equals()

First see if the object being compared is actually a team (using instanceof), then compare the percentages:

public boolean equal(Object obj) {
     if(!obj instanceof Team) 
          return false;

     return getPercentOfGamesWon() == ((Team) obj).getPercentOfGamesWon();
} 

Now you can call the equals method of one Team and pass in the other team to compare them:

Team team1 = new Team();
Team team2 = new Team();

boolean equal = team1.equals(team2);

As mentioned by @MarsAtomic in the comment section of your question, you should really be implementing a compareTo(Team) method. This method should return a number based on whether the percentage is higher, lower or the same:

class Team implements Comparable<Team> {

     public int compareTo(Team team) {
          int ourPercent = getPercentOfGamesWon();
          int theirPercent = team.getPercentOfGamesWon();

          if(ourPercent > theirPercent)
               return 1;
          else if(ourPercent < theirPercent)
               return -1;
          else
               return 0; //the same
     }
}

Answer 2

As @MarsAtomic commented, this is more suited for a Comparator, not equals. Even if the Giants and Dodgers finish with the same record, I don't think you want to consider them "equals". And you are likely to want to rank the teams by performance.

public static Comparator<Team> BY_PCT = new Comparator<Team>() {
   public int compare(Team t1, Team t2) {
      double winPct1 = t1.getPercentOfGamesWon();
      double winPct2 = t2.getPercentOfGamesWon();
      return Double.compare( winPct1, winPct2);
   }
};

You could also implement Comparable as in Vince's answer.

Answer 3

First step is to determine how to calculate a percentage. Percentage is often written as "Value/Combined Values". If youre just returning a percentage then that is your amswer. Though if accuracy is important I reccomended using the BigDecimal class.

As for the toString method, you can basically put anything in here. ToString() is supposed to give meaningful text to an object. This relates to the equals method. In many objects .equals() compares hashcode, the location in memory. Therefore, toString often returns hashcode for many objects. It is essential to make hashcode equal to values you are comparing and many times toString is just a string representation of these values. In your case I would return the percentage.

Answer 4

You can do it like this:

public class Team {

    private String name, sport;
    private int numOfWins, numOfLosses;

    public Team(String name, String Sport) {
        this.name = name;
        this.sport = Sport;
        numOfWins = 0;
        numOfLosses = 0;
    }

    public int addAnotherWin() {
        return numOfWins++;
    }

    public int addAnotherLoss() {
        return numOfLosses++;
    }

    public int getNumWins() {
        return numOfWins;
    }

    public int getNumLosses() {
        return numOfLosses;
    }

    public void resetWinsAndLosses() {
        numOfWins = numOfWins * 0;
        numOfLosses = numOfLosses * 0;
    }

    public Double getPercentOfGamesWon() {
        double z = numOfWins / (numOfWins + numOfLosses);
        return new Double(z);
    }

    @Override
    public boolean equals(Object o) {
        if ( o instanceof Team)
        {
            Team other = (Team)o;
            return this.getPercentOfGamesWon().equals(other.getPercentOfGamesWon());
        }
        return false;
    }

    public static void main(String[] args) {
        Team teamOne = new Team("Falcons", "Football");
        teamOne.addAnotherWin();
        teamOne.addAnotherWin();

        Team teamTwo = new Team("Broncos", "Football");
        teamTwo.addAnotherWin();
        teamTwo.addAnotherWin();

        if( teamOne.equals(teamTwo) )
        {
            System.out.println("Two wins, they are equal");
        }

        teamOne.addAnotherLoss();

        if ( ! teamOne.equals(teamTwo) )
        {
            System.out.println("Two wins, but one loss, they are not equal");
        }


    }

}

I added a main so you you could see it in action. Another, possibly more useful solution might be to implement Comparable, which would let you see if a team is less than, equal to, or greater than another team.