如何翻转字符串中的两个单词，Java

Question

假设我有一个名为 x 的字符串 =“Hello world”。我想以某种方式让它翻转这两个词，而是显示“世界你好”。我不太擅长循环或数组，显然是初学者。我可以通过拆分字符串以某种方式完成此操作吗？如果是这样，怎么做？如果没有，我该怎么做？将不胜感激，谢谢！

Answer 1

1) 将字符串拆分为空间上的String 数组。

String myArray[] = x.split(" ");

2) 从数组中逆序创建新的字符串。

String newString = myArray[1] + " " + myArray[0];

使用 StringBuilder 而不是串联的奖励积分。

Answer 2

String abc = "Hello world";
String cba = abc.replace( "Hello world", "world Hello" );

abc = "This is a longer string. Hello world. My String";
cba = abc.replace( "Hello world", "world Hello" );

如果你愿意，你也可以分解你的字符串：

String[] pieces = abc.split(" ");
for( int i=0; i<pieces.length-1; ++i )
    if( pieces[i]=="Hello" && pieces[i+1]=="world" ) swap(pieces[i], pieces[i+1]);

还有很多其他方法可以做到这一点。注意大小写。您可以在 if 语句中使用 .toUpperCase() ，然后将匹配的条件变为大写，但将结果保留为原始大写等。

Answer 3

解决办法如下：

import java.util.*;

public class ReverseWords {
    public String reverseWords(String phrase) {
        List<String> wordList = Arrays.asList(phrase.split("[ ]"));
        Collections.reverse(wordList);

        StringBuilder sbReverseString = new StringBuilder();
        for(String word: wordList) {
            sbReverseString.append(word + " ");
        }

        return sbReverseString.substring(0, sbReverseString.length() - 1);
    }
}

上面的解决方案是我为 Google Code Jam 编写的，也在这里写博客：Reverse Words - GCJ 2010

Answer 4

只要使用这个方法，调用它并传递你想要拆分出来的字符串

static String reverseWords(String str) {

    // Specifying the pattern to be searched
    Pattern pattern = Pattern.compile("\\s");

    // splitting String str with a pattern
    // (i.e )splitting the string whenever their
    //  is whitespace and store in temp array.
    String[] temp = pattern.split(str);
    String result = "";

    // Iterate over the temp array and store
    // the string in reverse order.
    for (int i = 0; i < temp.length; i++) {
        if (i == temp.length - 1) {
            result = temp[i] + result;
        } else {
            result = " " + temp[i] + result;
        }
    }
    return result;
}

Answer 5

根据您的具体要求，您可能希望拆分为其他形式的空白（制表符、多个空格等）：

static Pattern p = Pattern.compile("(\\S+)(\\s+)(\\S+)");
public String flipWords(String in)
{
    Matcher m = p.matcher(in);
    if (m.matches()) {
        // reverse the groups we found
        return m.group(3) + m.group(2) + m.group(1);
    } else {
        return in;
    }
}

如果您想变得更复杂，请参阅 Pattern http://docs.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html 的文档

Answer 6

尝试以下方法：

String input = "how is this";
List<String> words = Arrays.asList(input.split(" "));
Collections.reverse(words);
String result = "";
for(String word : words) {
    if(!result.isEmpty()) {
        result += " ";
    }
    result += word;
}
System.out.println(result);

输出：

这就是

Answer 7

太多了？

private static final Pattern WORD = Pattern.compile("^(\\p{L}+)");
private static final Pattern NUMBER = Pattern.compile("^(\\p{N}+)");
private static final Pattern SPACE = Pattern.compile("^(\\p{Z}+)");

public static String reverseWords(final String text) {
    final StringBuilder sb = new StringBuilder(text.length());

    final Matcher wordMatcher = WORD.matcher(text);
    final Matcher numberMatcher = NUMBER.matcher(text);
    final Matcher spaceMatcher = SPACE.matcher(text);

    int offset = 0;
    while (offset < text.length()) {

        wordMatcher.region(offset, text.length());
        numberMatcher.region(offset, text.length());
        spaceMatcher.region(offset, text.length());

        if (wordMatcher.find()) {
            final String word = wordMatcher.group();
            sb.insert(0, reverseCamelCase(word));
            offset = wordMatcher.end();
        } else if (numberMatcher.find()) {
            sb.insert(0, numberMatcher.group());
            offset = numberMatcher.end();
        } else if (spaceMatcher.find()) {
            sb.insert(0, spaceMatcher.group(0));
            offset = spaceMatcher.end();
        } else {
            sb.insert(0, text.charAt(offset++));
        }
    }

    return sb.toString();
}

private static final Pattern CASE_REVERSAL = Pattern
        .compile("(\\p{Lu})(\\p{Ll}*)(\\p{Ll})$");

private static String reverseCamelCase(final String word) {
    final StringBuilder sb = new StringBuilder(word.length());
    final Matcher caseReversalMatcher = CASE_REVERSAL.matcher(word);
    int wordEndOffset = word.length();
    while (wordEndOffset > 0 && caseReversalMatcher.find()) {
        sb.insert(0, caseReversalMatcher.group(3).toUpperCase());
        sb.insert(0, caseReversalMatcher.group(2));
        sb.insert(0, caseReversalMatcher.group(1).toLowerCase());
        wordEndOffset = caseReversalMatcher.start();
        caseReversalMatcher.region(0, wordEndOffset);
    }
    sb.insert(0, word.substring(0, wordEndOffset));
    return sb.toString();
}