在Java中反转给定的句子答案

【问题标题】：Reverse a given sentence in Java在Java中反转给定的句子
【发布时间】：2010-04-26 13:14:03
【问题描述】：

谁能告诉我如何编写一个Java程序来反转给定的句子？

例如，如果输入是：

“这是一道面试题”

输出必须是：

“问题采访是这个”

【问题讨论】：

您可能应该考虑参加 Java 认证课程，因为他们会教您常用的 Java 库课程。然后，您将拥有完成此类任务所需的工具。
先反转字符串。那就把话倒过来。它需要两次通过，但非常干净。也可以一次性完成。
@jack，我想你的第一个词应该是“分裂”，是吗？
@CPerkins：好吧，“问题”->“noitseuq eht”->“问题”仍然有效，我怀疑这就是杰克的意思，因为回答者已经发布了你的方式。跨度>
@CPerkins 没有。我的意思是（在 python 中）：
str = "这是面试问题"
str1 = str[::-1]
print str1 for word in str1.split(" "):
print word[::-1]

标签： java string reverse

【解决方案1】：

您将字符串按空格分割，然后向后迭代以组装反转的句子。

String[] words =  "This is interview question".split(" ");

String rev = "";
for(int i = words.length - 1; i >= 0 ; i--)
{
   rev += words[i] + " ";
}

// rev = "question interview is This "

// can also use StringBuilder:
StringBuilder revb = new StringBuilder();
for(int i = words.length - 1; i >= 0 ; i--)
{
   revb.append(words[i]);
   revb.append(" ");
}
// revb.toString() = "question interview is This "

【讨论】：

这不会添加尾随空格吗？
您连接到string（每次都会创建一个新的string 对象）而不是使用StringBuilder 是否有原因？
@Christopher Parker - 简单地展示原理。这当然可以调整为更高的性能（如果需要）。
@Skilldrick - Rev.trim(); 删除尾随空格。不是指定的问题，而是像你一样，我不喜欢这样的额外空格。
我不会使用 trim() - 它会创建一个全新的字符串。最好在循环恕我直言中对 i 进行第二次检查。

【解决方案2】：

String[] words = sentence.split(" ");
String[] reversedWords = ArrayUtils.reverse(words);
String reversedSentence = StringUtils.join(reversedWords, " ");

（使用 commons-lang 中的 ArrayUtils 和 StringUtils，但这些方法很容易编写 - 只需几个循环）

【讨论】：

使用外部库来回答这个简单的面试问题并没有那么好。
好吧。过去的事情并不简单这个问题面试一个使用外的图书馆
@D'Nabre - 如果你足够了解 commons-lang 来编写该代码，我认为它会做得很好。
@D'Nabre 我不这么认为。如果他们要求你解释这些实用方法是如何实现的，你总是可以解释的，但这样你就增加了代码的优雅性。如果java.util.Arrays 中存在这些方法怎么办？
如果有人在面试中表现出对了解和使用库指南的欣赏，我肯定会认为这是一个加分项。

【解决方案3】：

与众不同：递归解决方案。不添加任何额外的空格。

public static String reverse(String s) {
   int k = s.indexOf(" ");
   return k == -1 ? s : reverse(s.substring(k + 1)) + " " + s.substring(0, k);
}


System.out.println("[" + reverse("This is interview question") + "]");
// prints "[question interview is This]"

我还将改进split 解决方案，改用\b（这太明显了！）。

    String[] parts = "Word boundary is better than space".split("\\b");
    StringBuilder sb = new StringBuilder();
    for (int i = parts.length; i --> 0 ;) {
        sb.append(parts[i]);
    }
    System.out.println("[" + sb.toString() + "]");
    // prints "[space than better is boundary Word]"

【讨论】：

很好，我真的很喜欢递归解决方案的设计，但是迭代 + 字符串生成器必须更快，对吗？

【解决方案4】：

Bozho 已经给出了一个很好的 Java 特定答案，但是如果您需要在没有 Java API 方法的情况下解决这个问题：

要反转，您只需将单个单词弹出到stack 上，然后在没有单词时将它们全部弹出。

（更清楚一点，Java 确实提供了Stack class，因此在 Java 中也可以使用此方法。

【讨论】：

【解决方案5】：

只需将它在一个空格字符上拆分成一个字符串数组，然后以相反的顺序遍历该数组并构造输出字符串。

String input = "This is interview question";
String output = "";
String[] array = input.split(" ");
for(int i = array.length-1; i >= 0; i--)
{
    output += array[i];
    if (i != 0) { output += " "; }
}

【讨论】：

【解决方案6】：

一个无聊的java：

