String, StringBuilder, Character and regular expressions

Text processing is in every program: validating a username, splitting a CSV line, counting words. In the exam this topic comes as short but tricky output questions: the end index of substring, the immutability of String, char arithmetic, the empty parts of split. There is also a “write a method” question: palindrome, word counting, converting to upper case.

Golden rules:

1. String is immutable. Methods return a new String; if you do not assign it, the result is lost.
2. substring(a, b) does not take b. The length is b - a.
3. char is a number. 'A' + 2 gives an int (67); if you want a character, cast it.
4. StringBuilder for text that changes. Its methods change the same object.
5. A backslash in a regex is written twice in a Java String: "\\d+".

String methods

String s = "Object Oriented";
System.out.println(s.length());
System.out.println(s.charAt(7));
System.out.println(s.indexOf('e'));
System.out.println(s.lastIndexOf('e'));
System.out.println(s.indexOf("Or"));
System.out.println(s.indexOf('z'));
System.out.println(s.substring(7));
System.out.println(s.substring(0, 6));
System.out.println(s.substring(2, 4));
System.out.println(s.toUpperCase() + " " + s.toLowerCase());
System.out.println("[" + "  hi there ".trim() + "]");
System.out.println(s.replace('e', '3'));
System.out.println(s.startsWith("Obj") + " " + s.endsWith("ED") + " " + s.contains("ted"));

15
O
3
13
7
-1
Oriented
Object
je
OBJECT ORIENTED object oriented
[hi there]
Obj3ct Ori3nt3d
true false true

index:      0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
character:  O b j e c t _ O r i e  n  t  e  d      (_ = space)
substring(2, 4) → 2 and 3 → "je"        substring(7) → from 7 to the end → "Oriented"

PITFALL · bounds. "java".substring(2, 5) and "java".charAt(4) throw StringIndexOutOfBoundsException when they run. But "java".substring(4) does not give an error, it returns an empty String (isEmpty() is true).

Immutability

Once a String object is created, its content does not change. Methods such as toUpperCase, concat and replace produce a new String.

String t = "java";
t.toUpperCase();          // result not assigned, lost
t.concat("!");            // same
System.out.println(t);
t = t.toUpperCase();      // t now points to the new object
System.out.println(t);

java
JAVA

For the same reason, after String u = "A"; String v = u; v += "B"; u is still "A": += creates a new object and assigns it to v. With StringBuilder, however, two references change the same object (below).

Comparison

System.out.println("Java".equals("java") + " " + "Java".equalsIgnoreCase("java"));
System.out.println("Apple".compareTo("apple"));
System.out.println("cat".compareTo("car"));
System.out.println("ab".compareTo("abcd"));

false true
-32
2
-2

The Character class and char arithmetic

A char is really a 16-bit number (a Unicode code). When it enters arithmetic it is promoted to int. Memorize: '0' = 48, 'A' = 65, 'a' = 97; the gap between upper and lower case is 32.

System.out.println('A' + 2);           // int
System.out.println((char) ('A' + 2));  // char
System.out.println("A" + 2);           // String concatenation
char c = 'x';
c++;                                   // ++ stays a char
System.out.println(c);
System.out.println('7' - '0');         // value of the digit

67
C
A2
y
7

The static methods of the Character class:

String mix = "a1B2 c3!";
int letters = 0, digits = 0, upper = 0, spaces = 0;
for (int i = 0; i < mix.length(); i++) {
    char ch = mix.charAt(i);
    if (Character.isLetter(ch)) letters++;
    if (Character.isDigit(ch)) digits++;
    if (Character.isUpperCase(ch)) upper++;
    if (Character.isWhitespace(ch)) spaces++;
}
System.out.println(letters + " " + digits + " " + upper + " " + spaces);

3 3 1 1

StringBuilder

If you build text piece by piece or change it often, use StringBuilder. Its content is changeable (mutable); its methods change the same object and return it, which is why they are chained.

StringBuilder sb = new StringBuilder("code");
sb.append(42).append('!');
System.out.println(sb);
sb.insert(0, "my ");
System.out.println(sb);
sb.reverse();
System.out.println(sb);
sb.reverse().deleteCharAt(sb.length() - 1).setCharAt(0, 'M');
System.out.println(sb + " len=" + sb.length());

StringBuilder sb2 = new StringBuilder("abc");
sb2.replace(1, 2, "XYZ");     // 1 included, 2 excluded
System.out.println(sb2);
sb2.delete(0, 2);
System.out.println(sb2);

code42!
my code42!
!24edoc ym
My code42 len=9
aXYZc
YZc

StringBuilder x = new StringBuilder("hi"), y = new StringBuilder("hi");
System.out.println(x.equals(y));
System.out.println(x.toString().equals(y.toString()));

StringBuilder p = new StringBuilder("A");
StringBuilder q = p;
q.append("B");            // same object
System.out.println(p);

false
true
AB

PITFALL · a loop that prepends. r = i + r; and rb.insert(0, i); both put each element at the front. In a loop from 0 to 3, both produce 3210. If you had appended at the end, it would be 0123.

Regular expressions

A regex is a small language that describes a text pattern. In Java you use it in three places: matches (validation), split (splitting), replaceAll (replacing).

Because \ is the escape character in a Java String, every backslash of the regex is written twice: \d+ in a regex, "\\d+" in Java. To search for a special character such as the dot literally, you also escape it: "\\.".

matches: validation

matches tells whether the whole text fits the pattern.

