Strings in Java

Creating Strings in Java

Java provides multiple ways to create String objects.

String Literals

// String literal - stored in string pool
String name = "Hello World";

// String pool is a special area in heap memory
// JVM tries to reuse strings with same content
String a = "Hello";
String b = "Hello";
System.out.println(a == b);  // true (same object in pool)

Using new Keyword

// Creates new String object in heap (not in pool)
String name = new String("Hello World");

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);  // false (different objects)
System.out.println(a.equals(b));  // true (same content)

From char Array

char[] chars = {'H', 'e', 'l', 'l', 'o'};
String str = new String(chars);  // "Hello"

// With offset and length
char[] chars2 = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};
String str2 = new String(chars2, 0, 5);  // "Hello"

From byte Array

byte[] bytes = {72, 101, 108, 108, 111};
String str = new String(bytes);  // "Hello"

// With charset
String str2 = new String(bytes, StandardCharsets.UTF_8);

String Concatenation

// + operator creates new String object
String first = "Hello";
String second = " World";
String result = first + second;  // "Hello World"

// Compile-time constant folding
String a = "Hello" + " World";  // "Hello World" (compiled as single string)
String b = "Hello";
String c = b + " World";  // Runtime concatenation

String Length

String str = "Hello";
int len = str.length();  // 5 (method, not field like arrays)

// Empty string
String empty = "";
int emptyLen = empty.length();  // 0

Key Differences

Literal	new String()
Stored in string pool	Stored in heap
Reuses existing objects	Creates new object
a == b may be true	a == b is always false
More memory efficient	Less efficient

String Immutability

Strings in Java are immutable - once created, their values cannot be changed.

Why Immutable?

// Strings are immutable for security and performance
String str = "Hello";

// This does NOT modify the original string
String upper = str.toUpperCase();  // "HELLO"

// str is still "Hello"
// A new string is created for the result

Immutability Benefits

// 1. Security - Strings can't be modified
String password = "secret";
// No other code can change this value

// 2. Thread Safety - Safe to share between threads
String shared = "constant";
// Multiple threads can read without synchronization

// 3. Hash Code Caching - Can be cached since content doesn't change
String str = "Hello";
int hash = str.hashCode();  // Computed once, cached

// 4. String Pool - Can safely reuse strings
String a = "Hello";
String b = "Hello";
// Both point to same object in pool

String Concatenation Performance

// BAD: Creates many intermediate String objects
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i;  // Creates new String each time!
}
// O(n^2) time complexity

// GOOD: Use StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();
// O(n) time complexity

String Methods Return New Strings

String str = "Hello World";

// Each method returns a NEW string
String upper = str.toUpperCase();    // "HELLO WORLD"
String lower = str.toLowerCase();    // "hello world"
String trimmed = str.trim();         // "Hello World"
String replaced = str.replace('o', '0');  // "Hell0 W0rld"

// Original string unchanged
System.out.println(str);  // "Hello World"

Memory Implications

// Each string operation creates new object
String a = "Hello";
String b = a.toUpperCase();  // New object created
String c = b.concat(" World");  // Another new object

// This can waste memory in loops
// Use StringBuilder for multiple concatenations

String Pool

String pool is a special memory area in the JVM heap where String literals are stored.

How It Works

// String literals are automatically interned
String a = "Hello";
String b = "Hello";

// Both point to same object in pool
System.out.println(a == b);  // true
System.out.println(a.equals(b));  // true

// new String() creates new object outside pool
String c = new String("Hello");
System.out.println(a == c);  // false
System.out.println(a.equals(c));  // true

intern() Method

// Manually add string to pool
String a = new String("Hello");  // Not in pool
String b = a.intern();  // Added to pool
String c = "Hello";     // Already in pool

System.out.println(b == c);  // true

// Useful for saving memory with many duplicate strings

Pool Size and Performance

// Pool is limited in size
// Too many strings can cause performance issues

