看一下StringBuffer下的Java 6 API

String s = "sample";
String result = new StringBuffer(s).reverse().toString();

下面是一个使用递归的例子:

public void reverseString() {
    String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    String reverseAlphabet = reverse(alphabet, alphabet.length()-1);
}

String reverse(String stringToReverse, int index){
    if(index == 0){
        return stringToReverse.charAt(0) + "";
    }

    char letter = stringToReverse.charAt(index);
    return letter + reverse(stringToReverse, index-1);
}

这招对我很管用

public static void main(String[] args) {

    String text = "abcdefghijklmnopqrstuvwxyz";

    for (int i = (text.length() - 1); i >= 0; i--) {
        System.out.print(text.charAt(i));
    }
}

对于不允许StringBuilder或StringBuffer的Online Judges问题，可以使用char[]，如下所示:

public static String reverse(String input){
    char[] in = input.toCharArray();
    int begin=0;
    int end=in.length-1;
    char temp;
    while(end>begin){
        temp = in[begin];
        in[begin]=in[end];
        in[end] = temp;
        end--;
        begin++;
    }
    return new String(in);
}

字符串(String s) {

    String reversedWords = "";

    if(s.length()<=0) {
        return reversedWords;
    }else if(s.length() == 1){
        if(s == " "){
            return "";
        }
        return s;
    }

    char arr[] = s.toCharArray();
    int j = arr.length-1;
    while(j >= 0 ){
        if( arr[j] == ' '){
            reversedWords+=arr[j];
        }else{
            String temp="";
            while(j>=0 && arr[j] != ' '){
                temp+=arr[j];
                j--;
            }
            j++;
            temp = reverseWord(temp);
            reversedWords+=temp;
        }
        j--;

    }

    String[] chk = reversedWords.split(" ");

    if(chk == null || chk.length == 0){
        return "";
    }

    return reversedWords;



}

public String reverseWord(String s){

    char[] arr = s.toCharArray();

    for(int i=0,j=arr.length-1;i<=j;i++,j--){
        char tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    return String.valueOf(arr);

}

简单的回答是，由于“代理对”问题，Java没有提供反转String的通用解决方案，您必须考虑到这个问题。

如果要求保证它适用于所有Unicode和所有语言(包括Welsh:)，那么您必须自己编写。只需将字符串作为代码点进行就地数组交换:

public static String reverse(String str)
{
        // You get what you ask for ;)
        if (str == null) return null;

        // str.length() is equal to the number of unicode code points in a string
        if (str.isEmpty() || str.length() == 1) return str;

        final int[] codePoints = str.codePoints().toArray();
        final int len = codePoints.length;

        // swap in place
        for(int i = 0; i < codePoints.length/2; i++)
        {
            int tmp = codePoints[i];
            codePoints[i] = codePoints[len-i-1];
            codePoints[len-i-1] = tmp;
        }

        return new String(codePoints,0,len);
}

如果您通过使用String.getBytes()来做到这一点，那么所有的字节都将被反转，这将反转所有的UTF-8编码，并且任何使用不是int编码点的字符的尝试都将失败，任何“星体平面”编码点(BMP之外的那些)。

作为一个通解，这是相当有效的，但它非常简单，并保证适用于任何字符串，这可能是你想要的“通解”。

唯一的问题是，如果你从UTF8/16编码文件中读取字符串，你可能在开始时有一个BOM，但这超出了问题的范围。

蓝