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）当我真正想要（41 2 1）时返回（14 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();     
    }

反转整数串而不反转整数本身

8 个答案: