Strings

Overview#

Strings in Java are represented by java.lang.String class objects, which encapsulate a sequence of Unicode characters. Under the hood, these characters are stored in a plain Java byte[] array (since Java 9, as part of the Compact Strings optimization), but the String class manages it and provides a rich access API.

Strings in Java are immutable — once a string is created, it cannot be changed. There are many operations available that appear to modify a string, but they actually return a new String object every time. For example, .concat() returns a brand-new String rather than modifying the original.

Creation#

String Literals#

Java automatically converts string literals into String objects.

// String literal
String singleLine = "Software Design";

String multiLine1 =
  "Define a multi-line string\n" +
  "using concatenation";

// Concatenation
String title = "Software " + "Design"; // "Software Design"

For larger text blocks, Java 13 introduced text blocks. There is a special rule about leading spaces: the leftmost non-space character becomes the left “edge”. All spaces to the left of that edge are ignored, while spaces to the right are retained.

public static void main(String[] args) {
  String multiLine2 = """
    CAP theorem stands for:
      - Consistency
      - Availability
      - Partition tolerance
  """;
//  ^ the edge; all spaces to the left are ignored
}

/*
CAP theorem stands for:
  - Consistency
  - Availability
  - Partition tolerance
*/

Creating From Other Types#

It’s also possible to construct strings from other types:

char[] letters = new char[] { 'D', 'e', 's', 'i', 'g', 'n' };
String lettersStr = new String(letters); // "Design"

// Creating strings from primitive types
String intStr     = String.valueOf(111);   // "111"
String floatStr   = String.valueOf(3.14f); // "3.14"
String booleanStr = String.valueOf(false); // "false"

Calling String.valueOf with an object invokes the object’s toString() method:

Date date = new Date();

// Equivalent for non-null values:
String d1 = String.valueOf(date); // "Wed Apr 22 23:16:59 CEST 2026"
String d2 = date.toString();      // "Wed Apr 22 23:16:59 CEST 2026"

// But differs when the value is null:
Date empty = null;
String e1 = String.valueOf(empty); // "null"  (safe)
String e2 = empty.toString();      // NullPointerException!

Format String#

The static String.format(String format, Object... args) method allows you to build a new string from a template (called a format string), filled with any number of arguments. Arguments are inserted via format specifiers, which follow this syntax:

%[flags][width][.precision]conversion

• conversion — the argument type:
  • b (Boolean), c (Character), d (Integer), e (Scientific notation), f (Float), s (String)
• flags — format-specific options:
  • - (left-align), + (include sign), 0 (pad with zeros), , (grouping separators), ( (parentheses for negatives), (space for positive sign)
• width — total minimum number of characters
• precision — number of digits to the right of the decimal point

// 3.141593 3.141593e+00 3.141592653589793 true
String.format("%f %e %s %b", Math.PI, Math.PI, Math.PI, Math.PI);

// '3.142' '+3.1416' ' 3.1416'
String.format("'%.3f' '%+1.4f' '% 1.4f'", Math.PI, Math.PI, Math.PI);

// Right: '  3.14', Left: '3.14  ', Padded: '003.14'
String.format("Right: '%6.2f', Left: '%-6.2f', Padded: '%06.2f'", Math.PI, Math.PI, Math.PI);

String.format("%.4f %(.4f", -Math.PI, -Math.PI); // -3.1416 (3.1416)
String.format("%,d", 1999000000);                // 1,999,000,000

String.format("%b or %b", true, false); // true or false
// null is false, but Date is true
String.format("null is %b, but Date is %b", null, new Date());

// Fri Apr 24 21:10:01 CEST 2026 is a GOOD date
String.format("%s is a %s date", new Date(), "GOOD");
String.format("Today is %.3s", new Date()); // Today is Fri

String message = STR."\{user} has chosen option '\{option}'";

String Pool#

The String Pool (also called the intern pool) is a special memory region inside the heap where the JVM stores string literals. It’s a cache that avoids creating duplicate string objects with the same content.

When you write String a = "Hello" and later String b = "Hello", the JVM doesn’t allocate two separate objects — it reuses the same one from the pool, so a == b evaluates to true. This saves memory by ensuring that identical literals share a single instance.

String a = "Hello";
String b = "Hello";
System.out.println(a == b);      // true  — same object from the pool
System.out.println(a.equals(b)); // true  — same content

However, strings created with new String(...) bypass the pool entirely and always produce a fresh heap object:

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

This is exactly why you should always compare strings with .equals() rather than ==. The == operator checks reference equality (same object), not value equality (same content).

You can manually push a string into the pool by calling .intern() on it. This returns the existing pooled instance if one exists, or adds the string to the pool and returns it:

String d = new String("Hello").intern();
System.out.println(a == d); // true — now points to the pooled instance

String Methods#

StringBuilder#

The StringBuilder class lets you work with strings as mutable objects. Internally it maintains a variable-length char[] array. That array can be modified in-place through various operations, which gives a significant performance benefit over repeated string concatenation — each + on a regular String creates a new object, while StringBuilder keeps modifying the same buffer.

Apart from length, StringBuilder also exposes a capacity property — the size of the pre-allocated buffer. It expands automatically when needed, similar to how ArrayList works. By default, a new StringBuilder starts with 16 extra characters of capacity (though you can specify a custom value).

var sb = new StringBuilder();    // length =  0, capacity = 16
sb.append("software design");    // length = 15, capacity = 16
sb.append(":)");                 // length = 17, capacity = 34 (auto-expanded)

var cap = new StringBuilder(99); // length =  0, capacity = 99

StringBuilder Methods#

The key difference from String methods is that most StringBuilder methods return this (the same object), which enables method chaining like sb.append("a").append("b").reverse().