how does String.equals() work

Question

I have been trying to understand how some of API methods work

below is a snippet of equals method of java.lang.String class

Can someone out there tell me how actually the code is comparing two strings. I get the significance of count, but what does offset signify. how are these variables getting values ?

Like when i create a String. how are these initialized.

a detailed line by line description and also how and when the instance variables, value, count, offset etc are initialized ??

 public boolean equals(Object anObject) {
  1014           if (this == anObject) {
  1015               return true;
  1016           }
  1017           if (anObject instanceof String) {
  1018               String anotherString = (String)anObject;
  1019               int n = count;
  1020               if (n == anotherString.count) {
  1021                   char v1[] = value;
  1022                   char v2[] = anotherString.value;
  1023                   int i = offset;
  1024                   int j = anotherString.offset;
  1025                   while (n-- != 0) {
  1026                       if (v1[i++] != v2[j++])
  1027                           return false;
  1028                   }
  1029                   return true;
  1030               }
  1031           }
  1032           return false;
  1033       }

RNJ · Accepted Answer · 2012-09-30T13:12:58.707

Logically

while (n-- != 0) {
if (v1[i++] != v2[j++])
    return false;
}

is the same as

for (int i = 0; i < n; i++) {
    if (v1[i] != v2[j])
        return false;
    }
}

Why the JVM designers have done it this way I am not sure. Perhaps there is a performance improvement using a while loop than a for loop. It looks quite C like to me so maybe the person who wrote this has a background in c.

Offset is used to locate where the string starts within the char array. Internally Strings are stored as char arrays. This is value

if (v1[i++] != v2[j++])
    return false;

checks the characters in the string's underlying char array.

and line by line it is

if the refernce is pointing to the same object is must the equals

1014           if (this == anObject) {
1015               return true;
1016           }

if the object is a string then check they are equal

1017           if (anObject instanceof String) {

cast the parameter passed in as String.

1018               String anotherString = (String)anObject;

remember the length of this.string

1019               int n = count;

if the two string's lengths match

1020               if (n == anotherString.count) {

get an array of the characters (value is this array)

1021                   char v1[] = value;
1022                   char v2[] = anotherString.value;

find out where in this array the string starts

1023                   int i = offset;
1024                   int j = anotherString.offset;

loop through char array. if the values are different then return false

1025                   while (n-- != 0) {
1026                       if (v1[i++] != v2[j++])
1027                           return false;
1028                   }

everything else must be true

1029                   return true;
1030               }
1031           }

if not of type String then they cannot be equals

1032           return false;
1033       }

To understand offset and value look at the String class

/** The value is used for character storage. */
private final char value[];

/** The offset is the first index of the storage that is used. */
private final int offset;

/** The count is the number of characters in the String. */
private final int count;

The constructors initialises these variables. The default constructor code is below. You should see something similar for the other constructors.

/**
  * Initializes a newly created {@code String} object so that it represents
  * an empty character sequence.  Note that use of this constructor is
  * unnecessary since Strings are immutable.
  */
 public String() {
    this.offset = 0;
    this.count = 0;
    this.value = new char[0];
 }

This is quite a good link to look at

One more question, I couldnt find a constructor that is initializing these instance variable. Is there one ? Is this handled by JVM.? — Mukul Goel, Sep 30 '12 at 13:11
Just updated the answer with the default ctor for string where these are initialised — RNJ, Sep 30 '12 at 13:13

Ankur · Answer 2 · 2012-09-30T12:58:03.727

As you may be knowing that string handling in Java is a special case, most of the time the String is assigned from the String pools, so it might be the case that for a char array "I am Learning Java", one string reference points to "I am Learning Java", then offset would be 0, other string might point to "am" so offset would be 2. As some of the native code handles its initilization so i think offset is set during that process.(during sharing memory from String pool)

Also as you can see from the code

 public String(String original) {
         int size = original.count;
        char[] originalValue = original.value;
        char[] v;
        if (originalValue.length > size) {
            // The array representing the String is bigger than the new
          // String itself.  Perhaps this constructor is being called
            // in order to trim the baggage, so make a copy of the array.
           int off = original.offset;
          v = Arrays.copyOfRange(originalValue, off, off+size);
        } else {
           // The array representing the String is the same
          // size as the String, so no point in making a copy.
            v = originalValue;
       }
      this.offset = 0;
       this.count = size;
       this.value = v;
    }

When new String is created from the old one, it might be the case that old string(original in this case) might be from String pool, thats why first a offset is taken and then the whole array is copied to allocate new memory(new string doesn't share memory from String pool)

Also you should remember String is a derived type and the string is always stored in a character array, so we need an offset to determine from where the string starts in the character array.

how does String.equals() work

2 Answers2

Linked