String Functions in Java

Strings are everywhere — names, messages, URLs, file paths. Java's String class is immutable and packed with dozens of useful methods. Mastering them unlocks fast text manipulation for searching, formatting, validation and data extraction.

• Create a string: String s = "Hello";
• Call methods using dot notation: s.length(), s.charAt(0)
• Strings are immutable — methods return new strings.
• Use StringBuilder for repeated modifications.

Let's start with a hands-on example. The program below shows the core idea behind String Functions in just a few lines of Java. Read it line by line and observe how Java executes each statement in order.

class Main
{
    public static void main(String args[])
    {
        String s = "PBA Institute";

        System.out.println("Length: " + s.length());
        System.out.println("Upper:  " + s.toUpperCase());
        System.out.println("Lower:  " + s.toLowerCase());
        System.out.println("Char 4: " + s.charAt(4));
    }
}

The following examples progress from simple to more practical patterns. Try each in your IDE, change the inputs and observe the output. This is the fastest way to internalize the concept.

class Main
{
    public static void main(String args[])
    {
        String s = "Java Programming";

        System.out.println(s.substring(5));
        System.out.println(s.substring(0, 4));
        System.out.println(s.indexOf("Program"));
    }
}

class Main
{
    public static void main(String args[])
    {
        String s = "   Hello Java   ";

        System.out.println(s.trim());
        System.out.println(s.replace("Java", "World"));
    }
}

class Main
{
    public static void main(String args[])
    {
        String s = "Apple,Banana,Mango";

        String fruits[] = s.split(",");

        for (String f : fruits)
            System.out.println(f);
    }
}

class Main
{
    public static void main(String args[])
    {
        String a = "hello";
        String b = "HELLO";

        System.out.println(a.equals(b));
        System.out.println(a.equalsIgnoreCase(b));
        System.out.println(a.compareTo(b));
    }
}

class Main
{
    public static void main(String args[])
    {
        String s = "PBA";

        String rev = new StringBuilder(s).reverse().toString();

        System.out.println(rev);
    }
}

• Strings in Java are immutable — each modification creates a new String object.
• Use StringBuilder or StringBuffer for heavy modification.
• Use equals() for content comparison; == compares object references.
• String constant pool optimizes memory by reusing literal Strings.
• split() uses regex by default — escape special characters as needed.

Reading is not enough — practice solidifies knowledge. Try every question below in your own editor before peeking at any solution.

• Q1. Count vowels and consonants in a string.
• Q2. Reverse a string without StringBuilder.
• Q3. Check if a string is a palindrome.
• Q4. Count word occurrences in a sentence.
• Q5. Convert the first letter of each word to uppercase.

These are the most common questions asked in Java interviews on this topic. Memorize the concept, not just the answer — interviewers often follow up with edge cases.

Even experienced developers slip on the same pitfalls. Watch out for these classic mistakes while working with String Functions in Java:

• Forgetting the semicolon ; at the end of statements while using String Functions.
• Mixing up similar method names — read Java docs before using new APIs related to String Functions.
• Ignoring compiler warnings — they often hint at bugs that will appear later in production.
• Hard-coding values that should come from configuration files or environment variables.
• Not handling edge cases: empty inputs, very large inputs, negative numbers and null references.
• Skipping unit tests — small tests prevent big regressions, especially around control flow.