Strings & Big Numbers

Before we start

Why this matters

Outline · Lectures 22–23

Topics in this chapter

Select a topic to jump to the slide that explains it.

1. The String class and the string pool
2. Comparing strings
3. String operations
4. StringBuilder and StringBuffer
5. Big number manipulation using String

Concept 1 of 5

The String class and the string pool

The String class and the string pool

String a = "Hi";               // pool
String b = "Hi";               // same pooled object
String c = new String("Hi");   // new heap object
char[] cs = {'J', 'a', 'v', 'a'};
String d = new String(cs);     // "Java"
String e = String.valueOf(42); // "42"

• String is a class, but literals get special treatment: identical literals share one object in the string pool.
• Strings are immutable: no method changes a String; methods return a new one.
• Immutability makes strings safe to share between variables and threads.

Step through the code

Trace: pool, heap and ==

Watch which variables share an object. a + "!" builds a brand-new String — the original "Hi" is untouched.

Step through the code

Trace: pool, heap and == (cont.)

Concept 2 of 5

Comparing strings

String a = "apple", b = "Apple";
a == b                    // compares references
a.equals(b)               // false: content, case-sensitive
a.equalsIgnoreCase(b)     // true
a.compareTo(b)            // 32  ('a' 97 − 'A' 65)
"apple".compareTo("banana")  // -1  ('a' − 'b')
"app".compareTo("apple")     // -2  (length 3 − 5)

Concept 3 of 5

String methods at a glance

Interactive

String method playground

Code example

Processing text

String s = "Green University of Bangladesh";

int vowels = 0;
for (char ch : s.toLowerCase().toCharArray())
    if ("aeiou".indexOf(ch) >= 0) vowels++;

String[] words = s.split(" ");
String initials = "";
for (String w : words) initials += w.charAt(0);

String p = "madam";
boolean pal = new StringBuilder(p).reverse().toString().equals(p);

System.out.println(vowels + " " + words.length + " " + initials + " " + pal);
System.out.println(s.replace("Bangladesh", "BD").toUpperCase());

10 4 GUoB true
GREEN UNIVERSITY OF BD

Step through the code

Trace: split() and += on Strings

Every += creates a new String. Watch the old ones lose their last reference and become garbage.

Step through the code

Trace: split() and += on Strings (cont.)

Concept 4 of 5

StringBuilder

StringBuilder sb = new StringBuilder("GUB");
sb.append(" CSE").append(201);   // "GUB CSE201"
sb.insert(3, ",");               // "GUB, CSE201"
sb.reverse();                    // "102ESC ,BUG"
sb.setCharAt(0, '9');            // "902ESC ,BUG"
sb.deleteCharAt(sb.length() - 1);// "902ESC ,BU"
String result = sb.toString();

Step through the code

Trace: String + in a loop vs StringBuilder

Count the objects on the heap: every s + i leaves an abandoned String behind, while the builder reuses one object.

Step through the code

Trace: String + in a loop vs StringBuilder (cont.)

Concept 5 of 5

Big numbers stored as Strings

static String add(String a, String b) {
    StringBuilder sb = new StringBuilder();
    int i = a.length() - 1, j = b.length() - 1, carry = 0;
    while (i >= 0 || j >= 0 || carry > 0) {
        int d1 = i >= 0 ? a.charAt(i--) - '0' : 0;
        int d2 = j >= 0 ? b.charAt(j--) - '0' : 0;
        int sum = d1 + d2 + carry;
        sb.append(sum % 10);
        carry = sum / 10;
    }
    return sb.reverse().toString();
}

Interactive

Big-number addition, column by column

Code example

Multiplying big numbers

121932631112635269
1219326311370217952237463801111263526900

Digit i of a times digit j of b lands in column i + j + 1 of the result — the same shifted rows you write on paper.

Code example

The library way: BigInteger and BigDecimal

import java.math.*;

BigInteger f = BigInteger.ONE;
for (int i = 2; i <= 30; i++) f = f.multiply(BigInteger.valueOf(i));
System.out.println("30! = " + f);
System.out.println("2^100 = " + BigInteger.TWO.pow(100));

System.out.println(0.1 + 0.2);
BigDecimal x = new BigDecimal("0.1"), y = new BigDecimal("0.2");
System.out.println(x.add(y));

30! = 265252859812191058636308480000000
2^100 = 1267650600228229401496703205376
0.30000000000000004
0.3

• BigInteger: integers of any size. BigDecimal: exact decimal arithmetic for money.
• Both are immutable, like String: f.multiply(...) returns a new object.

Worked example 1 of 3

Worked example 1

Worked example 2 of 3

Worked example 2

String t = "  OOP   is   fun ";
String[] w = t.trim().split("\\s+");     // one or more spaces
System.out.println(w.length);            // 3

Worked example 3 of 3

Worked example 3

Practice

Practice (1 of 2)

Try each one on paper first, then check your answer.

static boolean isPal(String s) {
    s = s.toLowerCase();
    for (int i = 0, j = s.length() - 1; i < j; i++, j--)
        if (s.charAt(i) != s.charAt(j)) return false;
    return true;
}

Practice

Practice (2 of 2)

Try each one on paper first, then check your answer.

static String subtract(String a, String b) {
    StringBuilder sb = new StringBuilder();
    int borrow = 0;
    for (int i = a.length() - 1, j = b.length() - 1; i >= 0; i--, j--) {
        int d = a.charAt(i) - '0' - borrow - (j >= 0 ? b.charAt(j) - '0' : 0);
        borrow = d < 0 ? 1 : 0;
        sb.append(d < 0 ? d + 10 : d);
    }
    String r = sb.reverse().toString().replaceFirst("^0+(?!$)", "");
    return r;
}

Check yourself

Quiz

Summary

Summary

• String literals share objects in the string pool; new String always creates a new object.
• Strings are immutable — methods return new strings; compare text with equals, order with compareTo.
• Key methods: length, charAt, indexOf, substring, split, replace, trim, toUpperCase.
• StringBuilder is mutable and efficient for building strings in loops.
• Numbers of any size can be stored as digit strings and added or multiplied column by column; BigInteger/BigDecimal do it for you.