Java String Basics

Java String Basics

Every Java program deals with text — usernames, messages, product names, addresses, error messages. All of that text is handled using String. It is the most used class in Java, and also one of the most misunderstood.

A String in Java is a sequence of characters. What makes it different from a plain char[] is that String comes with built-in methods for searching, comparing, transforming, and combining text — and it has a special behaviour called immutability that every developer must understand to avoid bugs and write efficient code.

Creating Strings — Two Ways

There are two ways to create a String in Java, and they behave differently in memory.

Output:
name1 == name2 : true
name1 == name3 : false
name3 == name4 : false
name1.equals(name3) : true
name3.equals(name4) : true

Memory picture:

String Pool (special area in heap):
  ┌──────────────┐
  │  "Priya"     │ ◄── name1 and name2 both point here
  └──────────────┘

Heap (regular area):
  ┌──────────────┐   ┌──────────────┐
  │  "Priya"     │   │  "Priya"     │
  └──────────────┘   └──────────────┘
       ▲                    ▲
     name3                name4

Use String literals (String s = "hello") in almost all situations. They are more memory-efficient because Java reuses the same object for identical strings in the pool. Use new String(...) only in rare cases where you explicitly need a separate object.

String Immutability — The Most Important Concept

A String object cannot be changed after it is created. This is called immutability. When you call methods like toUpperCase(), replace(), or trim() on a String, they do not modify the original — they return a brand new String object with the result.

Output:
Original : mumbai
city after toUpperCase() : mumbai
upperCity                : MUMBAI
city after ignored call  : mumbai
city after reassignment  : MUMBAI

messy  : '  Hello, World!  '
cleaned: 'hello world!'

The most common beginner mistake is calling a String method and ignoring the return value — and then wondering why the String did not change. The rule is: always capture the result. String methods never modify the object they are called on.

String Length and Character Access

Output:
String  : Hello, India!
Length  : 13
charAt(0) : H
charAt(7) : I
Last char : !

Characters one by one:
H e l l o ,   I n d i a ! 

empty.isEmpty()  : true
spaces.isEmpty() : false
text.isEmpty()   : false
empty.isBlank()  : true
spaces.isBlank() : true
text.isBlank()   : false

isEmpty() only returns true for a string with zero characters. isBlank() (Java 11+) also returns true for strings that contain only spaces, tabs, or other whitespace — which is more useful when validating user input where someone might enter just spaces.

Common String Methods

These are the methods every Java developer uses daily.

Output:
Original : '  Welcome to DevStackFlow  '
trimmed  : 'Welcome to DevStackFlow'
stripped : 'Welcome to DevStackFlow'

upper: WIRELESS HEADPHONES - PREMIUM EDITION
lower: wireless headphones - premium edition

contains 'Headphones': true
contains 'laptop'    : false
starts 'Wireless': true
ends 'Edition'   : true

original : I love Java. Java is great. Java forever.
replaced : I love Python. Python is great. Python forever.

Full name  : Priya Sharma
First name : Priya
Last name  : Sharma

@ at pos : 5
Username : priya
Domain   : flipkart.com

String Comparison — equals() vs equalsIgnoreCase() vs ==

Output:
== check:
  input == stored : false
  input == ref    : true

equals():
  'Admin'.equals('admin') : false
  'Admin'.equals('Admin') : true

equalsIgnoreCase():
  'Admin'.equalsIgnoreCase('admin') : true

compareTo():
  'Apple' compareTo 'Banana'  : -1
  'Apple' compareTo 'Apple'   : 0
  'Banana' compareTo 'Apple'  : 1

Safe null check: false

Always use equals() or equalsIgnoreCase() for string content comparison — never ==. When comparing against a known string constant, put the constant on the left side: "admin".equals(userInput). This way, even if userInput is null, no NullPointerException is thrown.

String Concatenation

Output:
Full name   : Rohan Mehta
Greeting    : Hello, Rohan!
Summary     : Order ORD-501 | Rs.1299.50 | PLACED

Age: 24
Salary: 45000.0
Active: true

Result: 1020
Result: 30
30 is the sum

Cart items  : Laptop, Mouse, Keyboard, Monitor

The + operator creates a new String object every time. Inside a loop that concatenates many strings, this creates many temporary objects. StringBuilder avoids this — it accumulates all parts in a mutable buffer and converts to a String only once at the end with toString().

String Splitting and Joining

Output:
CSV row : Priya,28,Bengaluru,Engineering
Parts   : [Priya, 28, Bengaluru, Engineering]
Name    : Priya
Age     : 28
City    : Bengaluru
Dept    : Engineering

Limited split: [one, two, three:four:five]

Joined cities: Mumbai, Delhi, Bengaluru, Pune
Skills       : Java | SQL | Spring Boot | Git

First : Ananya
Middle: Krishnan
Last  : Iyer

split() accepts a regular expression as the delimiter — not just a plain character. Splitting on . (dot) does not work as expected because . means "any character" in regex. To split on a literal dot, use split("\\.").

String vs StringBuilder vs StringBuffer — Comparison Table

Basic Example

Output

Full name : Priya Sharma
Length    : 12
Uppercase : PRIYA SHARMA
Is Priya? : true

How it works:

1. ›firstName + " " + lastName joins three strings into one new String, fullName.
2. ›length() counts every character in fullName, including the space.
3. ›toUpperCase() returns a new String with every letter capitalised — fullName itself is unchanged.
4. ›equals() compares the actual text content of two strings, returning true because firstName holds exactly "Priya".

Best Practices

