【发布时间】：2010-03-14 07:32:38
【问题描述】：
我想反转 Java 中 String 的每个 individual 单词（不是整个字符串，只是每个单词）。
示例：如果输入字符串是“Hello World”，那么输出应该是“olleH dlroW”。
【问题讨论】：
【发布时间】：2010-03-14 07:32:38
【问题描述】：
这应该可以解决问题。这将遍历源字符串中的每个单词，使用StringBuilder 的内置reverse() 方法将其反转，并输出反转后的单词。
String source = "Hello World";
for (String part : source.split(" ")) {
System.out.print(new StringBuilder(part).reverse().toString());
System.out.print(" ");
}
输出：
olleH dlroW
注意事项：评论者正确地指出了一些我认为我应该在这里提及的事情。此示例将在结果末尾附加一个额外的空格。它还假设您的单词由一个空格分隔，并且您的句子不包含标点符号。
【讨论】：
-
听起来像是功课，使用内置方法是不行的。
-
+1 只是想回答这个问题。请注意，您最后有一个多余的空白
-
可能，但我会在这里留下这个答案，因为问题没有说明它是否与家庭作业有关。
-
@fastcodejava - 在某些人看来，家庭作业问题的完整答案是不可接受的......因为最终它对 OP 没有帮助。
-
这会忽略 unicode 变音符号和其他 unicode 多字符
String问题。请参阅我的答案以获得解决方案：stackoverflow.com/a/20279110/9636
了解你的库 ;-)
import org.apache.commons.lang.StringUtils;
String reverseWords(String sentence) {
return StringUtils.reverseDelimited(StringUtils.reverse(sentence), ' ');
}
【讨论】：
您需要在将split 转换为array 单词后的每个单词上执行此操作。
public String reverse(String word) {
char[] chs = word.toCharArray();
int i=0, j=chs.length-1;
while (i < j) {
// swap chs[i] and chs[j]
char t = chs[i];
chs[i] = chs[j];
chs[j] = t;
i++; j--;
}
return String.valueOf(chs);
}
【讨论】：
-
代理对是 unicode 的一个特性，其中（如果我理解正确的话）不是 16 位形成一个 unicode 字符，而是一对 16 位字符形成一个字符。谷歌“代理对”了解更多信息。
这是最简单的解决方案，甚至不使用任何循环。
public class olleHdlroW {
static String reverse(String in, String out) {
return (in.isEmpty()) ? out :
(in.charAt(0) == ' ')
? out + ' ' + reverse(in.substring(1), "")
: reverse(in.substring(1), in.charAt(0) + out);
}
public static void main(String args[]) {
System.out.println(reverse("Hello World", ""));
}
}
即使这是家庭作业，您也可以随意复制并作为自己的作业提交。你要么获得额外的学分（如果你能解释它是如何工作的），要么被抓到抄袭（如果你不能）。
【讨论】：
-
您能详细解释一下吗？似乎很复杂。
-
提示：思考什么而不是如何。
-
我猜这个解决方案可能涉及到可能的 lisp 作业，仅在 java 中实现:)
-
递归循环仍然是一个循环；）
-
如果字符串的最后一个字符是空格，这将引发异常。
这里没有人考虑 unicode 字符。您需要使用java.text.BreakIterator 来查找单词边界，然后在每个单词边界内使用另一个来枚举字符边界：
String helloWorld = "He\u0308llo World"; // Hëllo World
StringBuilder reverseStringBuilder = new StringBuilder(helloWorld.length());
BreakIterator wordBreakIterator = BreakIterator.getWordInstance();
wordBreakIterator.setText(helloWorld);
int wordStart = wordIterator.first();
int wordEnd = wordIterator.next();
while (wordEnd != BreakIterator.DONE) {
String word = helloWorld.substring(wordStart,wordEnd);
if (Character.isLetterOrDigit(word.charAt(0))) {
// "Hello" or "World" in our example
BreakIterator characterBreakIterator = BreakIterator.getCharacterInstance();
characterBreakIterator.setText(word);
int characterEnd = characterBreakIterator.last();
int characterStart = characterBreakIterator.previous();
while (characterStart != BreakIterator.DONE) {
reverseStringBuilder.append(word.substring(characterStart, characterEnd));
characterEnd = characterStart;
characterStart = characterBreakIterator.previous();
}
} else {
// " " in our example
reverseStringBuilder.append(word);
}
wordStart = wordEnd;
wordEnd = wordIterator.next();
}
String dlroWolleh = reverseStringBuilder.toString(); // "dlroW ollëH"
当您反转String 时，使用上述简单方法会将变音符号\u0308 移动到第一个l 上方。您希望它保持在e 之上。
【讨论】：
-
我使用本地方法（利用 StringBuilder 和 String.charAt() 方法）来反转字符串 'He\u0308llo World'。我的输出是“dlroW oll̈eH”。代码： private void reverseString(String input) { try { StringBuilder build = new StringBuilder(); for(int i=input.length()-1; i>=0; i--){ build.append(input.charAt(i)); } logp.info("反转："+build.toString()); } catch (Exception e) { logp.error(e.getMessage(), e); } }
嗯，我是 C/C++ 人，在面试中练习 Java 让我知道是否可以更改或改进某些内容。以下允许多个空格和换行符。
第一个是使用 StringBuilder
public static String reverse(String str_words){
StringBuilder sb_result = new StringBuilder(str_words.length());
StringBuilder sb_tmp = new StringBuilder();
char c_tmp;
for(int i = 0; i < str_words.length(); i++){
c_tmp = str_words.charAt(i);
if(c_tmp == ' ' || c_tmp == '\n'){
if(sb_tmp.length() != 0){
sb_tmp.reverse();
sb_result.append(sb_tmp);
sb_tmp.setLength(0);
}
sb_result.append(c_tmp);
}else{
sb_tmp.append(c_tmp);
}
}
if(sb_tmp.length() != 0){
sb_tmp.reverse();
sb_result.append(sb_tmp);
}
return sb_result.toString();
}
这个正在使用 char[]。我认为它更有效...
public static String reverse(String str_words){
char[] c_array = str_words.toCharArray();
int pos_start = 0;
int pos_end;
char c, c_tmp;
int i, j, rev_length;
for(i = 0; i < c_array.length; i++){
c = c_array[i];
if( c == ' ' || c == '\n'){
if(pos_start != i){
pos_end = i-1;
rev_length = (i-pos_start)/2;
for(j = 0; j < rev_length; j++){
c_tmp = c_array[pos_start+j];
c_array[pos_start+j] = c_array[pos_end-j];
c_array[pos_end-j] = c_tmp;
}
}
pos_start = i+1;
}
}
//redundant, if only java had '\0' @ end of string
if(pos_start != i){
pos_end = i-1;
rev_length = (i-pos_start)/2;
for(j = 0; j < rev_length; j++){
c_tmp = c_array[pos_start+j];
c_array[pos_start+j] = c_array[pos_end-j];
c_array[pos_end-j] = c_tmp;
}
}
return new String(c_array);
}
【讨论】：
我假设你可以只打印结果（你刚才说'输出应该是......'）;-)
String str = "Hello World";
for (String word : str.split(" "))
reverse(word);
void reverse(String s) {
for (int idx = s.length() - 1; idx >= 0; idx--)
System.out.println(s.charAt(idx));
}
或者返回反转的字符串：
String str = "Hello World";
StringBuilder reversed = new StringBuilder();
for (String word : str.split(" ")) {
reversed.append(reverse(word));
reversed.append(' ');
}
System.out.println(reversed);
String reverse(String s) {
StringBuilder b = new StringBuilder();
for (int idx = s.length() - 1; idx >= 0; idx--)
b.append(s.charAt(idx));
return b.toString();
}
【讨论】：
仅使用 substring() 和递归：
public String rev(String rest) {
if (rest.equals(""))
return "";
return rev(rest.substring(1)) + rest.substring(0,1);
}
【讨论】：
-
看起来不错，方法被调用了12次，11次切换字母，一次返回最终字符串。
-
这段代码确实反转了完整的
String，而不是其中的每个单词。
考虑到分隔符可以有多个空格/制表符，并且我们希望保留它们：
public static String reverse(String string)
{
StringBuilder sb = new StringBuilder(string.length());
StringBuilder wsb = new StringBuilder(string.length());
for (int i = 0; i < string.length(); i++)
{
char c = string.charAt(i);
if (c == '\t' || c == ' ')
{
if (wsb.length() > 0)
{
sb.append(wsb.reverse().toString());
wsb = new StringBuilder(string.length() - sb.length());
}
sb.append(c);
}
else
{
wsb.append(c);
}
}
if (wsb.length() > 0)
{
sb.append(wsb.reverse().toString());
}
return sb.toString();
}
【讨论】：
这是一个接受字符串并将其反转的方法。
public String reverse ( String s ) {
int length = s.length(), last = length - 1;
char[] chars = s.toCharArray();
for ( int i = 0; i < length/2; i++ ) {
char c = chars[i];
chars[i] = chars[last - i];
chars[last - i] = c;
}
return new String(chars);
}
首先你需要将字符串拆分成这样的单词
String sample = "hello world";
String[] words = sample.split(" ");
【讨论】：
我在解决这个问题时想出了这个答案。我尝试不使用嵌套的 for 循环解决方案 O(N^2)。我有点强迫自己使用堆栈来娱乐：D
public StringBuilder reverseWord(String input) {
char separator = ' ';
char[] chars = input.toCharArray();
Stack<Character> stack = new Stack<Character>();
StringBuilder sb = new StringBuilder(chars.length);
for(int i = 0; i < chars.length; i++) {
if(chars[i] != separator) { //letters
stack.push(chars[i]);
//if not last letter don't go any further
if(i != chars.length - 1) { continue; }
}
while(!stack.isEmpty()) {
sb.append(stack.pop());
}
sb.append(separator);
}
//remove the last separator
sb.deleteCharAt(sb.length() - 1);
return sb;
}
【讨论】：
-
+1 我喜欢使用堆栈的方法。但是逻辑比它需要的更复杂，
continue使它更难理解。循环中的逻辑可以简化为：if (chars[i] != separator) { stack.push(chars[i]); } else { while (!stack.isEmpty()) { sb.append(stack.pop()); } sb.append(chars[i])}。然后在返回之前从堆栈中弹出/追加到sb。
public static void main(String[] args) {
System.out.println(eatWord(new StringBuilder("Hello World This Is Tony's Code"), new StringBuilder(), new StringBuilder()));
}
static StringBuilder eatWord(StringBuilder feed, StringBuilder swallowed, StringBuilder digested) {
for (int i = 0, size = feed.length(); i <= size; i++) {
if (feed.indexOf(" ") == 0 || feed.length() == 0) {
digested.append(swallowed + " ");
swallowed = new StringBuilder();
} else {
swallowed.insert(0, feed.charAt(0));
}
feed = (feed.length() > 0) ? feed.delete(0, 1) : feed ;
}
return digested;
}
运行：
olleH dlroW sihT sI s'ynoT edoC
BUILD SUCCESSFUL (total time: 0 seconds)
【讨论】：
使用 split()，您只需更改要拆分的内容。
public static String reverseString(String str)
{
String[] rstr;
String result = "";
int count = 0;
rstr = str.split(" ");
String words[] = new String[rstr.length];
for(int i = rstr.length-1; i >= 0; i--)
{
words[count] = rstr[i];
count++;
}
for(int j = 0; j <= words.length-1; j++)
{
result += words[j] + " ";
}
return result;
}
【讨论】：
-
你忘了把每个单词倒过来。
String input = "Hello World!";
String temp = "";
String result = "";
for (int i = 0; i <= input.length(); i++) {
if (i != input.length() && input.charAt(i) != ' ') {
temp = input.charAt(i) + temp;
} else {
result = temp + " " + result;
temp = "";
}
}
System.out.println("the result is: " + result);
【讨论】：
class ReverseWordsInString{
public static String reverse(String s1){
int l = s1.length();
if (l>1)
return(s1.substring(l-1) + reverse(s1.substring(0,l-1)));
else
return(s1.substring(0));
}
public static void main(String[] args){
String st = "Hello My World!";
String r = "";
for (String word : st.split(" "))
r += " "+ reverse(word);
System.out.println("Reversed words in the given string: "+r.trim());
}
}
【讨论】：
-
这使用递归，所以你最终会得到堆栈溢出。您能否添加几行来解释为什么您认为此版本是对许多现有答案的改进？
-
嗨 Burhan，这不是一个改进的版本。此外，这不是正确的答案，因为它不会逐字颠倒。我没有阅读该问题，而是通过答案发布了反转整个字符串。该程序不使用循环，而是使用递归，不会导致堆栈溢出。这只是另一种方法。可以修改为通过将字符串拆分为单词并为每个单词调用 reverse 函数来使用反转每个单词。
-
Burhan，我已经重新发布了更正的答案以满足确切的要求。请注意，这只是我能想到的另一个逻辑。
使用 split() 函数并反转单个单词
public String reverseSentence(String input)
{
String[] words = input.split(" ");
StringBuilder builder = new StringBuilder();
for (String s : words)
{
String rev = " ";
for (int i = 0; i < s.length(); i++)
{
rev = s.charAt(i) + rev;
}
builder.append(rev);
}
return builder.toString().trim();
}
使用 trim() 删除在新字符串末尾添加的额外空格
输出：
This is my sentence
sihT si ym ecnetnes
【讨论】：
public String reverse(String arg) {
char[] s = arg.toCharArray();
StringBuilder sb = new StringBuilder();
boolean reverse = false;
boolean isChar = false;
int insertPos = 0;
for (int i = 0; i < s.length; i++) {
isChar = Character.isAlphabetic(s[i]);
if (!reverse && isChar) {
sb.append(s[i]);
insertPos = i;
reverse = true;
} else if (reverse && isChar) {
sb.insert(insertPos, s[i]);
} else if (!reverse && !isChar) {
sb.append(s[i]);
} else if (reverse && !isChar) {
reverse = false;
sb.append(s[i]);
}
}
return sb.toString();
}
【讨论】：
package MujeebWorkspace.helps;
// javamujeeb@gmail.com
public class Mujeeb {
static String str= "This code is simple to reverse the word without changing positions";
static String[] reverse = str.split(" ");
public static void main(String [] args){
reverseMethod();
}
public static void reverseMethod(){
for (int k=0; k<=reverse.length-1; k++) {
String word =reverse[reverse.length-(reverse.length-k)];
String subword = (word+" ");
String [] splitsubword = subword.split("");
for (int i=subword.length(); i>0; i--){
System.out.print(splitsubword[i]);
}
}
}
}
【讨论】：
with and without api.
public class Reversal {
public static void main(String s[]){
String str= "hello world";
reversal(str);
}
static void reversal(String str){
String s[]=str.split(" ");
StringBuilder noapi=new StringBuilder();
StringBuilder api=new StringBuilder();
for(String r:s){
noapi.append(reversenoapi(r));
api.append(reverseapi(r));
}
System.out.println(noapi.toString());
System.out.println(api.toString());
}
static String reverseapi(String str){
StringBuilder sb=new StringBuilder();
sb.append(new StringBuilder(str).reverse().toString());
sb.append(' ');
return sb.toString();
}
static String reversenoapi(String str){
StringBuilder sb=new StringBuilder();
for(int i=str.length()-1;i>=0;i--){
sb.append(str.charAt(i));
}
sb.append(" ");
return sb.toString();
}
}
【讨论】：
按块反向复制字符串，然后连接空格。 例如。 “你好 java 世界”。
第一个块 = "hello" 反向复制它：- "olleh" 然后添加空格
第二块 = “java”等
public static void main(String args[]) {
String s, rev = "";
Scanner in = new Scanner(System.in);
System.out.println("Enter a string to reverse");
s = in.nextLine();
int length = s.length();
// char[] cs=s.toCharArray();
int l, r;
int i = 0;
while (i < length) {
l = i; // starting index
// find length of sub-block to reverse copy
while (i < length && s.charAt(i) != ' ') {
i++;
}
r = i - 1; // ending index
for (int j = r; j >= l; j--) { // copy reverse of sub-block
rev = rev + s.charAt(j);
}
rev = rev + " "; // add the whitespace
i++;
}
System.out.println("Reverse of entered string is: " + rev);
}
程序也适用于单词之间的多个空格。
【讨论】：
上述一些解决方案具有较高的运行时复杂性。使用下面的算法，可以在 O(n) 时间内完成。
算法：
- 从头到尾解析字符串。
- 每次遇到空格字符即“”时，将之前解析的字符列表放入一个可以动态增长的 ArrayList 中。
- 以相反的顺序打印 ArrayList，从而为您提供所需的输出。
复杂度：O(n)，其中 n 是字符串的长度。
import java.io.IOException;
import java.util.ArrayList;
public class WordReverse {
public static void main(String[] args) throws IOException {
String inputStr = "Hello World";
String reversed = "";
ArrayList<String> alist = new ArrayList<String>();
for (int i = inputStr.length() - 1; i >= 0; i--) {
if (inputStr.charAt(i) != ' ') {
reversed = reversed + inputStr.charAt(i);
} else {
alist.add(reversed);
reversed = "";
}
}
alist.add(reversed);
String result = "";
for (int i = alist.size() - 1; i >= 0; i--) {
result = result + alist.get(i);
result = result + " ";
}
System.out.println(result);
}
}
【讨论】：
使用 TC - O(n) 和 SC - O(1) 的解决方案
public String reverseString(String str){
String str = "Hello Wrold";
int start = 0;
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == ' ' || i == str.length() - 1) {
int end = 0;
if (i == str.length() - 1) {
end = i;
} else {
end = i - 1;
}
str = swap(str, start, end);
start = i + 1;
}
}
System.out.println(str);
}
private static String swap(String str, int start, int end) {
StringBuilder sb = new StringBuilder(str);
while (start < end) {
sb.setCharAt(start, str.charAt(end));
sb.setCharAt(end, str.charAt(start));
start++;
end--;
}
return sb.toString();
}
【讨论】：
流 API 示例
public static String reverseAllWords(String str) {
String[] arr = str.split(" ");
String res = "";
for (int x = 0; x < arr.length; x++) {
res = res + Stream.of(arr[x].split("")).reduce("", (a, b) -> b + a) + " ";
}
return res;
}
【讨论】：
您可以使用增强的for循环来反转字符串并交换里面的summands：
public static String reverse(String str) {
String revStr = "";
for (char ch : str.toCharArray()) {
// concat of chars in reverse order
revStr = ch + revStr;
}
return revStr;
}
public static String[] reverse(String[] arr) {
String[] revArr = new String[arr.length];
for (int i = 0; i < arr.length; i++) {
// same word order
revArr[i] = reverse(arr[i]);
}
return revArr;
}
public static void main(String[] args) {
String[] arr = reverse("Hello World".split(" "));
System.out.println(String.join(" ", arr));
}
输出：
olleH dlroW
【讨论】：
String someString = new String("Love thy neighbor");
System.out.println(someString);
char[] someChar = someString.toCharArray();
int j = someChar.length - 1;
char temp;
for (int i = 0; i <= someChar.length / 2; i++) {
temp = someChar[i];
someChar[i] = someChar[j];
someChar[j] = temp;
j--;
}
someString = new String(someChar);
System.out.println(someString);
运行：
Love thy neighbor
robhgien yht evoL
【讨论】：
-
反转整个字符串。
这会反转给定字符串中的单词。假设单词由一个空格分隔。反转在原地完成（在字符缓冲区中）。
public static String reversePhrases(String s)
{
char[] buf = s.toCharArray();
int len = buf.length;
int start = 0;
for (int i = 0; i < len; i++) {
if (buf[i] == ' ' || i == (len-1)) {
if (i == (len-1)) {
i = len;
}
int end = (start + i)/2;
for (int j = start; j < end; j++) {
char c = buf[j];
int pos = (start + i) - j - 1;
buf[j] = buf[pos];
buf[pos] = c;
}
start = i + 1;
}
}
return new String(buf);
}
【讨论】：
简单的方法：
String reverseString(String string)
{
String newString = "";
for(int x = string.length() - 1; x > -1; x ++)
newString += string.charAt(x);
return newString;
}
【讨论】：