Reverse Alternate Words in A String Java

There are various ways to control strings. One common task is to opposite exchange phrases in a given string. In this section, we will discover how to attain this in Java. To get started out, let's define what we imply with the aid of "reverse exchange phrases".

Given a string, we need to reverse every different word. For instance, if we've the string "the fast brown fox jumps over the lazy dog", we might need to get the string "eht kciuq nworb xof spmuj revo eht yzal god". To accomplish this, we need to break down the string into character words, then reverse every other phrase.

We will use the following two approaches to reverse the string:

Using String.split() Method
Using Regular Expression

Using String.split() Method

The first approach is to use the String.Breakup() approach to split the string into an array of phrases, then reverse every other phrase within the array. The following example demonstrate the same.

ReverseAlternateWords.java

public class ReverseAlternateWords {
    public static void main(String[] args) {
        String str = "the quick brown fox jumps over the lazy dog";
        String[] words = str.split(" ");
        for (int i = 0; i < words.length; i += 2) {
            words[i] = reverse(words[i]);
        }
        StringBuilder sb = new StringBuilder();
        for (String word : words) {
            sb.append(word).append(" ");
        }
        String result = sb.toString().trim();
        System.out.println(result);
    }
    private static String reverse(String str) {
        StringBuilder sb = new StringBuilder(str);
        return sb.reverse().toString();
    }
}

Output:

eht kciuq nworb xof spmuj revo eht yzal god

In this program, we first define the enter string "the short brown fox jumps over the lazy dog". We then name the split() technique at the string, passing in a space man or woman because the delimiter. This splits the string into an array of phrases, which we shop within the words variable. Next, we loop thru the words array, starting at index 0 and incrementing via 2 on every generation. This manner we most effective manner every other word within the array. Inside the loop, we call the reverse() approach to reverse the present day word, then keep the end result back into the words array. After reversing every different phrase, we construct a new string by way of looping thru the phrases array again and appending each phrase, separated with the aid of a space individual, to a StringBuilder. We then name the toString() approach at the StringBuilder to get the very last result, which we store within the result variable.

Using a Regular Expression

Another method to opposite change words is to use a normal expression to fit every other phrase within the string, then reverse the matched words. Here is an example software that demonstrates this method:

ReverseAlternateWords.java

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ReverseAlternateWords {
    public static void main(String[] args) {
        String str = "the quick brown fox jumps over the lazy dog";
        Pattern pattern = Pattern.compile("(\\w+\\W+)(\\w+)");
        Matcher matcher = pattern.matcher(str);
        StringBuilder sb = new StringBuilder();
        int lastEnd = 0;
        while (matcher.find()) {
            sb.append(str.substring(lastEnd, matcher.start()));
            sb.append(reverse(matcher.group(2)));
            sb.append(matcher.group(1));
            lastEnd = matcher.end();
        }
        sb.append(str.substring(lastEnd));
        String result = sb.toString();
        System.out.println(result);
}
private static String reverse(String str) {
StringBuilder sb = new StringBuilder(str);
return sb.reverse().toString();
}
}

Output:

eht kciuq nworb xof spmuj revo eht yzal god

In this program, we first outline the enter string "the quick brown fox jumps over the lazy dog". We then define a regular expression sample that fits each other word within the string. The sample consists of groups: the primary institution fits one or extra phrase characters followed through one or greater non-word characters (i.E., a phrase and any following punctuation), and the second one group fits the subsequent word in the string. We then create a Matcher item by calling the matcher() method at the sample, passing within the enter string. We also create a StringBuilder object to keep the end result, and an integer variable lastEnd to hold music of the cease index of the closing match.

Inside some time loop, we name the discover() method on the Matcher item to look for the next suit. If a healthy is discovered, we append the substring among the end index of the final in shape and the start index of the modern match to the StringBuilder. We then append the reversed second organization of the fit, accompanied via the first organization of the match. Finally, we replace lastEnd to the give up index of the modern-day healthy. After the even as loop, we append the ultimate substring of the enter string to the StringBuilder and call the toString() approach to get the final end result, which we save in the end result variable.

Both procedures obtain the identical result, however they use specific strategies to accomplish the project. The break up() technique is less complicated and simpler to recognize, however it creates a brand new array of phrases and may be much less green for huge strings. The regular expression approach is extra complex; however, it operates at once on the enter string and may be more green for massive strings.

In conclusion, reversing exchange phrases in a string is a not unusual task in programming, and there are numerous ways to perform it. In Java, we are able to use both the String.Cut up() approach or a normal expression to obtain this challenge. Which approach to use depends at the specific requirements of the application, inclusive of overall performance, clarity, and maintainability.

Next TopicSize of Empty Class in Java

← prev next →