// Modern JVMs use different pool strategies:
// - Java 6: PermGen (fixed size, can cause OutOfMemoryError)
// - Java 7+: Heap (garbage collected, more flexible)

Common Patterns

// Pattern 1: Check equality correctly
String user = getUserInput();
if (user.equals("quit")) {  // Always use equals()
    exit();
}

// Pattern 2: Switch on strings (Java 7+)
switch (command) {
    case "start":
        start();
        break;
    case "stop":
        stop();
        break;
}

// Pattern 3: String comparison
String a = "Hello";
String b = new String("Hello");

// WRONG: Use equals()
if (a == b) { }  // false!

// RIGHT: Use equals()
if (a.equals(b)) { }  // true!

Memory Optimization

// Bad: Creates many objects
String[] words = new String[1000];
for (int i = 0; i < 1000; i++) {
    words[i] = new String("hello");  // 1000 objects!
}

// Good: Reuses pool objects
String[] words = new String[1000];
for (int i = 0; i < 1000; i++) {
    words[i] = "hello".intern();  // Reuses pool object
}

Comparison Summary

Expression	What it checks
a == b	Reference equality (same object?)
a.equals(b)	Content equality (same value?)
a.intern() == b.intern()	Both in pool?

Best Practice

Always use equals() to compare String content, never ==.

Common String Operations

Length and Access

String str = "Hello World";

int len = str.length();           // 11
char first = str.charAt(0);       // 'H'
char last = str.charAt(10);       // 'd'

// Iterate through characters
for (int i = 0; i < str.length(); i++) {
    System.out.println(str.charAt(i));
}

// Enhanced for loop (Java 5+)
for (char c : str.toCharArray()) {
    System.out.println(c);
}

Substrings

String str = "Hello World";

String sub1 = str.substring(6);      // "World"
String sub2 = str.substring(0, 5);   // "Hello"

// substring(beginIndex, endIndex)
// endIndex is exclusive!

Search

String str = "Hello World";

int index = str.indexOf('l');           // 2 (first occurrence)
int index2 = str.lastIndexOf('l');      // 9 (last occurrence)
int index3 = str.indexOf("World");     // 6
int index4 = str.indexOf("xyz");       // -1 (not found)

boolean contains = str.contains("World");  // true
boolean starts = str.startsWith("Hello");   // true
boolean ends = str.endsWith("World");      // true

Transformation

String str = "Hello World";

String upper = str.toUpperCase();    // "HELLO WORLD"
String lower = str.toLowerCase();    // "hello world"
String trimmed = str.trim();         // "Hello World"

// Replace
String replaced = str.replace('l', 'L');      // "HeLLo WorLd"
String replaced2 = str.replace("World", "Java");  // "Hello Java"

// ReplaceAll (regex)
String cleaned = str.replaceAll("[^a-zA-Z]", "");  // "HelloWorld"

Split and Join

// Split
String csv = "apple,banana,cherry";
String[] fruits = csv.split(",");
// ["apple", "banana", "cherry"]

// With limit
String data = "a:b:c:d";
String[] parts = data.split(":", 2);  // ["a", "b:c:d"]

// Join
String joined = String.join(" - ", fruits);  // "apple - banana - cherry"

// Join with delimiter
String result = String.join(",", "a", "b", "c");  // "a,b,c"

Conversion

// To char array
char[] chars = "Hello".toCharArray();

// From char array
String str = new String(chars);

// To int
int num = Integer.parseInt("123");
double dbl = Double.parseDouble("3.14");

// From int
String fromInt = String.valueOf(123);     // "123"
String fromInt2 = Integer.toString(123);  // "123"
String fromInt3 = 123 + "";               // "123"

// Format
String formatted = String.format("Name: %s, Age: %d", "Alice", 25);

Formatting

// String.format()
String name = "Alice";
int age = 25;
String msg = String.format("%s is %d years old", name, age);

// System.out.printf()
System.out.printf("Name: %s, Age: %d%n", name, age);

// Format specifiers
// %s - string
// %d - integer
// %f - float
// %c - character
// %b - boolean