Always use .equals() to compare strings, never ==. The == operator checks whether two variables point to the same object in memory. Two strings with identical content stored as different objects will return false with ==. This is a bug that is easy to write and hard to spot. Use "constant".equals(variable) with the constant on the left to also avoid NullPointerException if the variable is null.

Always capture the result of a String method. String methods return new strings — they do not modify the original. name.trim() does nothing useful unless you write name = name.trim() or String trimmedName = name.trim(). Forgetting this is the single most common String mistake.

Use StringBuilder inside loops. Every + inside a loop creates a new String object. In a loop that runs 1,000 times, this creates 1,000 temporary String objects. StringBuilder.append() modifies the same buffer the entire time. For loops, StringBuilder is always the right choice.

Use String.format() for structured output. "Rs." + amount + " for " + qty + " items" becomes hard to read as the pieces multiply. String.format("Rs.%.2f for %d items", amount, qty) is readable, predictable, and formats numbers cleanly.

Common Mistakes

Mistake 1 — Comparing Strings With ==

Mistake 2 — Ignoring the Return Value of String Methods

Mistake 3 — NullPointerException From Calling Methods on a Null String

Mistake 4 — Building Strings With + Inside a Loop

Interview Questions

Q1. What is a String in Java and why is it immutable?

A String is a sequence of characters represented by the java.lang.String class. It is immutable — once a String object is created, its content cannot be changed. Immutability enables the String pool optimisation, where identical string literals can share the same object in memory without risk of one caller changing the content that another caller is reading. It also makes strings inherently thread-safe and safe to use as HashMap keys, since their hash code never changes.

Q2. What is the String pool in Java?

The String pool is a special region inside the heap where Java stores string literals. When you write String s = "hello", the JVM checks the pool first. If "hello" already exists there, it returns the existing reference — no new object is created. If not, it creates a new entry. This makes string literal reuse memory-efficient. Strings created with new String("hello") bypass the pool and always create a new object. You can add a new String to the pool manually using the intern() method.

Q3. What is the difference between equals() and == for Strings?

== compares references — it returns true only when both variables point to the exact same object in memory. equals() compares content — it returns true when both strings contain the same sequence of characters, regardless of whether they are the same object. Two strings created as literals with the same value may return true for == due to pool reuse, but two strings created with new String(...) containing the same value will return false for ==. Always use equals() for content comparison.

Q4. What is the difference between String, StringBuilder, and StringBuffer?

String is immutable — every operation produces a new object. StringBuilder is mutable and not thread-safe — use it for building strings in single-threaded code, especially inside loops. StringBuffer is mutable and thread-safe — all its methods are synchronised — use it when the same StringBuilder is accessed from multiple threads. For almost all common development scenarios, String for individual values and StringBuilder for building are the right choices. StringBuffer is rarely needed in modern Java where thread-local string building is preferred.

Q5. What does str.split(".") return?

An empty array — not what most beginners expect. split() takes a regular expression, and . in regex means "match any character". So "hello.world".split(".") matches every character and returns an empty array. To split on a literal dot, escape it: str.split("\\."). This is one of the most common beginner traps with split().

Q6. Why should you put the string constant on the left side of equals()?

"constant".equals(variable) is safe even when variable is null — calling .equals() on a non-null constant cannot throw NullPointerException. If you write variable.equals("constant") and variable is null, it throws NullPointerException. Since user input, database values, and API responses can all be null, putting the known non-null constant on the left is a defensive habit that prevents unnecessary null checks.

FAQs

Can you change a String after creating it in Java?

No. A String object's character content is fixed at creation. What you can do is reassign the variable to point to a new String — name = name.toUpperCase() — but the original "priya" object still exists in memory untouched until the garbage collector removes it. If you need to build or modify text frequently, use StringBuilder instead.

Is String a primitive type in Java?

No. String is a class — java.lang.String. It is a reference type, just like ArrayList or any custom class. However, Java gives it special syntax: you can create String literals with double quotes ("hello") without using the new keyword, and you can use + for concatenation. These conveniences make it feel primitive-like, but it is a full object with methods.

What is the difference between length for arrays and length() for Strings?

For arrays, length is a field — no parentheses: arr.length. For Strings, length() is a method — with parentheses: str.length(). Using str.length on a String causes a compile error, and arr.length() on an array also causes a compile error. The distinction exists because arrays are a special Java feature handled differently from objects, while String is a regular class.

What happens when you concatenate a String with null?

When null is concatenated with a String using +, Java converts null to the string "null" — no exception is thrown. So "Hello, " + null produces "Hello, null". However, calling .equals() or any method on a null reference throws NullPointerException.

What is the intern() method in Java?

intern() adds a String to the String pool (or returns the existing pool entry if one already exists with the same content). new String("hello").intern() returns the pooled reference for "hello". After calling intern(), you can compare with == reliably. In practice, intern() is rarely used in application code — it is more relevant in frameworks that process massive volumes of repeated strings.

Summary

String is Java's most used class, and its core behaviours are few and memorable. Strings are immutable — every method returns a new String, never modifying the original. String literals are pooled — identical literals share one object. Always compare with equals(), never ==. Always capture the return value of String methods.

The methods you will use most often are trim(), toLowerCase(), toUpperCase(), contains(), startsWith(), endsWith(), replace(), substring(), indexOf(), split(), equals(), equalsIgnoreCase(), and String.format(). These cover the vast majority of text processing tasks in real-world Java development.

For interviews, be ready to explain immutability and why it exists, describe the String pool, explain the difference between equals() and ==, and explain when to use StringBuilder over +. These appear in nearly every Java interview at every level.

What to Read Next