How does object.equals method is supposed to work in Java?

Question

This is my source code. I'trying to implement a simple program that asks a question to a user and expects the answer to be "yes" or "no" and terminates only if the user answer to the question "yes" or "no". The book I have suggested me not to use == comparison and to use the equals method instead, so that the program can understand if the user typed "y e s" instead of "yes". But in this way the result is the same and the method seems to compare the user's answer if it is exactly "yes" or "no". It doesn't accept for example an aswer of "n o". Is that logical for that method? Is it supposed to work that way? How can I change the program to accept answers like "Yes" "ye s" "No" "NO" etc.? I would appreciate your help:)

import acm.program.*;

public class YesNoExample extends ConsoleProgram{
public void run(){
    while(true){
    String answer = readLine("Would you like instructions? ");
    if(askYesNoQuestion(answer)){
        break;
    }
    println("Please answer yes or no.");
    }
}

private boolean askYesNoQuestion(String str){
    if(str.equals("yes")||str.equals("no")){
        return true;
    }else{
        return false;
    }
}

}

`.equals` does not differ from `==` in that it ignores spaces or capitalization. You either need to get a new book, or just read that part again :) — Ry-, Jul 05 '12 at 16:12
The only part that makes sense is "The book I have suggested me not to use == comparison and to use the equals method instead" - see for example: http://stackoverflow.com/questions/513832/how-do-i-compare-strings-in-java The rest makes no sense. — assylias, Jul 05 '12 at 16:14
In Java you cannot override operators like `==`, but you can override the `.equals()` method IIRC. Also I believe there is an `.equalsIgnoreCase()` method. The code you have will only accept `yes` or `no`. If you want to accept spaces between letters, etc., you will have to code for it. — taz, Jul 05 '12 at 16:14
The suggested answer on the link posted by assylias explains the difference very well. — taz, Jul 05 '12 at 16:16
The book comes from Stanford and specifically states: "The value read in from the user may well be a object composed of the characters 'y' , 'e' and 's' but it will not be the same object as the constant string "yes" that appears in the program. What you need to ask instead is whether the two strings contain the same sequence of characters, which is precisely what the equals method does. Thus, the statement you need to wdte is if (answer.equals("yes"))... — mgus, Aug 25 '12 at 11:07

score 2 · Accepted Answer · answered Jul 05 '12 at 16:14

If you use == you'll be comparing the references (memory pointers) of two String objects. If you use equals, a custom made method in the String class will be run that does some "intelligent" comparison, in this case, check that the characters are all the same, and the whole thing has the same length.

If you'd like to support mixed case letters, you could use "someString".equalsIgnoreCase("SoMeString") (which will return true). This is done (said roughly) by making both strings lowercase (so the case doesn't matter) and comparing them using equals.

Edit: The other posters made me realize that, in addition to capitalization, you also want to look for String equality where spaces don't matter. If that's the case, a similar trick to turning everything to lowercase applies, where you first remove all the spaces, as @LouisWasserman says in his answer

Marko Topolnik · Answer 2 · 2012-07-06T20:06:52.680

1

If you need to fuzzily identify yes/no, first you need exact rules as to what matches. Based on your examples, I can suggest this:

private boolean askYesNoQuestion(String str) {
  str = str.replace(" ", "").toUpperCase();
  return str.equals("YES") || str.equals("NO");
}

If interested in top performance and not at all in intelligibility, use this:

private static final Pattern p = 
    Pattern.compile("y\\s*e\\s*s|n\\s*o", Pattern.CASE_INSENSITIVE);
private boolean askYesNoQuestion(String str) {
  return p != null && p.matcher(str.trim()).matches();
}

edited Jul 06 '12 at 20:06

answered Jul 05 '12 at 16:48

Marko Topolnik

195,646
29
319
436

