Day 7: Strings in Java

Day 7: Strings in Java


6 min read

In this comprehensive blog, we will explore the concept of strings in the Java programming language and how to manipulate them effectively. Java is a versatile, object-oriented language often used for making web applications, Android apps, and other software. One of the most commonly used data types in Java is the String class, which represents a sequence of characters.

By the end of this blog, you will have a solid understanding of strings in Java and will be able to perform various string manipulations effectively.

What is a String?

A string is a sequence of characters that represents text. In Java, strings are objects of the String class, which is a part of the java.lang package. The String class provides many useful methods for creating, modifying, and comparing strings.

Here's a simple example of a string in Java:

String greeting = "Hello, World!";

In this example, the variable greeting holds a string object containing the text "Hello, World!".

Creating Strings

There are two common ways to create string objects in Java:

  1. String literal: A string literal is a sequence of characters enclosed in double-quotes. When you use a string literal, the Java compiler automatically creates a String object for it.
String stringLiteral = "This is a string literal";
  1. Using the new keyword: You can also create a String object by using the new keyword and invoking the String constructor. This approach is less common because it can be less efficient.
String newString = new String("This is a new string object");

Understanding String Immutability

It's important to understand that strings in Java are immutable, meaning that once a A String object is created, its content cannot be changed. Instead, when you perform operations that appear to modify a string, a new A String object is created.

This immutability has several benefits:

  • It makes String objects are safer to use in a multi-threaded environment.

  • It allows strings to be interned (stored in a pool) to save memory.

However, immutability can also lead to performance issues when performing many string manipulations, as each operation creates a new String object. We will discuss some solutions to this issue later in this blog.

Common String Operations

The String class provides numerous methods for manipulating and comparing strings. Here are some of the most commonly used methods:


To find the length of a string, use the length() method:

String example = "Java is awesome!";
int length = example.length(); // 16


To combine two strings, use the concat() method or the + operator:

String first = "Java";
String second = " is awesome!";
String combined = first.concat(second); // "Java is awesome!"

String combinedUsingOperator = first + second; // "Java is awesome!"


To extract a portion of a string, use the substring() method:

String text = "Java is awesome!";
String extracted = text.substring(5, 7); // "is"


To replace characters in a string, use the replace() method:

String text = "Java is awesome!";
String replaced = text.replace("awesome", "great"); // "Java is great!"


To compare two strings, use the equals() method for case-sensitive comparison or equalsIgnoreCase() for case-insensitive comparison:

String first = "Java";
String second = "java";

boolean isEqual = first.equals(second); // false
boolean isEqualIgnoreCase = first.equalsIgnoreCase(second); // true


To find the position of a character or substring within a string, use the indexOf() method:

String text = "Java is awesome!";
int index = text.indexOf("is"); // 5

The StringBuilder and StringBuffer Classes

As mentioned before, immutability can cause performance issues when performing many string manipulations. To avoid creating a new String object with each operation, Java provides the StringBuilder and StringBuffer classes, which allow you to create mutable strings.

Both classes have similar functionality, but StringBuffer is thread-safe, meaning it can be used safely in multi-threaded environments. However, this thread's safety comes at the cost of performance. In most cases, when you don't need thread safety, you should use StringBuilder.

Here's an example of using StringBuilder to concatenate strings:

StringBuilder builder = new StringBuilder();
builder.append(" is");
builder.append(" awesome!");

String result = builder.toString(); // "Java is awesome!"

Here's an example using StringBuffer:

StringBuffer buffer = new StringBuffer();
buffer.append(" is");
buffer.append(" great!");

String result = buffer.toString(); // "Java is great!"

String Tokens and Splitting

When working with strings, you may need to split a string into parts based on a delimiter, such as a space or a comma. To do this, you can use the split() method of the String class:

String text = "Java,Python,C++,JavaScript";
String[] languages = text.split(","); // ["Java", "Python", "C++", "JavaScript"]

You can also use the StringTokenizer class from the java.util package to split a string into tokens:

import java.util.StringTokenizer;

String text = "Java Python C++ JavaScript";
StringTokenizer tokenizer = new StringTokenizer(text, " ");

while (tokenizer.hasMoreTokens()) {
    String token = tokenizer.nextToken();

This code will output:


Regular Expressions

Regular expressions (regex) are a powerful tool for working with strings, allowing you to match, search, and manipulate text based on patterns. Java provides the Pattern and Matcher classes in the java.util.regex package for working with regular expressions.

Here's an example of using regular expressions to validate an email address:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

String email = "";
String regex = "^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)*(\\.[a-zA-Z]{2,})$";

Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(email);

boolean isValid = matcher.matches(); // true

In this example, the Pattern.compile() method creates a Pattern object from the regex string, and the matcher() method creates a Matcher object for the given input string. The matches() method then returns true if the input string matches the regex pattern.

Formatting Strings

Java provides the String.format() method and the Formatter class for formatting strings. You can use placeholders in the format string, which will be replaced by the corresponding values when the string is formatted.

Here's an example of using String.format():

String name = "Alice";
int age = 30;

String formatted = String.format("%s is %d years old", name, age);
System.out.println(formatted); // "Alice is 30 years old"

In this example, %s is a placeholder for a string, and %d is a placeholder for an integer. When the string is formatted, these placeholders are replaced by the values of name and age.


In this blog, we've explored the fundamentals of strings in Java and various techniques for manipulating them. We've discussed string creation, immutability, common string operations, and more advanced topics like StringBuilder, StringBuffer, string splitting, regular expressions, and string formatting.

By understanding the concepts presented in this blog, you'll be able to work with strings more effectively in your Java programs. String manipulation is a crucial skill for any Java developer, as it's a fundamental aspect of many applications and projects.

Did you find this article valuable?

Support Laxman Rai by becoming a sponsor. Any amount is appreciated!