String

Look at any parcel that a courier company delivers. It carries a tracking code, a sender's city, a receiver's city and a short note like "fragile". Every one of those is text. Almost every real Java program works with text in the same way: names, codes, messages, addresses, search boxes. In Java all of that text lives in one class, String.

You have used strings since your first System.out.println. Here you will see what a string really is, why Java never lets you change one, where strings sit in memory, and why == can fool you. By the end you will also know when to reach for StringBuilder instead.

What is a String?

A string is not a primitive like int or char. It is a full class with dozens of methods. Java gives it two special privileges, though. You can create one with a plain literal in double quotes, and you can join strings with the + operator. No other class gets that treatment.

Inside, a modern String keeps its characters in a private byte array. You never touch that array directly. You only call methods, and none of those methods modify it.

Why is String used?

Text is everywhere, and Java needed one safe, shared way to handle it.

• Safety. Because a string cannot change, you can pass it to any method without fear. A file path, a database password or a URL stays exactly as you wrote it.
• Sharing. Identical literals can point to one object, so a program with the same city name in a thousand places stores it once.
• Thread safety for free. Many threads can read the same string at once. Nobody can change it, so nobody can break it.
• Fast hash keys. A string caches its hash code after the first calculation. That makes strings excellent keys in a HashMap.
• Rich tools. Methods for searching, cutting, comparing and changing case save you from writing loops by hand.

Real-Life Example

Think of a printed shipping label stuck on a box. Once the printer produces it, nobody edits the ink. If the address is wrong, the clerk prints a brand new label and sticks that one on instead. The old label is simply thrown away.

A Java string behaves the same. Calling toUpperCase() does not repaint the old text. It prints a new label and hands it to you. The variable is like the box: you can stick a different label on it, but the label itself never changes. And when two parcels go to the same well-known hub, the office reuses one pre-printed hub sticker instead of printing a fresh one every time. That shared sticker drawer is the String pool.

java
String a = "text";              // literal, uses the pool
String b = new String("text");  // forces a new heap object
String c = a + " more";         // joining creates a new string
int n = a.length();             // call any String method
boolean same = a.equals(b);     // compare the characters

How String Works in Memory

Java stores every object on the heap. Inside the heap it keeps a special area called the String pool, where literals live.

text
 Stack       Heap
+------+   +------------------+
| hubA-+-->| String pool      |
| hubB-+-->|  "BLR-HUB"       |
|      |   +------------------+
| hubC-+-->  "BLR-HUB" (new)
+------+   normal heap area

When the compiler sees the literal "BLR-HUB" twice, the JVM places it in the pool only once. Both hubA and hubB get the address of that single object. The line with new String("BLR-HUB") skips the pool and builds a second object in the normal heap area, so hubC points somewhere else. The two objects hold the same letters, but they are different objects.

This explains the classic trap. The == operator compares addresses, not letters. So hubA == hubB is true because they share one object, but hubA == hubC is false. The equals() method compares the characters one by one, so it is true for all three. The intern() method returns the pooled copy of a string, which is why hubC.intern() == hubA is true.

Immutability is what makes this sharing safe. If one variable could edit the pooled "BLR-HUB", every other variable pointing to it would silently change too.

java
public class ParcelCodes {
    public static void main(String[] args) {
        String code = "pkg-4471";
        String upper = code.toUpperCase();
        System.out.println("code  : " + code);
        System.out.println("upper : " + upper);

        String hubA = "BLR-HUB";
        String hubB = "BLR-HUB";
        String hubC = new String("BLR-HUB");

        System.out.println("A == B      : " + (hubA == hubB));
        System.out.println("A == C      : " + (hubA == hubC));
        System.out.println("A equals C  : " + hubA.equals(hubC));
        System.out.println("A == intern : "
                + (hubA == hubC.intern()));
    }
}

text
code  : pkg-4471
upper : PKG-4471
A == B      : true
A == C      : false
A equals C  : true
A == intern : true

java
public class LabelReader {
    public static void main(String[] args) {
        String label = "  pune>mumbai|2.5kg|FRAGILE  ";
        String clean = label.trim();

        String[] parts = clean.split("\\|");
        String route = parts[0];
        int arrow = route.indexOf('>');
        String from = route.substring(0, arrow);
        String to = route.substring(arrow + 1);

        System.out.println("length   : " + clean.length());
        System.out.println("from     : " + from.toUpperCase());
        System.out.println("to       : " + to.toUpperCase());
        System.out.println("weight   : "
                + parts[1].replace("kg", " kg"));
        System.out.println("fragile  : "
                + parts[2].equalsIgnoreCase("fragile"));
        System.out.println("1st char : " + clean.charAt(0));
        System.out.println("has mum  : " + to.contains("mum"));
        System.out.println("ends kg  : " + parts[1].endsWith("kg"));
    }
}

text
length   : 25
from     : PUNE
to       : MUMBAI
weight   : 2.5 kg
fragile  : true
1st char : p
has mum  : true
ends kg  : true

java
public class ManifestBuilder {
    public static void main(String[] args) {
        int parcels = 200;

        String slow = "";
        long copied = 0;
        for (int i = 1; i <= parcels; i++) {
            slow += "P" + i + ";";
            copied += slow.length();
        }

        StringBuilder fast = new StringBuilder();
        for (int i = 1; i <= parcels; i++) {
            fast.append('P').append(i).append(';');
        }
        String result = fast.toString();

        System.out.println("length     : " + result.length());
        System.out.println("same text  : " + slow.equals(result));
        System.out.println("chars copied by +=");
        System.out.println("  " + copied);
        System.out.println("starts with: "
                + result.substring(0, 12));
    }
}

text
length     : 892
same text  : true
chars copied by +=
  83787
starts with: P1;P2;P3;P4;

String vs StringBuilder vs StringBuffer

In everyday code, use String for values and StringBuilder when you build text in a loop. StringBuffer is rarely needed today.

Common Mistakes

• Ignoring the return value. Writing name.trim(); on its own does nothing useful. The trimmed copy is thrown away. Write name = name.trim();.
• Calling methods on null. input.equals("yes") crashes when input is null. Put the literal first: "yes".equals(input).
• Joining with `+` inside big loops. Every pass copies the whole string again. Switch to StringBuilder.
• Forgetting that `split` uses regex. Characters like |, . and * have special meaning and must be escaped with \\.
• Off-by-one in `substring`. The end index is excluded, so substring(0, 3) returns three characters, positions 0 to 2.

Interview Questions

Summary

• A String is an object holding a fixed sequence of characters, and it can never be changed.
• Methods like toUpperCase and trim return new strings, so always store the result.
• Literals live in the String pool and are shared; new String makes a separate heap object.
• Use equals() to compare text; == only compares references.
• += in a loop copies the whole string each time, so use StringBuilder for heavy building.
• StringBuffer is the synchronized cousin of StringBuilder and is seldom needed now.

Related Topics

• String Methods: a closer look at every everyday method used above.
• String Pool: more detail on how the JVM stores and reuses literals.
• StringBuilder: the fast, changeable way to build text.
• StringBuffer: the thread-safe builder and when it still matters.