字符串(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);

}

import java.util.Scanner;

public class Test {

    public static void main(String[] args){
        Scanner input = new Scanner (System.in);
        String word = input.next();
        String reverse = "";
        for(int i=word.length()-1; i>=0; i--)
            reverse += word.charAt(i);
        System.out.println(reverse);        
    }
}

如果你想使用一个简单的for循环!

简单的回答是，由于“代理对”问题，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，但这超出了问题的范围。

蓝

    public String reverse(String s) {

        String reversedString = "";
        for(int i=s.length(); i>0; i--) {
            reversedString += s.charAt(i-1);
        }   

        return reversedString;
    }

下面是一个低级的解决方案:

import java.util.Scanner;

public class class1 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String inpStr = in.nextLine();
        System.out.println("Original String :" + inpStr);
        char temp;
        char[] arr = inpStr.toCharArray();
        int len = arr.length;
        for(int i=0; i<(inpStr.length())/2; i++,len--){
            temp = arr[i];
            arr[i] = arr[len-1];
            arr[len-1] = temp;
        }

        System.out.println("Reverse String :" + String.valueOf(arr));
    }
}

以上所有的解决方案都太好了，但在这里，我正在使用递归编程制作反向字符串。

这对于寻找递归方法做反向字符串的人是有帮助的。

public class ReversString {

public static void main(String args[]) {
    char s[] = "Dhiral Pandya".toCharArray();
    String r = new String(reverse(0, s));
    System.out.println(r);
}

public static char[] reverse(int i, char source[]) {

    if (source.length / 2 == i) {
        return source;
    }

    char t = source[i];
    source[i] = source[source.length - 1 - i];
    source[source.length - 1 - i] = t;

    i++;
    return reverse(i, source);

}

}