Converting a string to title case, where the first letter of each word is capitalized and the rest are in lowercase, is a common task in text formatting. This can be particularly useful in applications that deal with user names, titles, or any other textual content where proper capitalization is important.

In this article, we’ll explore different ways to convert a string to title case in Java. We’ll cover both basic and more advanced methods, providing code examples and explanations for each approach.

1. Basic Approach: Iterating Through Words

The most straightforward way to convert a string to title case is by splitting the string into words, capitalizing the first letter of each word, and then joining them back together. This method uses the String methods split(), substring(), and toUpperCase().

Code Example:

public class TitleCaseConverter {
    public static String toTitleCase(String input) {
        String[] words = input.toLowerCase().split("\\s+");
        StringBuilder titleCase = new StringBuilder();

        for (String word : words) {
            if (word.length() > 0) {
                titleCase.append(Character.toUpperCase(word.charAt(0)))
                         .append(word.substring(1))
                         .append(" ");
            }
        }

        return titleCase.toString().trim();
    }

    public static void main(String[] args) {
        String sentence = "java programming is fun";
        System.out.println(toTitleCase(sentence)); // Expected Output: Java Programming Is Fun
    }
}

In a situation where you need to convert a string to title case without relying on external libraries.

The approach is simple : Split the string into words, convert the first character of each word to uppercase, and then reassemble the string.

2. Using StringBuilder for Efficiency

While the basic approach works well, it can be optimized using StringBuilder to avoid the overhead of multiple string concatenations. This can improve performance, especially with longer strings.

Code Example:

public class TitleCaseConverter {
    public static String toTitleCase(String input) {
        StringBuilder titleCase = new StringBuilder();
        boolean nextTitleCase = true;

        for (char c : input.toCharArray()) {
            if (Character.isSpaceChar(c)) {
                nextTitleCase = true;
            } else if (nextTitleCase) {
                c = Character.toTitleCase(c);
                nextTitleCase = false;
            } else {
                c = Character.toLowerCase(c);
            }
            titleCase.append(c);
        }

        return titleCase.toString();
    }

    public static void main(String[] args) {
        String sentence = "java programming is fun";
        System.out.println(toTitleCase(sentence)); // Expected Output: Java Programming Is Fun
    }
}

You can use this approach if you want a more efficient way to convert a string to title case, especially for longer strings.

Use StringBuilder to build the result string, and a flag to track when the next character should be capitalized.

3. Stream Approach: Using Java Streams

For a more modern and functional approach, you can use Java Streams. This method involves splitting the string into an array of words, processing each word to capitalize the first letter, and then joining the words back together.

Code Example:

import java.util.Arrays;
import java.util.stream.Collectors;

public class TitleCaseConverter {
    public static String toTitleCase(String input) {
        return Arrays.stream(input.toLowerCase().split("\\s+"))
                     .map(word -> Character.toUpperCase(word.charAt(0)) + word.substring(1))
                     .collect(Collectors.joining(" "));
    }

    public static void main(String[] args) {
        String sentence = "java programming is fun";
        System.out.println(toTitleCase(sentence)); // Expected Output: Java Programming Is Fun
    }
}

If you prefer a functional programming style and want to leverage the power of Java Streams. Use Stream to process the string, capitalize each word, and join them into a title-cased string.

4. Advanced Approach: Using the Apache Commons Library

If you’re working on a project where you can afford to use external libraries, the Apache Commons Text library offers a convenient method for converting strings to title case. This method is not only concise but also highly reliable.

Code Example:

import org.apache.commons.text.WordUtils;

public class TitleCaseConverter {
    public static String toTitleCase(String input) {
        return WordUtils.capitalizeFully(input);
    }

    public static void main(String[] args) {
        String sentence = "java programming is fun";
        System.out.println(toTitleCase(sentence)); // Expected Output: Java Programming Is Fun
    }
}

Use WordUtils.capitalizeFully() from Apache Commons Text to capitalize each word in the string., if you want a reliable, well-tested method for converting strings to title case, and you’re open to using external libraries.

Converting a string to title case in Java can be done in several ways, each suited to different needs and contexts. Whether you opt for a basic iterative approach, optimize with StringBuilder, leverage Java Streams, or utilize an external library like Apache Commons Text, Java offers flexible options for handling text formatting tasks.

Choose the method that best suits your project’s requirements, considering factors like performance, code simplicity, and dependency management.

Happy Coding! 🚀