What are Strings?

A String is simply text in Java. It can be a single word, a sentence, or even an entire book. But in Java, Strings are not just plain text — they are objects. The class responsible for handling Strings is called String.

Example of creating a String:

String greeting = "Hello, world!";

Why are Strings a reference type?

When you create a String in Java, the variable (like greeting) doesn’t store the text directly. Instead, it stores a reference to the memory location where the actual text is kept.

Think of it like saving your friend’s phone number in your contact list. The contact doesn’t store your friend — it just points you to their phone number.

Important Features of Strings

Strings are immutable (unchangeable)
Once a String is created, its content cannot be changed. If you “change” a String, Java creates a new String object, and the old one stays the same.
Example:

String text = "Hello!";
text = "Goodbye!"; // A new String object is created, "Hello!" remains unchanged in memory.

Here, we need to understand how references to string objects are stored and when references are removed or continue to persist in memory. Here is a link to a lecture on this topic: Lesson 20: Java String References: When Are They Removed from Memory?

Strings are objects
Since Strings are objects, they come with useful built-in methods. These methods let you:

• Find the length of a String.
• Convert all characters to uppercase.
• Combine multiple Strings.
• And much more.

How to work with Strings?

To interact with a String, you call its methods. A method is a built-in action you can perform on an object. You call a method by adding a dot (.) after the variable that stores the String.

Examples:

Find the length of a String
The .length() method returns the number of characters in the String.

String text = "Welcome!";
System.out.println(text.length()); // Outputs: 8

Here:

• The .length() method is called on the variable text.
• The method calculates the length of the String and returns 8.
• The result is displayed in the console using System.out.println.

Change the case of a String
The .toUpperCase() method converts all letters in a String to uppercase.

String text = "Welcome!";
System.out.println(text.toUpperCase()); // Outputs: WELCOME!

Combine two Strings
The .concat() method joins two Strings together.

String first = "Hello, ";
String second = "world!";
String result = first.concat(second);
System.out.println(result); // Outputs: Hello, world!

Get a character at a specific position
The .charAt() method returns the character at a given index (starting from 0).

String text = "Java";
System.out.println(text.charAt(1)); // Outputs: a

Common String Methods

Here are some frequently used methods:

Real-Life Example

Imagine a String is a letter stored in an envelope. The variable (like greeting) is the label on the envelope that tells you where to find the letter.

If you want to know how many words are in the letter, you open the envelope and count. Similarly, when you want to make changes, you don’t edit the original letter. Instead, you write a new one and put it in a new envelope.

Why Strings are Important?

Strings are everywhere in programming. Whether it’s user input, error messages, or text displayed to users, you’ll work with Strings constantly. Understanding how Strings work gives you a solid foundation to handle text in your programs.

Now you know that Strings in Java are not just text — they are powerful tools for managing and manipulating data!

Text Blocks in Java

Starting from Java 15, Java introduced text blocks to make working with multi-line strings easier. Before text blocks, writing multi-line strings was a bit messy because you had to add \n for new lines or use multiple concatenations.

With text blocks, you can write multi-line strings more naturally by using three double quotes ("""). Java automatically handles the formatting for you.

Here’s a quick example:

String message = """
        Hello, Java learners!
        Welcome to text blocks.
        This makes multi-line strings so easy.
        """;
System.out.println(message);

The output will look like this:

Hello, Java learners!
Welcome to text blocks.
This makes multi-line strings so easy.

Concatenation with Text Blocks

You can combine (concatenate) text blocks with other strings just like regular strings. Let’s see an example:

String greeting = """
        Hello, world!
        """;

String question = "How are you today?";

String fullMessage = greeting + question;

System.out.println(fullMessage);

The output will be:

Hello, world!
How are you today?

Why Use Text Blocks?

Text blocks are great when you need to:

• Write multi-line messages.
• Store JSON, HTML, or other structured text.
• Make your code look cleaner and easier to read.

That’s it! Text blocks make working with strings in Java much more fun and less messy.

Review Questions on “Reference Types: Strings in Java”

What is a string (String) in Java?
a) A data type for storing numbers.
b) A simple sequence of characters.
c) An object representing text.
d) A method for working with text.

Why are strings in Java considered immutable?
a) They cannot be deleted from the program.
b) Changes create a new object instead of modifying the existing one.
c) They are protected from changes by built-in methods.
d) Their length is fixed.

What does the .length() method do, and how is it used?
a) Returns the number of characters in a string.
b) Changes the length of the string.
c) Multiplies the characters in the string.
d) Converts the string to uppercase.

What will the following code output?
Remember: in Java, character numbering starts at zero. For example, P is at position 0.

String text = "Programming";
System.out.println(text.charAt(3));