String : Java Glossary

You get the size of a String (length in chars) with String. length(), not .length or. size() used in other classes.

For manipulating 8-bit characters, you want an array of bytes — byte[].

Empty Strings

String Comparison

if ( "abc".equals (s) ) echo ( "matched" );

if ( s.equals ( "abc" ) ) echo ( "matched" );

Unless Strings have been interned, with String.intern(), you cannot compare them for equality with ==. You have to use equals() instead.

The compiler will not warn you if you inadvertently use ==. Unfortunately, the bug may take a long time to surface if your compiler or virtual machine is doing transparent interning. Interning gets you a reference to the master copy of a String. This allows the duplicates to be garbage collected sooner. However, there are three disadvantages to interning:

1. It takes extra time to look up the master string in a Hashtable.
2. In some implementations, you can have a maximum of 64K interned Strings.
3. In some implementation, interned Strings are never garbage collected, even when they are no longer used. The interning process itself acts as a packratter. The answer is to implement them with weak references.

String s = "apple";
String t = "orange";
if ( s.compareTo(t) < 0 )
   {
   System.out.println( "s < t" );
   }

• some positive number if string s lexically comes after t.
• 0 if s is the same as t.
• some negative number if s sorts earlier than t.

Novices might be astonished by the following results:

• abc.compareTo( ABC) returns abc > ABC. compareTo is case sensitive.
• abc .compareTo ( abc( returns abc > abc. Blanks are treated like any other character.
• "".compareTo( null) raises a java.lang.NullPointerException.
• "" is not the same thing as null. Most String functions will be happy to handle "", but very few will accept null.
• The comparison is done by straightforward Unicode numeric character by character comparison. There is no adjustment for locale collating sequence.

Case-Sensitive and Case-Insensitive Comparison

Searching

Creating Strings

• you concatenate.
• you read Strings from files.
• you foolishly use new String(String);. There is one situation where its use is legit. See substring for the explanation.
• you use new String( somethingElse ) ; for conversion.
• You use StringBuffer/StringBuilder toString/substring.

toString

You use it like this: String toShow = myThing. toString();

The default Object.toString method is not very clever. It does not display all the primitives in your class with field names as you might expect. If you want that, you must code it yourself. A default toString will typically, instead, do something lame like dump the hashCode or the Object’s address — only mildly interesting.

toString has a magical property. It appears to get invoked automatically to convert to String without you having to mention toString.

1. In one case, System.out.println (and brothers), it is not really magic. println pulls it off with a plethora of overloaded methods. println has many overloaded methods, one for each of the primitive types, and then each overloaded method converts its primitive parameter to a String for you, and passes that on to the variant of println that can only handle Strings. But, you say, (glad to see you are so attentive), primitives don’t have a toString method! That is true, but there are static conversion methods to get that effect, such as String. valueOf( double ). For any Object other than a String, println invokes the Object’s usually-overridden custom toString method and passes the result on to the String-eating version of println.
2. When you use concatenation, toString truly does get called for you magically, sometimes. If ever you try to add two Objects, Java presumes you are really trying to concatenate them and transparently calls each of their toString methods and concatenates the results giving a String. It even works when you try to add a String and a primitive. Concatenation will convert the primitive to a String for you and concatenate the results, transparently. This can lead to surprising results.

Replace

replaceAll( String regex, String replacement ) also replaces all instances. The difference is, replaceAll looks for a regex String not a simple String. Beware of using replaceAll( String regex, String replacement) when you meant replace( String target, String replacement ). The second parameter is not just a simple String. String. replaceAll behaves like Matcher. replaceAll. $ is a reference to a captured String in the search pattern and \ is the regex quote character, meaning literal \ must be coded as \\\\ and literal $ as \\$.

replaceFirst( String regex, String replacement ) also takes a regex. There is no replaceFirst that takes only a simple String.

String.replace in the Javadoc is shown with CharSequence parameters. Don’t let this frighten you. String implements CharSequence, so replace works fine on Strings. replace works on some other things as well such as StringBuilders.

Validating

You can also use charAt to extract the characters one by one, then categorise them with the Character methods such as isDigit.

Regex

Not only replaceAll but replace is implemented in an inefficient way, compiling a regex pattern every time it is invoked:

Gotchas

• String.replaceAll( a, b ) is not the method to use to replace all instances of b in a. Instead you use String. replace ( a, b ). replaceAll is a convenience regex method.
• String.replace ( a, b ) does not modify a. It creates a new modified String. This is true of all String methods. Strings are immutable. No method can modify the original String.
• Consider lastIndexOf( s, fromIndex). fromIndex is the offset near the end of the string where to start searching backwards for a match earlier in the string. It is not the index of a substring to search, i.e. the place where the reverse searching stops.

Learning More