Arrays, Strings and String Handling in Java

This lecture covers arrays, Strings and String handling in Java, including declaration and access, the Arrays utility, jagged arrays, String pool and heap-stack memory, StringBuffer capacity, StringTokenizer and StringBuilder.

18.1 Arrays — Fundamentals, Declaration, Initialization and Access

This section follows the lecture sequence: Arrays Fundamentals (concept overview), example length illustration with arr holding 20 31 54 82 23, actual physical memory blocks, enhanced for loop that iterates, loop that retrieves elements, type Employee object array, members empNo fields, creates array retrieval via loop.

The explanation below adds the next layer of intuition.

18.1.1 Declaration and Initialization — Linking a Name to Physical Memory

Declaration is the promise; initialization is the construction.

Three equivalent declaration forms for an integer array (all create a reference variable that can point to an int[], none allocate storage yet):

int[] arr;   // preferred — type is "array of int", name is arr
int arr[];   // C-style, same meaning, carried for familiarity
int []arr;   // whitespace variant, same meaning

For object types the pattern is identical: Employee[] staff; or String[] names;.

Initialization links the name to a physical heap block and freezes the length:

arr = new int[5];          // five consecutive int slots, all 0 initially
// combined form seen in professional code:
int[] arr = new int[5];
// initialized with values in one line (size inferred):
int[] arr2 = {20, 31, 54, 82, 23};  // length 5, contents as listed
// alternative initializer syntax:
int[] arr3 = new int[]{20, 31, 54, 82, 23};

Memory picture after arr = new int[5]; — arr itself is a 4- or 8-byte reference living on the stack (or as a field in an object), pointing to a heap object with a header, a length field holding 5, and five int slots back-to-back. Visualize:

stack:  arr ──► heap: [ header | length=5 | 0 | 0 | 0 | 0 | 0 ]
                indexes:              0   1   2   3   4

Without new, arr remains null and any arr[i] dereference throws NullPointerException. The "five consecutive blocks" phrase in the lecture maps to this heap object; "consecutive" matters because it gives $O(1)$ random access via $address=base+i\times elementSize$, a guarantee Java inherits from the underlying array implementation even though you never compute the address yourself.

Dynamic allocation via new is why every Java array is created at runtime and why the size expression new int[n] can itself be a variable n computed earlier — int n = sc.nextInt(); int[] a = new int[n]; is perfectly legal.

18.1.2 Accessing Array Elements — Direct Indexing and Loops

For a single variable int b = 7; you read and write the name b. For an array you read and write arr[i] — the name plus an index expression in brackets.

Direct assignment is exact but does not scale:

arr[0] = 10;
arr[1] = 20;
System.out.println(arr[2]); // 54 in the running example

For length 500, writing 500 such lines duplicates logic, invites copy errors, and defeats automation. Loops factor the index:

Simple for loop — explicit index, full control for reading and writing:

for (int i = 0; i < arr.length; i++) {
    System.out.println("Element at index " + i + " : " + arr[i]);
}

Walk-through with arr.length = 5: i starts at 0, test 0 < 5 true → print arr[0]; i++ → 1, test true → print arr[1]; ... i=4 print arr[4]; i++ → 5, test 5 < 5 false → stop. This is the canonical idiom because i < arr.length adapts automatically if the size changes — never hard-code i < 5 when arr.length is available.

For-each (enhanced for) loop — values only, no index writes:

for (int x : arr) {
    System.out.println(x);
}

x takes each element value in order; you cannot assign x = 10 to change arr[i]. Use it when you only need to display or sum.

Labelled for loop — a label before a loop (outer: for(...)) lets an inner loop break outer; or continue outer; to jump out of nested iteration. The lecture names it for completeness; with one-dimensional arrays you rarely need it, but it matters immediately when traversing jagged arrays with nested loops and an early-exit condition.

Population from external sources replaces the right-hand side of arr[i] = ...:

Scanner sc = new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {
    arr[i] = sc.nextInt();       // from user
    // or: arr[i] = Integer.parseInt(args[i]);  // from command line
    // or: arr[i] = fileScanner.nextInt();      // from file
}

18.1.3 Worked Examples

class ABC {
    public static void main(String[] args) {
        int[] arr = new int[5];   // length 5, all 0
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        arr[3] = 40;
        arr[4] = 50;
        // state: [10, 20, 30, 40, 50]
        for (int i = 0; i < arr.length; i++) {
            System.out.println("Element at index " + i + " : " + arr[i]);
        }
    }
}

Scanner sc = new Scanner(System.in);
for (int i = 0; i < arr.length; i++) arr[i] = sc.nextInt();

int[] arr = {10, 20, 30, 40, 50}; // declaration + initializer in one
for (int v : arr) System.out.println(v);

A second concrete trace makes the pattern concrete.

class Employee {
    int empNo;
    String name;
    Employee(int empNo, String name) {
        this.empNo = empNo;
        this.name = name;
    }
}

Employee[] arr = new Employee[5]; // array of 5 Employee references, all null initially
arr[0] = new Employee(1, "Ankit");
arr[1] = new Employee(2, "Bebbo");
arr[2] = new Employee(3, "Sunny");
arr[3] = new Employee(4, "Riya");
arr[4] = new Employee(5, "Karan");