`.toLowerCase()` is redundant as `.equalsIgnoresCase()` is a better alternative, especially with Unicode as a consideration. Also matching against `" "` isn't as comprehensive as `"\\s"`. And testing against `str` instead of the literal opens you up to `NullPointerExceptions`. Lots of non-idiomatic Java here. – Jul 05 '12 at 22:04
So you're **dowvoting** because there are minor points to improve?? Bravo. BTW `equalsIgnoreCase` will do the work TWICE, I already had it and explicitly went to this solution. Matching against " " is based OP's examples and is faster for that case. As far as NPE, look at the log in your eye first. – Marko Topolnik Jul 06 '12 at 05:50
the regular expressions you have aren't correct/comprehensive and aren't the ideal solution either, when there are much simpler more appropriate non-regular expression solutions. Implying that a regular expression provides *"top performance*, is naive at best, regular expressions are *slow*, especially compared to `.equalsIngnoreCase()` which is even faster than `.equals()` in Java. – Jul 06 '12 at 15:09
1

Your own solution employs a regex, and badly. As for performance, I have already done the tests: your solution is within 5% of the first of mine two; my second solution at least **five times** faster. As for `equalsIgnoreCase` vs. `equals` in isolation, `equals` is at least **ten times** faster. – Marko Topolnik Jul 06 '12 at 15:45
1

"aren't correct/comprehensive" -- provide a counterexample string which makes my method disagree with yours. – Marko Topolnik Jul 06 '12 at 16:50
1

@JarrodRoberson I went to see what's going on in `equalsIgnoreCase`, you may be [surprised to find out](http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/lang/String.java#1390): it converts **each char individually to uppercase** and compares them. Failing that, it then **converts both chars to lowercase** and compares them again! When I went for `string.toLowerCase`, I had a hunch it converted both chars to either lower or upper case, actually it does BOTH! – Marko Topolnik Jul 06 '12 at 19:56

score 0 · Answer 3 · 2012-07-06T15:04:33.180

Semantics of `==` vs `.equals()`

First off you misunderstand the semantics.

== tests for object identity. A == B says is A a reference to the exact same object as B.

.equals() applies custom logic to test if the objects are equal in some logical manner, without being the exact same object. For this to be implemented correct, both objects should have the same .hashCode() value as well.

Idiomatic Java Solution

Since the String object is final which means it can't be inherited from. You can't override the .equals() on the String object.

What you need to do is preprocess the input into something that can be directly compared to the target value with .equalsIgnoreCase().

One way to do this is use, answer.replaceAll("\\s","") to remove all the whitespace then you can compare it to your target String literal with .equalsIgnoreCase().

A better method to replace askYesNoQuestion() would be:

private boolean isAnswerYesOrNo(final String answer)
{
    final String input = answer.replaceAll("\\s","");
    return "yes".equalsIgnoreCase(input) || "no".equalsIgnoreCase(input);
}

Comparing a literal to the input parameter will insulate you from NullPointerExceptions if the input parameter happens to be null "yes".equalsIgnoreCase()can never throw aNullPointerException`. This is idiomatic Java.

Get a better book

That book isn't very useful if it really says what you are claiming it says. Also it is teaching you to write lots of code to handle bad input when that is a complete anti-pattern and a well designed program would exit with a verbose explanation of the exact problem was what can be done to fix the input.

@MarkoTopolnik show me code where a literal `String.equals()` against a `null` throws a `NPE` can't happen. `"MYSTRING".equalsIgnoreCase(null);` doesn't throw an `NPE` ever. That is why it is the preferred idiom. — , Jul 06 '12 at 15:12
@MarkoTopolnik that isn't my claim, nor your initial complaint, read my comment for comprehension. — , Jul 06 '12 at 15:51
Your code **can never call `equalsIgnoreCase` with a `null` argument**, so what is your point in using Yoda conditions? — Marko Topolnik, Jul 06 '12 at 15:58
You downvote my solution because, among others, "testing against `str` instead of the literal opens you up to `NullPointerExceptions`". At the same time, your code behaves **exactly the same** for a `null` argument. Care to explain *that*? — Marko Topolnik, Jul 06 '12 at 16:46

score -1 · Answer 4 · answered Jul 05 '12 at 16:58

With the explanation of == and .equals well described above, here's a two examples of a one liner that does the comparison you want.

if ( Pattern.matches("\\s*[yY]\\s*[eE]\\s*[sS]\\s*", input) ) {
  // do something
}


if ( input.replaceAll("\\s", "").equalsIgnoreCase("yes") ) {
  // do something
}

How does object.equals method is supposed to work in Java?

4 Answers4

Semantics of == vs .equals()

Idiomatic Java Solution

Get a better book

Semantics of `==` vs `.equals()`