List<String> l = new ArrayList<String>(Arrays.asList("this is an interview question".split("\\s")));
Collections.reverse(l);
StringBuffer b = new StringBuffer();
for( String s : l ){
    b.append(s).append(' ');
}
b.toString().trim();

在 groovy 中它更具可读性：

"this is an interview question"
    .split("\\s")
    .reverse()
    .join(' ')

【讨论】：

@Oded's 好多了...习惯于使用集合的方式。

【解决方案7】：

我也试一试：这是一个使用堆栈和扫描仪的版本：

String input = "this is interview question";
Scanner sc = new Scanner(input);
Stack<String> stack = new Stack<String>();

while(sc.hasNext()) {
    stack.push(sc.next());
}

StringBuilder output = new StringBuilder();

for(;;) { // forever
    output.append(stack.pop());

    if(stack.isEmpty()) {
        break; // end loop
    } else {
        output.append(" ");
    }
}

【讨论】：

【解决方案8】：

public class ReverseString {

    public void reverse(String[] source) {

        String dest = "";
        for (int n = source.length - 1; n >= 0; n--) {
            dest += source[n] + " ";
        }
        System.out.println(dest);

    }

    public static void main(String args[]) {
        ReverseString rs = new ReverseString();
        String[] str = "What is going on".split(" ");
        rs.reverse(str);

    }

}

【讨论】：

【解决方案9】：

可能是更好的方法..在某处看到了逻辑..这是我的代码可以完成这项工作。

    public class revWords {

    public static void main(String[] args) {

        revWords obj = new revWords();
        String print = obj.reverseWords("I am God");
        System.out.println(print);

    }

    public String reverseWords(String words)
    {
      if(words == null || words.isEmpty() || !words.contains(" "))
        return words;

      String reversed = "";
      for( String word : words.split(" "))
        reversed = word + " " + reversed;

      return reversed;
    }

}

【讨论】：

【解决方案10】：

我认为您不应该使用任何库.. 1）反转整个字符串 2) 反转每个单词。

public static void revWord(char[] a) {

    // reverse whole
    revWord(a, 0, a.length);

    int st = -1;
    int end = -1;

    for (int i = 0; i < a.length; i++) {

        if (st == -1 && a[i] != ' ') {
            st = i;
        }
        if (end == -1 && a[i] == ' ' ) {
            end = i;
        }
        if(i == a.length-1){
            end=i+1;
        }

        if (st != -1 && end != -1) {
            revWord(a, st, end );

            st = -1;
            end = -1;
        }

    }

}

public static void revWord(char[] a, int s, int l) {
    int mid = (l - s) / 2;
    l--;

    for (int i = 0; i < mid; i++, l--) {
        char t = a[s+i];
        a[s+i] = a[l];
        a[l] = t;
    }
}

`

【讨论】：

这仅适用于 ascii 字符集...不是理想的解决方案。

【解决方案11】：

目前还没有人提到基于 Java 8 的普通解决方案，它与 Bozho's 相同，但没有任何第三方库。所以这里是：

String input = "This is interview question";

List<String> list = Arrays.asList(input.split(" "));
Collections.reverse(list);
System.out.println(list.stream().collect(Collectors.joining(" ")));

【讨论】：

【解决方案12】：

请尝试以下解决方案，这对我有用。

public class reverseline {

public static void main(String[] args) {
    // TODO Auto-generated method stub

        String str="This is interview question";
    String words[]=str.split(" ");
    for(int i=words.length-1;i>=0;i--){
        System.out.print(words[i]+" ");
    }
}

}

【讨论】：

【解决方案13】：

在StringTokenizer 被宣布为遗产之前，许多人为此使用了StringTokenizer。以为我会把它留在这里。

String sentence = "This is interview question";
String reversed = "";
StringTokenizer tokens = new StringTokenizer(sentence); 

while (tokens.hasMoreTokens()) { // Loop through each token
    reversed =  tokens.nextToken() + ' ' + reversed; //add to start
}

System.out.println(reversed.trim());

【讨论】：

【解决方案14】：

最短答案

public class ReverseSentence {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter a sentence");
        String inputString = sc.nextLine();

        String[] words = inputString.split(" ");

        List<String> reverseWord = Arrays.asList(words);
        Collections.reverse(reverseWord);

        Iterator itr = reverseWord.iterator();

        while (itr.hasNext()) {
            System.out.print(itr.next() + " ");
        }
    }

}

或

public class ReverseSentence {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter a sentence");
        String inputString = sc.nextLine();

        String[] words = inputString.split(" ");

        for (int i = words.length-1 ; i >= 0; i--) {
            System.out.print(words[i] +" ");
        }
    }

}

【讨论】：