Strings

1A String is an object that holds characters

String is a class in java.lang. "A12" is a String object. It has methods: length, charAt, substring, equals.

It is not a char. A char is one 16-bit unit. A String is a sequence of them with a length.

Figure. "A12" is a String object, a sequence of characters with a length. length is 3. charAt(0) is A. It is not a char.

length 3; first character A

String seat = "A12";
int n = seat.length();
char row = seat.charAt(0);

2A String does not change in place

String is immutable: every method that looks like an edit returns a new String. seat.toUpperCase() does not alter seat unless you assign the result.

seat + " student" builds another object. The old "A12" is unchanged. That is why == after concat is not the original object.

Figure. seat.toUpperCase() does not alter seat unless you assign the result. The old A12 is unchanged. Every method that looks like an edit returns a new String.

How it works

1. A String does not change in placeString methods return a new String. Assign if you want to keep the result.

Forget the assignment and nothing changes

String seat = "A12";
seat.toUpperCase();
// seat is still "A12"
seat = seat.toUpperCase();
// now seat is "A12" in upper case — a new object

3CharSequence is the shared text contract

CharSequence is an interface: length, charAt, subSequence. String implements it. So do StringBuffer and StringBuilder.

A method that only needs to read characters should take CharSequence so a buffer or a String may both be passed.

Figure. CharSequence is the shared text contract: length, charAt, subSequence. String implements it. So do StringBuffer and StringBuilder. show("A12") passes a String.

How it works

1. CharSequence is the shared text contractCharSequence is readable text. String is one implementation.

String is a CharSequence

void show(CharSequence text) {
    System.out.println(text.length());
}
show("A12");

4The methods the desk actually calls

equals compares characters. contains, startsWith and indexOf search. substring copies a slice. split cuts on a delimiter. trim drops edge spaces.

None of these change the original String. Read the return value.

No diagram — the idea is carried by the prose or the Java listing.

split returns a new array of Strings

String line = "A12,200";
String[] parts = line.split(",");
boolean student = line.startsWith("S");

Coding lab. Split the stub and print the seat runs in the app, with checks on your output.

5StringBuffer is a mutable, thread-safe buffer

StringBuffer holds characters you can append, insert or delete without building a new String each time. When the stub is finished, toString() gives a String.

Its methods are synchronized: two threads appending to the same buffer will not tear a character. StringBuilder is the faster unsynchronized twin for one thread.

Figure. StringBuffer appends A12, a space, and 200 in place. toString() then gives an immutable String. Prefer it when several threads share the buffer.

How it works

1. StringBuffer is a mutable, thread-safe bufferStringBuffer mutates. toString() is the immutable snapshot. Prefer it when several threads share the buffer.

Append in place, then freeze to a String

StringBuffer stub = new StringBuffer();
stub.append("A12");
stub.append(' ');
stub.append(200);
String line = stub.toString();

6== is the same object; equals is the same characters

For String, == asks whether both variables refer to the same object. equals asks whether the characters match.

Literals like "A12" may be interned and share an object. new String("A12") is a second object. The desk compares seats with equals, not ==.

Figure. a is the literal A12. b is new String("A12") — a second object. == is false. equals is true: the characters match. The desk compares seats with equals, not ==.

== may be false; equals is true

String a = "A12";
String b = new String("A12");
System.out.println(a == b);
System.out.println(a.equals(b));