String fundamentals

A char is a single 16-bit value, written with single quotes ('a'); a String is an immutable sequence of chars, written with double quotes ("a"). They are different types: 'a' is a number-like primitive, "a" is an object. A String is conceptually a char[] with methods, but you cannot modify it in place.

s.charAt(i) returns a char; String.valueOf(c) or "" + c turns a char into a String.

1char c = 'a';
2String s = "abc";
3char first = s.charAt(0);                 // 'a'
4String one = String.valueOf(c);           // "a"
5char[] letters = s.toCharArray();         // a mutable copy: {'a', 'b', 'c'}
6String back = new String(letters);        // "abc"

ASCII assigns numbers 0 to 127 to English letters, digits, punctuation and control characters: '0' to '9' are 48 to 57, 'A' to 'Z' are 65 to 90 and 'a' to 'z' are 97 to 122. Because letters and digits are consecutive, c - 'a' is a letter's index and c - '0' a digit's value, and upper and lower case differ by 32.

Step through the string to see each character's code and the XOR 32 case trick.

1int idx = 'q' - 'a';                       // 16
2int digit = '7' - '0';                     // 7
3char upper = (char) ('g' - 32);            // 'G'
4boolean isLower = c >= 'a' && c <= 'z';

1for (int i = 0; i < s.length(); i++) {
2    char c = s.charAt(i);
3    int code = c;                        // widening: the character's numeric code
4    int index = c - 'a';                 // 0..25 for lowercase letters
5    int digit = c - '0';                 // 0..9 for digits
6}
7// toggle ASCII case: flip bit 5 (value 32); letters only
8char flipped = (char) (c ^ 32);          // 'a' (97) <-> 'A' (65)

Unicode is the universal character set: it assigns every character a number called a code point (U+0041 is 'A', U+00E9 is 'é', U+1F600 is a smiling emoji). There are over a million code points. ASCII is just the first 128 of them. How code points are stored in bytes is a separate matter: that is the encoding (UTF-8, UTF-16, ...).

Enter an emoji in the animation and compare the number of code units with the number of code points.

1int cp = "é".codePointAt(0);                    // 233 = U+00E9
2String smile = new String(Character.toChars(0x1F600));
3int len = smile.length();                        // 2: two UTF-16 units
4int chars = smile.codePointCount(0, len);        // 1: one character

1int units = s.length();                           // UTF-16 code units
2int count = s.codePointCount(0, units);           // real characters
3for (int i = 0; i < units; ) {
4    int cp = s.codePointAt(i);                    // combines a surrogate pair into one code point
5    i += Character.charCount(cp);                 // 2 for supplementary characters, otherwise 1
6}

Java strings are sequences of UTF-16 code units, each 16 bits. Code points up to U+FFFF (the Basic Multilingual Plane) take one unit. Larger code points, such as most emoji, are encoded as a surrogate pair of two units. length(), charAt and substring all work in units, not in characters.

The hex cells in the animation are the actual code units.

1int units = s.length();                           // UTF-16 code units
2int count = s.codePointCount(0, units);           // real characters
3for (int i = 0; i < units; ) {
4    int cp = s.codePointAt(i);                    // combines a surrogate pair into one code point
5    i += Character.charCount(cp);                 // 2 for supplementary characters, otherwise 1
6}

A code point is a whole Unicode character. Use codePointAt(i), codePointCount, codePoints() and Character.charCount(cp) when you mean characters rather than units. Character.isLetter(int) has an overload that takes a code point.

Walk through a string with an emoji and see one code point cover two units.

1String s = "Hi��";
2int units = s.length();                       // 4
3int points = s.codePointCount(0, units);       // 3
4int[] cps = s.codePoints().toArray();         // {72, 105, 128512}

1int units = s.length();                           // UTF-16 code units
2int count = s.codePointCount(0, units);           // real characters
3for (int i = 0; i < units; ) {
4    int cp = s.codePointAt(i);                    // combines a surrogate pair into one code point
5    i += Character.charCount(cp);                 // 2 for supplementary characters, otherwise 1
6}

A String cannot change after creation: every operation such as concat, replace, substring or toUpperCase returns a new String. This makes strings safe to share between threads, safe as hash keys (the hash code can be cached) and enables the string pool. The price is that building a string by repeated concatenation copies characters every time.

Use StringBuilder when you build or edit text in a loop.

1String s = "cat";
2String t = s.toUpperCase();    // new object "CAT"
3s.concat("s");                  // result ignored: s is still "cat"
4System.out.println(s);         // cat

String literals are interned: identical literals share one object in the string pool, so "java" == "java" is true. Strings created with new or at runtime are separate objects, so == compares references and can be false even for equal text. Always compare strings with equals. intern() returns the pooled instance.

Compile-time constant expressions such as "ja" + "va" are also pooled.

1String a = "java";
2String b = "java";
3String c = new String("java");
4boolean same = (a == b);                 // true: both are the pooled literal
5boolean ref = (a == c);                  // false: c is a new object
6boolean eq = a.equals(c);                // true
7boolean pooled = (a == c.intern());      // true