java - 反转整数字符串，而不反转整数本身

Question

我正在尝试使函数反转一串整数，但我只能使用我找到的以下代码完全镜像它。（我想将它从字符串转换为没有数组或列表的字符串，最好是递归的）

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

}

例如，当我真正想要 (41 2 1) 时， (1 2 41) 返回 (14 2 1)。我希望Java在遇到空格（或任何非整数）时开始反转并保持整数本身不变。

Answer 1

它可以像这样简单。

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

Answer 2

其中的另一种解决方案

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 3

另一个使用Tail 调用 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 4

您还可以使用 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 5

非递归，番石榴存在。

  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 6

如果您对递归不特别感兴趣，则以下解决方案将起作用。

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

Answer 7

您的函数的修改版本，使用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 8

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

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