反向字符串的整数，而不扭转整数本身

Question

我想使一个函数反向整数字符串，但我只能够完全镜像它，与我发现的下面一段代码。 （我想不用阵列或列表它从字符串转换为字符串，优选递归地）

static String reverseMe(String s) { 
if(s.length() == 0) 
    return ""; 
return s.charAt(s.length() - 1) + reverseMe(s.substring(0,s.length()-1)); 

}

因此，例如，（1 2 41）返回（14 2 1）当我真想（41 2 1）。我希望有一种方式让Java在遇到空格（或任何非整数）时开始反转，并将整数本身保持原样。

Answer 1

一种改进的使用String#lastIndexOf你的函数的版本：

String reverseMe(String s) 
{ 
    if (s.length() == 0) 
    return ""; 
    int index = s.lastIndexOf(" "); 
    if (index == -1) // not found, thus just return the string 
    return s; 
    else // found, thus concat last part with recursive call 
    return s.substring(index + 1) + " " + reverseMe(s.substring(0, index)); 
} 

或者你也可以反向使用String#split用空格，只是循环，分离出通过并连接。

String reverse(String s) 
{ 
    String reversed = ""; 
    String[] split = s.split(" "); 
    reversed = split[split.length-1]; 
    for (int i = split.length-2; i >= 0; i--) 
    { 
    reversed += " " + split[i]; 
    } 
    return reversed; 
} 

虽然StringBuilder将使一个更有效的选择，因为它不要求所有的字符串复制。

Answer 2

如果你想递归地做，它会做到这一点！

public static String reverseIt(final String inp,final int lastIndex,String out) 
{ 
    int i=lastIndex; 
    while(inp.charAt(i)!=' ' && i!=-1){i--;if(i==-1)break;} 
    out+=(inp.substring(i+1,lastIndex+1));if(i!=-1)out+=" "; 
    if(lastIndex!=0)return reverseIt(inp,i-1,out); 
    else return out; 
} 

现在，您可以把它作为

reverseIt(input,input.length-1,output); 

Answer 3

您还可以使用StringTokenized

StringTokenizer st = new StringTokenizer("1 2 41"); 
    StringBuilder sb = new StringBuilder(); 
    while (st.hasMoreTokens()) { 
     if (sb.length() > 0) { 
      sb.insert(0, ' '); 
     } 
     sb.insert(0, st.nextToken()); 
    } 
    System.out.println(sb.toString()); 

Answer 4

彼此解决这些

static String reverseMe(String s) { 
     if(s.length() == 0) 
      return ""; 
     String sa[] = s.split(" "); 
     List<String> newlist = Arrays.asList(sa); 
     Collections.reverse(newlist); 
     return newlist.toString(); 

} 

Answer 5

中它可以是一样简单这个。

String num="1 2 41"; 
    StringTokenizer sTok=new StringTokenizer(num, " "); 
    String revnum=""; 
    while(sTok.hasMoreTokens()) 
    { 
     revnum=sTok.nextToken()+" "+revnum; 
    } 
    System.out.println(revnum); 

Answer 6

另一个使用Tail call recursion的递归变体。

public static String reverseMe(String s) { 
    StringBuilder sb = new StringBuilder(); 
    return reverseMe(s.split(" "), sb); 
} 

public static String reverseMe(String[] s, StringBuilder sb) { 
    if (s.length == 0) { 
     return sb.toString().trim(); 
    } else { 
     return reverseMe(Arrays.copyOfRange(s, 1, s.length), sb.insert(0, " ").insert(0, s[0])); 
    } 
} 

Answer 7

非递归，番石榴礼物。

String input = "123 456 789 tt 012"; 
    Iterable<String> tokens = Splitter.on(Pattern.compile("[^\\d]")).omitEmptyStrings().split(input); 
    for(String token: tokens){ 
     StringBuilder builder = new StringBuilder(token); 
     System.out.println(builder.reverse().toString()); 
    } 

或者不番石榴：

String input = "123 456 789 tt 012"; 
    String tokens [] = input.split("[^\\d]+"); 
    for(String token:tokens){ 
     StringBuilder builder = new StringBuilder(token); 
     System.out.println(builder.reverse().toString()); 
    } 

Answer 8

如果你没有特别递归，下面的解决方案是可行的。

static String reversMe(String str) { 

    StringBuffer strBuf = new StringBuffer(); 

    String strArray = str.split(" "); 


    for(int i = strArray.length();i>=0; i--) { 

     strBuf.append(strArray[i]).append(" "); 

    } 

    return strBuf.toString().trim();  
    }