arr ──► [ null | null | null | null | null ]
         0      1      2      3      4

for (int i = 0; i < arr.length; i++) {
    System.out.println("Element at index " + i + " : " + arr[i].empNo + " " + arr[i].name);
}

Visual intuition for both examples: draw a column of boxes. Left column — indexes 0 to 4 in a vertical stack. Right column — current contents. For int[] the right column holds numbers; for Employee[] the right column holds arrows pointing to separate Employee boxes each containing two fields (empNo, name). Axes are simple: horizontal position is index increasing downward, content is value/reference. The takeaway is that int[] is a tray of values, Employee[] is a tray of signposts.

The visual picture clarifies why the preceding assumption matters before examining common errors.

18.1.4 Student Questions and Answers

The explanation below adds the next layer of intuition.

The explanation below adds the next layer of intuition.

Real-world and domain note: homogeneous arrays back every bulk numeric pipeline — daily sensor time-series, transaction ledgers, image rows, student score sheets, and database fetch buffers. Object arrays such as Employee[] model real business entities where each slot is a record with multiple fields; they underpin early domain models before generics and ArrayList<Employee> replace them for resizable collections. The same arr[i] mechanism reappears in systems programming for buffer management and windowing over large data arrays where a single allocation and indexed walk is faster than per-element objects.

18.1.5 Industry Applications

In production Java, primitive arrays drive high-throughput numeric code because they are contiguous and avoid per-element boxing. Examples include ingesting sensor streams from IoT gateways (one double[] per window), closing-price arrays for moving-average calculations in trading, and pixel row buffers in image processing. Object arrays like Employee[] or Order[] model entity sets in business applications — payroll batches, course-registration lists, hospital patient rosters — where each slot carries a rich object rather than a scalar. When collection size must vary at runtime, teams promote T[] to ArrayList<T>, but the underlying storage remains an array (ArrayList wraps an Object[]).

18.1.6 Exam Notes

18.2 The Arrays Utility Class — Printing, Sorting, Searching, Copying and Filling

Follow the Arrays utility flow in order: Arrays Utility overview, toString display via Arrays, meters supplied complete sort of A to 1 2 3 4 5 7, step element middle computation, Compute middle halving, middle truncated binary search, Since discard logic for comparison, remain does deepEquals nested check.

Java provides a helper class java.util.Arrays with static methods that operate on arrays. The class name Arrays (with an s) is itself a class, so an array such as int[] arr is an object of that underlying array type. The eight core method families are toString, sort, binarySearch, equals, deepEquals, copyOf, copyOfRange, and fill. Each family is overloaded for byte, char, double, float, int, long, short, and Object — the same code shape works for any element type.

The explanation below adds the next layer of intuition.

18.2.1 Printing Arrays — Why arr Alone Prints an Object ID

Consider int[] arr = {1, 2, 3}. If you write:

System.out.println(arr);