System.out.println("202312345".matches("\\d{9}"));          // 9-digit student number
System.out.println("20231234".matches("\\d{9}"));
System.out.println("abc123".matches("[a-z]+\\d+"));
System.out.println("abc123x".matches("[a-z]+\\d+"));
System.out.println("Ankara".matches("[A-Z][a-z]*"));        // a word starting with a capital letter
System.out.println("ali@bau.edu.tr".matches("[\\w.]+@[\\w.]+\\.[a-z]{2,}"));
System.out.println("05321234567".matches("05\\d{9}"));      // mobile phone

true
false
true
false
true
true
true

split and replaceAll

System.out.println(Arrays.toString("a,b,,c,,".split(",")));
System.out.println("a,b,,c,,".split(",").length);
System.out.println(Arrays.toString(",x,y".split(",")));
System.out.println(Arrays.toString("  one   two three ".trim().split("\\s+")));
System.out.println(Arrays.toString("1.5.9".split("\\.")));
System.out.println("1.5.9".split(".").length);   // "." is any character: every character is a separator

[a, b, , c]
4
[, x, y]
[one, two, three]
[1, 5, 9]
0

System.out.println("programming".replaceAll("[aeiou]", "*"));
System.out.println("a1b22c333".replaceAll("\\d+", "#"));
System.out.println("too    many   spaces".replaceAll(" +", " "));
System.out.println("2026-10-28".replaceAll("(\\d+)-(\\d+)-(\\d+)", "$3/$2/$1"));
System.out.println("x.y.z".replace(".", "-") + " " + "x.y.z".replaceAll(".", "-"));

pr*gr*mm*ng
a#b#c#
too many spaces
28/10/2026
x-y-z -----

Parentheses create a group; in the replacement text you can refer back to the groups by the numbers 1, 2, 3 (the date example above).

Pattern and Matcher

To find, one by one, all the parts inside a text that fit the pattern:

Matcher m = Pattern.compile("\\d+").matcher("Room 12, floor 3, gate 104");
int sum = 0;
while (m.find()) {
    System.out.print(m.group() + " ");
    sum += Integer.parseInt(m.group());
}
System.out.println("sum=" + sum);

12 3 104 sum=119

matches wants the whole text, while find searches inside the text for the next part that fits.

A solved writing question: palindrome

“A man, a plan, a canal: Panama”: after throwing away everything except letters and digits and converting to lower case, is it the same as its reverse?

static boolean isPalindrome(String s) {
    StringBuilder clean = new StringBuilder();
    for (char c : s.toCharArray())
        if (Character.isLetterOrDigit(c)) clean.append(Character.toLowerCase(c));
    String fwd = clean.toString();               // copy BEFORE reverse
    return fwd.equals(clean.reverse().toString());
}
System.out.println(isPalindrome("A man, a plan, a canal: Panama"));
System.out.println(isPalindrome("Java"));

true
false

Taking fwd before reverse is a must: reverse reverses the same object. clean.toString().equals(clean.reverse().toString()) also works (the left side is evaluated first), but a separate variable is more readable.

Common mistakes

String s = "Object Oriented";
System.out.println(s.indexOf('e') + " " + s.lastIndexOf('e'));
System.out.println(s.substring(2, 4) + s.substring(7, 8));

String t = "java";
t.toUpperCase();
t.concat("!");
System.out.println(t);

System.out.println('A' + 2);
System.out.println((char) ('A' + 2));
System.out.println("A" + 2);
System.out.println('7' - '0');

StringBuilder sb = new StringBuilder("code");
sb.append(42).append('!');
sb.insert(0, "my ");
System.out.println(sb);
sb.reverse();
System.out.println(sb);

StringBuilder x = new StringBuilder("hi"), y = new StringBuilder("hi");
System.out.println(x.equals(y));
System.out.println(x.toString().equals(y.toString()));

System.out.println(Arrays.toString("a,b,,c,,".split(",")));
System.out.println(Arrays.toString(",x,y".split(",")));

System.out.println("202312345".matches("\\d{9}"));
System.out.println("20231234".matches("\\d{9}"));
System.out.println("abc123x".matches("[a-z]+\\d+"));

System.out.println("programming".replaceAll("[aeiou]", "*"));
System.out.println("a1b22c333".replaceAll("\\d+", "#"));
System.out.println("x.y.z".replace(".", "-") + " " + "x.y.z".replaceAll(".", "-"));

String mix = "a1B2 c3!";
int letters = 0, digits = 0, upper = 0;
for (int i = 0; i < mix.length(); i++) {
    char ch = mix.charAt(i);
    if (Character.isLetter(ch)) letters++;
    if (Character.isDigit(ch)) digits++;
    if (Character.isUpperCase(ch)) upper++;
}
System.out.println(letters + " " + digits + " " + upper);

System.out.println("Apple".compareTo("apple"));
System.out.println("cat".compareTo("car"));
System.out.println("ab".compareTo("abcd"));

String s = "cat";
s.charAt(0) = 'b';
StringBuilder sb = "hello";
char c = s.substring(0, 1);

public static String capitalizeWords(String text) {
    String[] words = text.trim().split("\\s+");
    StringBuilder sb = new StringBuilder();
    for (String w : words) {
        if (sb.length() > 0) sb.append(' ');
        sb.append(Character.toUpperCase(w.charAt(0)));
        sb.append(w.substring(1).toLowerCase());
    }
    return sb.toString();
}