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

假设我有一个名为x的字符串，它=“Hello world”。我想以某种方式使它翻转这两个词，而不是显示“世界你好”。我不太擅长循环或数组，显然我是个初学者。我可以通过拆分字符串来实现这一点吗？如果是，怎么做？如果没有，我该怎么做？非常感谢您的帮助，谢谢

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]);

String[]片段=abc.split（“”）；
对于（int i=0；i1），将字符串拆分为空间上的
string
数组

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

2） 从数组中按相反顺序创建新字符串

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

使用
StringBuilder
而不是串联的额外积分。
根据您的具体要求，您可能希望在其他形式的空白（制表符、多个空格等）上拆分：

如果您想变得更复杂，请参阅模式文档，这里是解决方案：

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);
    }
}

import java.util.*；
公共类反向树{
公共字符串反转符（字符串短语）{
List wordList=Arrays.asList（短语.split（“[]”）；
集合。反向（单词列表）；
StringBuilder sbReverseString=新StringBuilder（）；
for（字符串字：单词列表）{
sbreversString.append（word+“”）；
}
返回sbreversString.substring（0，sbreversString.length（）-1）；
}
}

上面的解决方案是我为Google Code Jam编写的，也在这里发表了博客：
尝试以下内容：

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);

String input=“这是怎么回事”；
List words=Arrays.asList（input.split（“”））；
收藏。反面（文字）；
字符串结果=”；
for（字符串字：字）{
如果（！result.isEmpty（））{
结果+=”；
}
结果+=单词；
}
系统输出打印项次（结果）；

输出：

this is how
这是怎么回事
太多了

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();
}

private static final Pattern WORD=Pattern.compile（“^（\\p{L}+）；
私有静态最终模式编号=Pattern.compile（“^（\\p{N}+）”；
私有静态最终模式空间=Pattern.compile（“^（\\p{Z}+”）；
公共静态字符串反转记录（最终字符串文本）{
最终StringBuilder sb=新StringBuilder（text.length（））；
最终匹配器wordMatcher=WORD.Matcher（文本）；
最终匹配器编号Matcher=NUMBER.Matcher（文本）；
final Matcher spaceMatcher=SPACE.Matcher（文本）；
整数偏移=0；
while（偏移量0&&caseReversalMatcher.find（））{
sb.insert（0，caseReversalMatcher.group（3.toUpperCase（））；
sb.插入（0，病例对照组（2））；
sb.insert（0，caseReversalMatcher.group（1.toLowerCase（））；
wordEndOffset=caseReversalMatcher.start（）；
caseReversalMatcher.region（0，字内偏移）；
}
sb.插入（0，字子串（0，字内偏移））；
使某人返回字符串（）；
}
只需使用此方法，调用它并传递要拆分的字符串即可

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;
}

静态字符串反转记录（字符串str）{
//指定要搜索的模式
Pattern=Pattern.compile（“\\s”）；
//使用模式拆分字符串str
//（即）在其
//是空白，存储在临时数组中。
String[]temp=pattern.split（str）；
字符串结果=”；
//迭代临时数组并存储
//字符串的顺序相反。
对于（int i=0；i
不知何故，我不认为Lanuk想要的答案只是用另一个字符串替换这两个单词。hello world只是一个示例。该示例不适用于其他字符串。我假设您看到了我文章的其余部分，其中包含explode语句@owlstead？使用StringBuilder替换这两个单词？Java将自己完成这一切。过早优化？@owlstead-扩展；虽然上面的内容不能保证使用
StringBuilder
，但了解它以及在java中使用字符串连接的陷阱是很好的。考虑到OP的明显初学者水平，在它咬到他之前尽早学习对他来说是一件好事；）@布莱恩罗奇-如果你要教一堂课，那应该是正确的一课。在大多数情况下，使用
StringBuilder
而不是
+
@StephenC-AFAIK是不好的做法。编译器会尽可能地为您执行此操作，Josh Bloch在他的书中对此非常清楚。发生了什么变化？我很高兴忏悔：）@BrianRoach为此使用了stringbuilder:
System.out.println（reverseWords（“Owlstead是01 very\'srange bïrd\”！）
获取
！“bïrd strange”非常01是owlsteaD
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;
}