the output is not 1 2 3. It is something like [I@15db9742 — the object ID or reference number of the array object. That is because printing arr without an index talks about the array at the broad level, not about its individual elements. arr[0] means the first element; plain arr means the whole array object at the broad-to-deep distinction, and printing the broad reference shows its identity. [I is the JVM's internal name for int[]; the hex after @ is the hash of the object's heap address.

The fix is the static method Arrays.toString:

System.out.println(Arrays.toString(arr)); // [1, 2, 3]

Arrays.toString walks arr[i] for i = 0 to arr.length - 1, converts each element with String.valueOf, joins with ", " and wraps with [ ]. It is the standard way to print all elements in one go, complementing element-by-element access through a for loop with arr[i]. For multi-dimensional arrays use Arrays.deepToString.

18.2.2 Sorting — Full Sort and Partial (Range) Sort

An array A with elements [2, 3, 5, 1, 4, 7] has length 6 and indexes 0 through 5.

A = [2, 3, 5, 1, 4, 7]
     0  1  2  3  4  5   (indexes)

A = [1, 2, 3, 5, 4, 7]

Arrays.sort(A);
System.out.println(Arrays.toString(A)); // [1, 2, 3, 4, 5, 7]

18.2.3 Searching — Arrays.binarySearch

After sorting, the array [1, 2, 3, 4, 5, 7] is searched:

int idx = Arrays.binarySearch(A, 5);
System.out.println("Binary search for 5 is " + idx); // 4

The output 4 means element 5 is at index 4.

18.2.4 Copying — copyOf and copyOfRange

System.out.println(Arrays.toString(Arrays.copyOf(A, A.length))); // [1, 2, 3, 4, 5, 7]
System.out.println(Arrays.toString(Arrays.copyOf(A, 3)));        // [1, 2, 3] — truncated
System.out.println(Arrays.toString(Arrays.copyOf(A, 8)));        // [1,2,3,4,5,7,0,0] — padded

System.out.println(Arrays.toString(Arrays.copyOfRange(A, 1, 4))); // [2, 3, 4]

18.2.5 Filling — Arrays.fill

before: [1, 2, 3, 4, 5, 7]
index:   0  1  2  3  4  5
after:  [1, 2, 3, 4, 1, 1]
                    ^  ^  filled with 1

before: [1, 2, 3, 4, 1, 1]
after:  [1, 1, 1, 1, 1, 1]

18.2.6 Equality — == Versus Arrays.equals Versus Arrays.deepEquals

int[] ar1 = {1, 2, 3};
int[] ar2 = {1, 2, 3};
if (ar1 == ar2)
    System.out.println("Same");
else
    System.out.println("Not same");
System.out.println(Arrays.equals(ar1, ar2));

ar1 ──► [1,2,3] at id1
ar2 ──► [1,2,3] at id2   (different object, same contents)

int[] inAr1 = {1, 2, 3};
int[] inAr2 = {1, 2, 3};
Object[] ar1 = {inAr1, inAr2}; // two references inside
Object[] ar2 = {inAr2, inAr1}; // same two, swapped order? actually same values, same order in session's second example as {inAr2}, but deep matters
if (Arrays.equals(ar1, ar2))
    System.out.println("Same");
else
    System.out.println("Not same");  // prints Not same

if (Arrays.deepEquals(ar1, ar2))
    System.out.println("Same");      // prints Same when values match at deepest level
else
    System.out.println("Not same");

18.2.7 Worked Examples Summary

A compact map of the session's demonstrations:

• Printing: System.out.println(arr) → [I@... (ID); Arrays.toString(arr) → [1, 2, 3].
• Partial sort: Arrays.sort(A, 0, 4) on [2,3,5,1,4,7] sorts [2,3,5,1] to [1,2,3,5] leaving [4,7] untouched → [1,2,3,5,4,7].
• Full sort: Arrays.sort(A) produces [1,2,3,4,5,7].
• Binary search for 5 in the sorted [1,2,3,4,5,7] returns index 4 via two halvings.
• copyOf(A, A.length) copies whole array; copyOfRange(A,1,4) yields [2,3,4] (exclusive to).
• fill(A,4,A.length,1) fills tail with 1 → [1,2,3,4,1,1]; fill(A,1) fills all with 1.
• ar1 == ar2 compares IDs and yields false; Arrays.equals compares flat values; Arrays.deepEquals compares nested values.

The visual picture clarifies why the preceding assumption matters before examining common errors.

Visual intuition: picture each utility as a strip operation. Draw A as six adjacent cells. Highlight the sort window [0,4) in yellow, show arrows reordering values inside only; show binarySearch as a shrinking highlight around mid; show copyOfRange(1,4) as a scissors cut extracting cells 1-3; show fill(4,n,1) as a paint roller over the tail. Axes are index (left→right) vs value (cell content). The takeaway is windowed operations are always half-open [from, to).

18.2.8 Student Questions and Answers

The explanation below adds the next layer of intuition.

The explanation below adds the next layer of intuition.

Real-world and domain note: in production data pipelines, Arrays.sort and binarySearch replace hand-rolled sorts over million-element int[] windows from logs or time-series; copyOfRange carves sliding windows without manual loops; fill pre-conditions buffers with sentinel values (e.g. Arrays.fill(buf, -1) before a sparse fill). The equals/deepEquals hierarchy is exercised in testing frameworks (assertArrayEquals delegates to these helpers) and in serialization checks where nested record arrays must be compared deeply.

18.2.9 Industry Applications

At large scale, array utilities replace hand-written loops with one-line, native-accelerated calls. Data engineers sort multi-million-entry int[] or double[] from sensor feeds with Arrays.sort before selecting percentiles via binarySearch; ETL jobs use copyOfRange to carve a date-window out of a year-long array for reprocessing; server buffers are reset with Arrays.fill(cache, 0) or Arrays.fill(tmp, 4, n, -1) to mark uncomputed tails. Equality helpers underpin correctness checks: unit tests assert Arrays.equals(expected, actual) for flat responses and Arrays.deepEquals(expected, actual) for nested result sets (e.g. Object[][] rows from JDBC).

18.2.10 Exam Notes

18.3 Jagged Arrays — Two-Dimensional Arrays with Variable Column Counts

Up to this point the discussion assumed regular (rectangular) two-dimensional arrays. A jagged array — also called a ragged array — is a two-dimensional array whose rows can have different numbers of columns. It is defined as an array whose elements are themselves arrays, possibly of different sizes.

The explanation below adds the next layer of intuition.

arr ──► [ arr[0] ] ──► [  *              ] length 1
        [ arr[1] ] ──► [  *  *           ] length 2
        [ arr[2] ] ──► [  *  *  *        ] length 3
        [ arr[3] ] ──► [  *  *  *  *     ] length 4

18.3.1 Declaration — Fixing Only the Row Count

int[][] arr = new int[2][];

Here 2 fixes the number of rows. The second bracket is left blank [] because column sizes are not yet chosen — the compiler creates an array of two int[] references, both null:

arr[0] = null
arr[1] = null

Then each row is sized individually:

arr[0] = new int[3]; // row 0 gets 3 columns — arr[0] now [0,0,0]
arr[1] = new int[2]; // row 1 gets 2 columns — arr[1] now [0,0]

Now arr[0] is an array of length 3 and arr[1] is an array of length 2. The structure looks like a staircase rather than a rectangle. Equivalent alternative syntax accepted by the compiler:

int arr[][] = new int[2][];
int[] arr2[] = new int[2][];

All mean the same: outer array of int[]. Reassigning arr[0] = new int[10] later is legal — the staircase can be reshaped per row at runtime. This per-row control is exactly why Java documents multidimensional arrays as "arrays of arrays" (T6 Chapter 3) and recommends leaving inner dimensions blank when sizes will vary.

18.3.2 Populating and Retrieving — Nested Loops with Per-Row Length

A worked example uses a counter count initialized to 0 and nested loops. This is the canonical idiom — outer walks rows, inner walks the specific row's length:

int count = 0;
for (int i = 0; i < arr.length; i++) {           // arr.length is number of rows (2)
    for (int j = 0; j < arr[i].length; j++) {    // arr[i].length is columns in row i
        arr[i][j] = count++;
    }
}

row 0: [0, 1, 2]   (3 columns)
row 1: [3, 4]      (2 columns)

0
1 2
3 4 5
6 7 8 9

Retrieval mirrors population — the inner bound must be arr[i].length, not a constant:

for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println(); // newline per row
}

Output for the two-row example:

0 1 2 
3 4 

If you mistakenly write j < arr.length or j < 3, the first row may print correctly but the second will either miss elements or throw ArrayIndexOutOfBoundsException. The key pattern arr[i].length (length of row i) replaces a fixed column count — this phrase is exactly what the professor asked students to memorize.

A variant using Arrays.toString per row for debugging:

for (int i = 0; i < arr.length; i++) {
    System.out.println(Arrays.toString(arr[i]));
}
// [0, 1, 2]
// [3, 4]

The visual picture clarifies why the preceding assumption matters before examining common errors.

Visual intuition: sketch a left-to-right index axis per row, but shorten each row's bar to its own arr[i].length. Row 0's bar extends to 3, row 1's to 2. The "staircase" profile — steps of decreasing or increasing length — is the one-sentence takeaway. For the $4$-row $1,2,3,4$ case, the area of cells is $10$ versus $16$ for a $4\times 4$ rectangle — jagged saves $37.5\%$ of allocations when rows are actually short.

18.3.3 Student Questions and Answers

Real-world and domain note: jagged arrays model inherently ragged data — adjacency lists for sparse graphs (each node's neighbor list has degree d_i), inverted indexes where each term posts to a different number of documents, student-course enrollments, calendar days with variable appointments, and compressed sparse rows for matrices where most entries are zero. Backend engineers often promote jagged patterns to List<List<T>> for dynamic growth, but the in-memory layout remains "array of arrays."

18.3.4 Industry Applications

Jagged arrays back systems where rows naturally differ: graph engines store adjacency as int[][] adj where adj[v].length is the out-degree; e-learning platforms store per-student course IDs (courses[s].length varies by enrollment); workforce schedulers store per-day shift assignments with variable staffing. Choosing jagged over rectangular saves heap and iteration time when the average row length is much smaller than the maximum — precisely the sparse, irregular datasets where graph traversal, path-finding (BFS over adjacency lists), and sparse-matrix kernels benefit most. When serialization to JSON or DB persistence is needed, each jagged row maps cleanly to a variable-length JSON array.

18.3.5 Exam Notes

18.4 Strings in Java — Immutability, the String Constant Pool, and Heap-Stack Memory

Lecture order for strings: Strings Java overview, normal sharing of literals in SCP, assignment java concatenation, Student Questions and Answers discussion.

Java strings are objects, not just character arrays. A String — a sequence of characters — in Java is immutable, meaning once a string object such as "Java" is created, its character content cannot be changed in place. Any operation that appears to modify it actually creates a new string.

The explanation below adds the next layer of intuition.

18.4.1 The String Constant Pool (SCP)

The SCP exists to optimize space and improve performance. It is a table of interned literals inside the heap (in modern JVMs, inside the heap's string table backed by native memory, logically part of the heap). On class loading, every literal "..." encountered is interned: the JVM checks the SCP first, creates the character array once if absent, and shares that single instance.

String s1 = "Java";              // literal
String s2 = "Java";              // same literal
String s3 = new String("Java");  // explicit heap object

   stack 1000: s1 ──► heap SCP 2048: "Java"

   stack 1054: s2 ──► heap SCP 2048: "Java"  (shared)

   stack: s3 ──► heap 2150: "Java" (separate copy, not the SCP 2048 copy)

18.4.2 Equality — == Versus equals() for Strings

Because of SCP sharing:

s1 == s2        // true  — both references point to the same SCP entry at 2048
s2 == s3        // false — s3 points to 2150, s2 to 2048 — different objects
s2.equals(s3)   // true  — equals() walks character by character

18.4.3 Immutability in Action and the Stack-Heap Mapping

Consider:

String s1 = "Java";
String s2 = "Java";
s1 = s1 + "J2EE"; // intended "modification"

stack 1000: s1 ──► heap 2048: "Java"
stack 1054: s2 ──► heap 2048: "Java"   (shared, s1 == s2 true)

  heap 3056: "JavaJ2EE"  (new object)
  heap 2048: "Java"      (unchanged, still alive because s2 points to it)

stack 1000: s1 ──► heap 3056: "JavaJ2EE"
stack 1054: s2 ──► heap 2048: "Java"

s1 == s2   // false — different heap objects 3056 vs 2048
s1.equals("JavaJ2EE") // true
s2.equals("Java")     // true

The interchange cut by the lecture break that referenced "s1 == s2 is true for literals but s2.equals(s3) is true even across new" is exactly the two-level equality point above: literal-literal sharing makes == accidentally true, but equals() is the reliable content check that holds across both literal and new construction.

The visual picture clarifies why the preceding assumption matters before examining common errors.

Visual intuition: draw a two-region diagram. Top region (stack) — two named boxes s1@1000, s2@1054 holding arrows. Bottom region (heap/SCP) — boxes 2048:"Java", 3056:"JavaJ2EE". Initially both arrows point at 2048. After s1 = s1 + "J2EE", the s1 arrow swings to 3056, s2 stays. Label the arrow as "reference" and the bottom boxes as "immutable character data." The one-sentence takeaway is that reassignment swings arrows, never rewrites boxes.

18.4.4 Student Questions and Answers

The explanation below adds the next layer of intuition.

The explanation below adds the next layer of intuition.

Real-world and domain note: the SCP optimisation is visible in parsers, compilers, XML/JSON decoders, HTTP header handling and logging frameworks where the same header names and log prefixes appear millions of times — sharing one "Content-Type" or "INFO" object instead of millions of duplicates saves heap and GC time. Application correctness still depends on equals() — notably, web request parameters and database strings are never literals and must not be compared with == even though literal-literal == accidentally works in test code.

18.4.5 Industry Applications

Systems that handle many repeated literals — HTTP servers canonicalizing header names, compilers interning identifiers, parsers holding grammar keywords, and logging frameworks emitting repeated levels (INFO, ERROR) — benefit directly from SCP sharing because one pooled copy replaces millions of duplicated char sequences, cutting heap footprint and GC pressure. Where safe (interned literals only), code can use faster == identity checks, but production Java universally mandates equals() for content comparison because runtime-derived strings (readLine(), substring(), StringBuilder.toString()) are never pooled by default. Security-sensitive code (authentication tokens, passwords) deliberately avoids interning to prevent pooled copies from lingering in memory.

18.4.6 Exam Notes

18.5 StringBuffer — Mutable, Growable Character Sequences

Capacity walkthrough in lecture order: StringBuffer Mutable basics, Programming leading example where default 20 holds Programming 16 then expands, request least ensureCapacity.

StringBuffer represents a growable and writable (mutable) sequence of characters. Unlike String, which is immutable, a StringBuffer can accommodate more characters, insertions, or appends by automatically expanding its capacity. Think of String as a printed book you cannot edit and StringBuffer as the editor's notepad — you can append, insert and delete in place.

The explanation below adds the next layer of intuition.

18.5.1 Constructors

Three concrete forms used in this lecture:

StringBuffer sbEmpty = new StringBuffer();          // capacity 16
StringBuffer sb5     = new StringBuffer(5);         // capacity 5
StringBuffer sbJava  = new StringBuffer("Java");    // lecture reports capacity 20 (=4 + 16)

18.5.2 Capacity and Automatic Expansion — Old Capacity Times Two Plus Two

A StringBuffer has a capacity — how many characters it can hold without reallocating. If the number of characters to store exceeds the current capacity, the capacity increases by the rule:

$$\text{newCapacity}=(\text{oldCapacity}\times 2)+2$$

In implementation this is newCapacity = (oldCapacity << 1) + 2, but the arithmetic is identical. ensureCapacity uses max(requestedMinimum, newCapacity) semantics — it grows just enough to satisfy the request, using the formula above if that still falls short.

StringBuffer sb = new StringBuffer("Java"); // "Java" = 4 chars
System.out.println(sb.capacity()); // 20
System.out.println(sb.length());   // 4

sb.append(" Programming"); // total chars = 4 + 12 = 16
System.out.println(sb);          // "Java Programming"
System.out.println(sb.length()); // 16
System.out.println(sb.capacity()); // 20  (16 <= 20, no expansion)

sb.append(" EA.."); // now length 21 (lecture: 16+5)
System.out.println(sb.length());   // 21
System.out.println(sb.capacity()); // 42

A second concrete trace makes the pattern concrete.

StringBuffer sb1 = new StringBuffer(5); // capacity 5, length 0
sb1.append("program");  // 7 chars: p(1) r(2) o(3) g(4) r(5) a(6) m(7)
System.out.println(sb1.length());   // 7
System.out.println(sb1.capacity()); // 12

sb1.append("ming"); // +4 chars → 7+4 = 11 total; "programming" = 11? actually "program"=7 plus "ming"=4 → "programm"+"ming" = 11
System.out.println(sb1.length());   // 11
System.out.println(sb1.capacity()); // 12 (still fits: 11 <= 12)

A second concrete trace makes the pattern concrete.

StringBuffer sb = new StringBuffer("Java"); // capacity 20, length 4
System.out.println(sb.capacity()); // 20
sb.ensureCapacity(25);             // "make sure we can hold at least 25"
System.out.println(sb.capacity()); // 42
sb.ensureCapacity(30);             // already 42 >= 30
System.out.println(sb.capacity()); // 42 (no shrink, no second growth)

Visual intuition: draw a strip of boxes: capacity is total boxes, shaded length are filled with letters, blank capacity-length are empty tail. Append fills tail boxes left-to-right. When the write head passes the right edge, a second strip twice as long plus two appears, the shaded prefix is copied across, and writing continues. Axes are character position (horizontal) vs occupancy (shaded/blank). The one-sentence takeaway is that growth is generous (doubling plus two) so repeated appends amortize to near-linear cost.

The visual picture clarifies why the preceding assumption matters before examining common errors.

18.5.3 Student Questions and Answers

Real-world and domain note: incremental string assembly is ubiquitous — structured log lines (timestamp + level + message), SQL/JSON/HTML generation, protocol frame building, and test report generation. Using StringBuffer/StringBuilder there avoids the heap churn of looped + on immutable strings; ensureCapacity(expectedSize) is the standard micro-optimization in hot paths where the final size is predictable (e.g. pre-sizing to 256 before appending a known record). In performance-sensitive servers, the old×2+2 trade-off between memory overhead and copy frequency is directly visible in GC logs — fewer, larger reallocations mean fewer old-gen promotions.

18.5.4 Industry Applications

In production code, StringBuffer and StringBuilder serve as the accumulation buffer for any piecewise text assembly: structured logging (sb.append(time).append(' ').append(level).append(msg)), dynamic SQL (sb.append("SELECT ...").append(whereClause)), HTML/XML templating, command-line help generation, and protocol encoding where fields are appended conditionally. Because each append writes into a pre-allocated char[] rather than allocating a fresh String, GC pressure and latency variance drop measurably in high-throughput services. The legacy choice between the two is governed by thread sharing (see 18.7); migration tooling often rewrites StringBuffer to StringBuilder where the buffer is method-local and no sharing crosses thread boundaries.

18.5.5 Exam Notes

18.6 StringTokenizer — Breaking a String into Tokens

Tokenizer sequence: StringTokenizer Breaking, Splitting Java example, self disappears after cut, included default behavior for delimiters.

StringTokenizer — from java.util — breaks a string into tokens, meaning the separated words or substrings that remain after splitting by a delimiter. Given a sentence as a single string, it extracts the individual words. In the parsing pipeline it is the lexer — the first phase that groups raw characters into meaningful pieces before grammar or semantics are applied.

The explanation below adds the next layer of intuition.

18.6.1 Constructors

18.6.2 Core Methods

while (st.hasMoreTokens()) {
    String tok = st.nextToken();
    // process tok
}

while (st.hasMoreElements()) {
    String tok = (String) st.nextElement();
}

18.6.3 Worked Examples

StringTokenizer st = new StringTokenizer("Java Programming with Objects");
int j = st.countTokens(); // snapshot before iteration
int i = 0;
while (st.hasMoreTokens()) {
    System.out.println(st.nextToken());
    i++;
}
System.out.println("i = " + i);                // 4
System.out.println("j = " + j);                // 4
System.out.println(st.countTokens());          // 0 — cursor at end

str:  J a v a _ P r o g r a m m i n g _ w i t h _ O b j e c t s
          ^ cut              ^ cut    ^ cut
tokens: [Java] [Programming] [with] [Objects]   (4 tokens)

Java
Programming
with
Objects
i = 4
j = 4
0

A second concrete trace makes the pattern concrete.

StringTokenizer st = new StringTokenizer("Java Programming with Objects");
while (st.hasMoreTokens()) {
    System.out.println(st.nextToken("a"));
}

J a v a   P r o g r a m m i n g   w i t h   O b j e c t s
  ^   ^           ^     ^
cuts at each 'a'  (Java has two a's, Programming has two)

"Java" → tokens: [J] [v]  ]? actually splits: J | v | ""  → "J", "v" (trailing empty discarded)

A second concrete trace makes the pattern concrete.

StringTokenizer st = new StringTokenizer("ABC, DEF, GHI"); // commas and spaces in source
System.out.println(st.nextToken()); // prints "ABC,"  (default space delimiter)

StringTokenizer st2 = new StringTokenizer("ABC, DEF, GHI", ",");
System.out.println(st2.nextToken()); // "ABC"
System.out.println(st2.nextToken()); // " DEF" (space + DEF — comma consumed, space not)
System.out.println(st2.nextToken()); // " GHI"

A second concrete trace makes the pattern concrete.

StringTokenizer st = new StringTokenizer("ABC+DEF+GHI", "+", true);
System.out.println(st.nextToken()); // ABC
System.out.println(st.nextToken()); // +
System.out.println(st.nextToken()); // DEF
System.out.println(st.nextToken()); // +
System.out.println(st.nextToken()); // GHI

StringTokenizer st2 = new StringTokenizer("ABC+DEF+GHI", "+");
System.out.println(st2.countTokens()); // 3  (ABC, DEF, GHI — '+' discarded)

ABC
+
DEF
+
GHI

Legacy Enumeration mapping (for completeness):

StringTokenizer st = new StringTokenizer("a b");
while (st.hasMoreElements()) {
    String tok = (String) st.nextElement(); // same as nextToken()
}

And nextToken(delim) switching inside a loop can produce surprising counts — once you call nextToken("a"), the tokenizer's active delimiter set becomes "a" for subsequent nextToken() calls as well, unless you switch back — the session's Examples 1→2 transition assumes a fresh tokenizer per example, which is the safe pattern.

Visual intuition: draw the source string as a character ribbon with cut marks according to the delimiter set. Tokens are the colored segments between marks; delimiters are the black tick marks. With delimAsToken=false the ticks are erased after cutting; with true each tick is itself a colored mini-segment between content pieces. Axes are character index (left→right) and segmentation (colors). The one-sentence takeaway is that changing delim moves every tick, and the true flag decides whether ticks are kept.

The visual picture clarifies why the preceding assumption matters before examining common errors.

18.6.4 Student Questions and Answers

The explanation below adds the next layer of intuition.

Real-world and domain note: tokenizers underpin any parsing of delimited text before a proper parser is justified — CSV rows split by commas, TSV by tabs, log lines split by spaces or colons, HTTP header values split by ;, and tiny DSLs that need a lightweight lexer. Where performance matters or delimiters are regular expressions, modern code migrates to String.split("\\s*,\\s*") or a Scanner; the tokenizer's speed advantage is marginal today, but its conceptual simplicity — "one token at a time, discarded delimiters" — remains the pedagogical foundation for scanners, grammars and the stream API.

18.6.5 Industry Applications

Tokenizers are the first pass over delimited input in data ingest: ETL jobs split CSV lines (new StringTokenizer(line, ",") historically, now line.split(",", -1) to keep empties), log processors split by spaces/colons/dashes to extract timestamps and levels, and protocol parsers separate fields before handing them to a grammar parser. In compilers, a tokenizer (lexer) groups characters into keywords and identifiers before parsing — StringTokenizer is the Java standard library's most direct illustration of that lexer step. Modern services often replace it with Pattern.split or Commons CSV for quoted fields with embedded commas, but the token-by-token cursor model persists in streaming parsers and Scanner.

18.6.6 Exam Notes

18.7 StringBuilder — Mutable Like StringBuffer but Without Synchronization

StringBuilder also represents a mutable sequence of characters and is functionally very similar to StringBuffer: both provide an alternative to immutable String by allowing the character sequence to be expanded and mutated in place. The difference is a single design knob: synchronization (thread safety).

The explanation below adds the next layer of intuition.

18.7.1 Constructors

StringBuilder sb1 = new StringBuilder();              // cap 16, len 0
StringBuilder sb2 = new StringBuilder(40);            // cap 40, len 0
StringBuilder sb3 = new StringBuilder("Hello");       // len 5, cap 5+16=21
StringBuilder sb4 = new StringBuilder((CharSequence)"Hi"); // via CharSequence

StringBuilder sb = new StringBuilder(16); // capacity 16, length 0
sb.append("Hello");          // Hello length 5 -> cap still 16
sb.append(" ");              // length 6
sb.append("World");          // length 11 -> cap still 16
System.out.println(sb.toString()); // Hello World
System.out.println(sb.length());   // 11
System.out.println(sb.capacity()); // 16 (no growth yet: 11 <= 16)
sb.append("! This is a builder test."); // pushes length to 35
System.out.println(sb.capacity()); // 34? compute: 16*2+2=34 insufficient for 35 -> 34*2+2=70
System.out.println(sb.toString()); // Hello World! This is a builder test.

18.7.2 Relationship to String Manipulation Methods

Many string manipulation concerns — String methods, tokenizer behaviour, builder/buffer operations — share similar names (append, insert, substring, indexOf) and overlapping behaviours. The session defers exhaustive enumeration to the slides and advises self-practice, because the important conceptual takeaway is already covered: immutability of String versus mutability of StringBuffer and StringBuilder, and the synchronization guarantee that separates the latter two. The remaining methods are used exactly as illustrated in the textbook's catalog: append(...) adds at the tail, insert(pos, ...) splices at pos, delete(start, end) removes, replace, reverse, charAt/setCharAt, getChars, and trimToSize/ensureCapacity manage capacity — all behaving identically between StringBuilder and StringBuffer except the monitor around them.

The visual picture clarifies why the preceding assumption matters before examining common errors.

Visual intuition: picture two identical desk pads side by side, one with a tiny lock icon. Both have a char[] strip (capacity boxes) and a count pointer. A single writer using the locked pad pauses at the lock gate on each stroke; the same writer using the open pad writes straight through. With two writers, the open pad shows interleaved half-letters; the locked pad forces them to take turns and keeps the final text coherent. Axes are operation sequence (time) vs buffer content (character order). The one-sentence takeaway is that the lock guarantees coherence at the price of per-operation waiting.

18.7.3 Student Questions and Answers

Real-world and domain note: in high-throughput servers that assemble responses from many threads, legacy code historically promoted StringBuffer for shared buffers and Vector/Hashtable for shared collections for the same reason — intrinsic synchronization. Modern practice confines a StringBuilder to a single thread or request scope (local variable, ThreadLocal, or StringBuilder per task) and synchronizes externally only where sharing is unavoidable. This shift — from synchronized shared object to thread-confined unsynchronized builder — mirrors the wider move from StringBuffer/Vector to StringBuilder/ArrayList and is visible in performance profiles as reduced lock contention and fewer monitor acquisitions.

18.7.4 Industry Applications

In high-throughput services, string assembly is request-scoped: each HTTP handler creates a local StringBuilder to build the response body, log entry or JSON payload, then discards it. Because the builder never escapes the thread, no lock is needed and StringBuilder outperforms StringBuffer measurably. Shared aggregation — e.g. a single buffer appended to by multiple worker threads polling a queue — historically used StringBuffer for its synchronization guarantee; today engineers typically prefer a StringBuilder per producer plus a final merge, or a BlockingQueue<String> rather than a shared mutable buffer at all. Migration scripts that replace StringBuffer with StringBuilder where escape analysis proves thread confinement show up regularly in performance backlogs, and profiling tools flag StringBuffer constructed inside a method as a lint recommendation to switch.

18.7.5 Exam Notes

Exam Guidance Summary

• Arrays — declaration vs initialization: expect to write the three declaration forms (int[] arr, int arr[]) and the initialization arr = new int[5] that reserves five consecutive blocks. Know that size is required at initialization and fixes the length.
• Arrays — access patterns: know the indexed loop for (int i = 0; i < arr.length; i++) with arr[i], and distinguish it from the for-each and labelled-for alternatives.
• Arrays — object arrays: Employee[] arr = new Employee[5] with arr[0] = new Employee(1, "Ankit") is a distinct concept from int[]. The constructor parameters initialise per-slot fields.
• Arrays class — output prediction: the session used several predict-the-output questions. Practise: System.out.println(arr) prints an object ID versus Arrays.toString(arr) prints values; Arrays.sort(A, 0, 4) partially sorts; Arrays.sort(A) fully sorts; Arrays.binarySearch(A, key) returns the index after sorting; Arrays.copyOf and copyOfRange with exclusive upper bounds; Arrays.fill with and without range indexes.
• Arrays class — equality trap: == compares references (always Not same for two distinct arrays even with identical values); Arrays.equals compares flat contents; Arrays.deepEquals is required for nested arrays such as Object[] {int[], int[]} where equals still compares inner references.
• Jagged arrays: int[][] arr = new int[2][]; arr[0] = new int[3]; arr[1] = new int[2]; and the nested loop using arr.length for rows and arr[i].length for columns per row.
• Strings — SCP and equality: String s1 = "Java"; String s2 = "Java"; share the SCP so s1 == s2 is true; String s3 = new String("Java"); forces a new copy so s2 == s3 is false but s2.equals(s3) is true; s1 = s1 + "J2EE" creates "JavaJ2EE" and repoints s1, leaving s1 == s2 false.
• Strings — heap/stack mapping: SCP strings live in the heap; references s1, s2 live in the stack (e.g., 1000, 1054 versus heap 2048, 3056). Garbage collection reclaims heap; stack is LIFO.
• StringBuffer — capacity rule: memorize $(oldCapacity\times 2)+2$. Examples: default 20 holding 16 stays 20 but 21 becomes 42; 5 with "program" (7 chars) becomes 12; ensureCapacity(25) from 20 becomes 42.
• StringTokenizer — token counting and delimiter inclusion: countTokens() before loop versus 0 after exhaustion; default space versus explicit "a" or ","; true flag in new StringTokenizer(str, delim, true) includes the delimiter as its own token.
• StringBuffer vs StringBuilder vs String: core comparison across immutability, growth, and synchronization — only StringBuffer is synchronized; StringBuilder defaults to capacity 16 when empty.

Key Industry Applications

• Collections of homogeneous data (sensor streams, financial records, academic scores) modelled as primitive arrays, and entity collections (employees, orders, accounts) modelled as object arrays such as Employee[].
• High-volume array processing using Arrays.sort, Arrays.binarySearch, Arrays.copyOf/copyOfRange, and Arrays.fill instead of hand-written loops, enabling concise handling of large data windows and buffer management.
• Graph adjacency lists, variable-length records, and per-row variable datasets modelled with jagged arrays int[][] where arr[i].length differs per row.
• Systems with many repeated literals (parsers, web handlers, logging) benefitting from SCP sharing, while application correctness still relies on equals() over == for content checks.
• Incremental string assembly (logs, queries, HTML) using mutable StringBuffer/StringBuilder to avoid the heap cost of repeated immutable String concatenation, with StringBuffer chosen for multi-threaded shared builders and StringBuilder for single-threaded speed.
• Text parsing and lightweight lexing via StringTokenizer, splitting delimited input (CSV, logs, protocol fields) by spaces, commas, or custom delimiters, optionally preserving the delimiter as a token for reconstruction.