Java String.indexOf and empty Strings

Well, if it helps, you can think of "FOO" as "" + "FOO".

int number_of_empty_strings_in_string_named_text = text.length() + 1

All characters are separated by an empty String. Additionally empty String is present at the beginning and at the end.

This question is actually two questions:

1. Why should a string contain the empty string?
2. Why should the empty string be found specifically at index zero?

Answering #1:

It is a matter of convention. The designers of the language could have implemented it either way:

• The empty string can be found inside all strings
• The empty string can never be found in any string

They decided that the empty string can be found in all strings so as to be in accordance with Set Theory (See Wikipedia), according to which:

The empty set is a subset of every set including itself.

This also means that even the empty string contains the empty string, and the following statement proves it:

assert "".indexOf( "" ) == 0;

I am not sure why the mathematicians who came up with Set Theory decided that the empty set should behave this way, but I am pretty sure they had their reasons, and it appears that these reasons can be explained in layman's terms, as various youtube videos seem to do; for example: https://www.youtube.com/watch?v=1nBKadtFViM.

^{Although I have to admit that I have not actually viewed any of those videos, because #AintNoBodyGotNoTimeFoDat.}

Answering #2:

The empty string can be found at the first index examined, because the indexOf() function returns the index of the first occurrence, and the empty string is everywhere, including at the first index examined.

Using an algebraic approach, "" is the neutral element of string concatenation: x + "" == x and "" + x == x (although + is non commutative here).

Then it must also be:

x.indexOf ( y ) == i and i != -1 
<==> x.substring ( 0, i ) + y + x.substring ( i + y.length () ) == x

when y = "", this holds if i == 0 and x.substring ( 0, 0 ) == "". I didn't design Java, but I guess mathematicians participated in it...

if we look inside of String implementation for a method "foo".indexOf(""), we arrive at this method:

public int indexOf(String str) {
    byte coder = coder();
    if (coder == str.coder()) {
        return isLatin1() ? StringLatin1.indexOf(value, str.value)
                          : StringUTF16.indexOf(value, str.value);
    }
    if (coder == LATIN1) {  // str.coder == UTF16
        return -1;
    }
    return StringUTF16.indexOfLatin1(value, str.value);
}

If we look inside of any of the called indexOf(value, str.value) methods we find a condition that says:

if the second parameter (string we are searching for) length is 0 return 0:

 public static int indexOf(byte[] value, byte[] str) {
    if (str.length == 0) {
        return 0;
    }
    ...

This is just defensive coding for an edge case, and it is necessary because in the next method that is called to do actual searching by comparing bytes of the string (string is a byte array) it would otherwise have resulted in an ArrayIndexOutOfBounds exception:

public static int indexOf(byte[] value, int valueCount, byte[] str, int strCount, int fromIndex) {
        byte first = str[0];
...

By using the expression "", you are actually referring to a null string. A null string is an ethereal tag placed on something that exists only to show that there is a lack of anything at this location.

So, by saying "".indexOf( "" ), you are really asking the interpreter:

Where does a string value of null exist in my null string?

It returns a zero, since the null is at the beginning of the non-existent null string.

To add anything to the string would now make it a non-null string... null can be thought of as the absence of everything, even nothing.