First letter in each word is the same

String str is given which contains lowercase English letters and spaces. It may contain multiple spaces. Get the first letter of every word and return the result as a string. The result should not contain any space.

Examples: 

Input : str = "geeks for geeks"
Output : gfg

Input : str = "geeks for geeks""
Output : hc

Source: https://www.geeksforgeeks.org/amazon-interview-set-8-2/

The idea is to traverse each character of string str and maintain a boolean variable, which was initially set as true. Whenever we encounter space we set the boolean variable is true. And if we encounter any character other than space, we will check the boolean variable, if it was set as true as copy that charter to the output string and set the boolean variable as false. If the boolean variable is set false, do nothing. 

Algorithm: 

1. Traverse string str. And initialize a variable v as true.
2. If str[i] == ' '. Set v as true.
3. If str[i] != ' '. Check if v is true or not.
   a) If true, copy str[i] to output string and set v as false.
   b) If false, do nothing.

Implementation:

Time Complexity: O(n)
Auxiliary space: O(1). 

Approach 1 : Reverse Iterative Approach 

This is simplest approach to to getting first letter of every word of the string. In this approach we are using reverse iterative loop to get letter of words. If particular letter ( i ) is 1st letter of word or not is can be determined by checking pervious character that is (i-1). If the pervious letter is space (‘ ‘) that means (i+1) is 1st letter then we simply add that letter to the string. Except character at 0th position. At the end we simply reverse the string and function will return string which contain 1st letter of word of the string.

Time Complexity: O(n)
Auxiliary space: O(1). 

Approach 2: Using StringBuilder

This approach uses the StringBuilder class of Java. In this approach, we will first split the input string based on the spaces. The spaces in the strings can be matched using a regular expression. The split strings are stored in an array of strings. Then we can simply append the first character of each split string in the String Builder object.  

Implementation:

Time Complexity: O(n)
Auxiliary space: O(1). 

Another Approach: Using boundary checker, refer https://www.geeksforgeeks.org/get-first-letter-word-string-using-regex-java/

This article is contributed by Aarti_Rathi and Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

In this short guide, you will learn how to capitalize the first letter of each word in a string using Java. We have already learned to capitalize the first letter of a string in Java. But capitalizing each word in a string is a bit tricky.

Using Java 8 Streams

The easiest way to capitalize the first character of each word of a string is by using Java 8 Stream API:

String str = "welcome to java";

// uppercase first letter of each word
String output = Arrays.stream(str.split("\s+"))
        .map(t -> t.substring(0, 1).toUpperCase() + t.substring(1))
        .collect(Collectors.joining(" "));

// print the string
System.out.println(output);
// Welcome To Java

In the above example, we first split the string into an array using the split() method. The array is passed to Arrays.stream() as a parameter that turns it into a Stream object. Afterward, we use the map() method from streams to capitalize each word before converting it back to a string using the collect() method.

If the string is empty or null, the above code will throw an exception. Let us write a function capitalizeAll() that makes sure there is no exception while transforming string:

public static String capitalizeAll(String str) {
    if (str == null || str.isEmpty()) {
        return str;
    }

    return Arrays.stream(str.split("\s+"))
            .map(t -> t.substring(0, 1).toUpperCase() + t.substring(1))
            .collect(Collectors.joining(" "));
}

Here are a few examples that use the above function to capitalize the first character of each word:

System.out.println(capitalizeAll("welcome to java")); // Welcome To Java
System.out.println(capitalizeAll("this is awesome")); // This Is Awesome
System.out.println(capitalizeAll("mcdonald in lahore")); // Mcdonald In Lahore
System.out.println(capitalizeAll(null)); // null

The above solution only changes the first letter of each word while all other characters remain the same.

Sometimes, you want to ensure that only the first character of a word is capitalized. Let us write another function capitalizeFully() for this:

public static String capitalizeFully(String str) {
    if (str == null || str.isEmpty()) {
        return str;
    }

    return Arrays.stream(str.split("\s+"))
            .map(t -> t.substring(0, 1).toUpperCase() + t.substring(1).toLowerCase())
            .collect(Collectors.joining(" "));
}

The only difference between capitalizeAll() and capitalizeFully() is that the latter function explicitly changes the remaining part of the word to lowercase:

System.out.println(capitalizeFully("i aM aTTa")); // I Am Atta
System.out.println(capitalizeFully("fOo bAr")); // Foo Bar

Using String.replaceAll() Method

If you are using Java 9 or higher, it is possible to use a regular expression with the String.replaceAll() method to capitalize the first letter of each word in a string. The String.replaceAll() method replaces each substring of this string that matches the given regular expression with the given replacement. Here is an example:

public static String capitalizeAll(String str) {
    if (str == null || str.isEmpty()) {
        return str;
    }

    return Pattern.compile("\b(.)(.*?)\b")
            .matcher(str)
            .replaceAll(match -> match.group(1).toUpperCase() + match.group(2));
}

Let us have some examples:

System.out.println(capitalizeAll("12 ways to learn java")); // 12 Ways To Learn Java
System.out.println(capitalizeAll("i am atta")); // I Am Atta
System.out.println(capitalizeAll(null)); // null

Using Apache Commons Text

The Apache Commons Text library is yet another option to convert the first character of each word in a string to uppercase. Add the following dependency to your build.gradle file:

implementation 'org.apache.commons:commons-text:1.8'

For the Maven project, you need to add the following to your pom.xml file:

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-text</artifactId>
   <version>1.8</version>
</dependency>

Now you can use the capitalize() method from the WordUtils class to capitalize each word in a string:

System.out.println(WordUtils.capitalize("love is everywhere")); // Love Is Everywhere
System.out.println(WordUtils.capitalize("sky, sky, blue sky!")); // Sky, Sky, Blue Sky!
System.out.println(WordUtils.capitalize(null)); // null

The good thing about WordUtils methods is that they handle the exceptions gracefully. There won’t be any exception even if the input is null.

The WordUtils class also provides the capitalizeFully() method that capitalizes the first character and turns the remaining characters of each word into lowercase:

System.out.println(WordUtils.capitalizeFully("fOO bAR")); // Foo Bar
System.out.println(WordUtils.capitalizeFully("sKy is BLUE!")); // Sky Is Blue!

✌️ Like this article? Follow me on
Twitter
and LinkedIn.
You can also subscribe to
RSS Feed.

ANSWER KEY