如何在 Java 中反转字符串

How to reverse String in place in Java

提问by Vikas Suryawanshi

How to reverse String in place in Java

如何在 Java 中反转字符串

input String : 1234 Output Should : 4321

输入字符串：1234 输出应该：4321

what i have tried.

我试过的。

public static void main(String args[]) 
{ 
 String number = "1234"; 
 System.out.println("original String: " + number); String reversed = inPlaceReverse(number);
 System.out.println("reversed String: " + reversed);
}



public static String inPlaceReverse(final String input) 
{
   final StringBuilder builder = new StringBuilder(input); 
   int length = builder.length();
   for (int i = 0; i < length / 2; i++)
   {
      final char current = builder.charAt(i); 
      final int otherEnd = length - i - 1;
      builder.setCharAt(i, builder.charAt(otherEnd)); // swap 
      builder.setCharAt(otherEnd, current); 
   }
 return builder.toString(); 
}

i am getting answer like: reversed String: 4231 as i expected 4321.

我得到的答案是：反转字符串：4231 正如我所期望的 4321。

回答by Davide Spataro

If your teacher wants to see your work then you should manipulate the chars directly. Something like the following should be enough to let you spot the mistake:

如果你的老师想看你的作品，那么你应该直接操作字符。类似以下内容应该足以让您发现错误：

public static String reverse(String orig)
{
    char[] s = orig.toCharArray();
    final int n = s.length;
    final int halfLength = n / 2;
    for (int i=0; i<halfLength; i++)
    {
        char temp = s[i];
        s[i] = s[n-1-i];
        s[n-1-i] = temp;
    }
    return new String(s);
}

回答by Mistalis

It can be even simpler using StringBuilder's reverse()function:

使用StringBuilder 的reverse()函数可以更简单：

public static String inPlaceReverse(String input) {
   StringBuilder builder = new StringBuilder(input); 
   return builder.reverse().toString();
}

回答by gati sahu

public static String inPlaceReverse(String number) {
        char[] ch = number.toCharArray();
        int i = 0;
        int j = number.length()-1;
        while (i < j) {
            char temp = ch[i];
            ch[i] = ch[j];
            ch[j] = temp;
            i++;
            j--;
        }
        return String.valueOf(ch);
    }

回答by Avijit Karmakar

1. Using Character Array:

1. 使用字符数组：

public String reverseSting(String inputString) {
    char[] inputStringArray = inputString.toCharArray();
    String reverseString = "";
    for (int i = inputStringArray.length - 1; i >= 0; i--) {
        reverseString += inputStringArray[i];
    }
    return reverseString;
}

2. Using StringBuilder:

2. 使用 StringBuilder：

public String reverseSting(String inputString) {
    StringBuilder stringBuilder = new StringBuilder(inputString);
    stringBuilder = stringBuilder.reverse();
    return stringBuilder.toString();
}

OR

或者

return new StringBuilder(inputString).reverse().toString();

回答by Soudipta Dutta

This is an interview question. Reverse a String in place :

这是一道面试题。原地反转字符串：

public class Solution4 {
    public static void main(String[] args) {

        String a = "Protijayi";

        System.out.println(reverse(a)); //iyajitorP
    }

    private static String reverse(String a) {
           char[] ca = a.toCharArray();
           int start = 0 ; int end = a.length()-1;
           while(end > start) {
               swap(ca,start,end);
               start++;
               end--;
           }//while

        return new String(ca);
    }

    private static void swap(char[] ca, int start, int end) {
        char t = ca[start];
        ca[start] = ca[end];
        ca[end] = t ;
        }
}

回答by Yauhen

Mind also, that you can avoid using additional memory during the swap, though having some extra computation.

还要注意，您可以避免在交换期间使用额外的内存，尽管需要一些额外的计算。

public class StringReverser {

public static String reverseStringInPlace(String toReverse) {

    char[] chars = toReverse.toCharArray();

    int inputStringLength = toReverse.length();

    for (int i = 0; i < inputStringLength / 2; i++) {
        int toMoveBack = toReverse.charAt(i);
        int toMoveForward = toReverse.charAt(inputStringLength - i - 1);

        //swap
        toMoveForward = toMoveBack - toMoveForward;
        toMoveBack -= toMoveForward;
        toMoveForward += toMoveBack;

        chars[i] = (char) toMoveBack;
        chars[inputStringLength - i - 1] = (char) toMoveForward;
    }

    return String.valueOf(chars);

}

public static void main(String[] args) {

    System.out.println(reverseStringInPlace("asd0")); // output: 0dsa
    System.out.println(reverseStringInPlace("sd0")); // output: 0ds
    System.out.println(reverseStringInPlace("")); // output: empty
    System.out.println(reverseStringInPlace("-")); // output: -
    System.out.println(reverseStringInPlace("ABD+C")); // output: C+DBA
    System.out.println(reverseStringInPlace("勒")); // output: 勒
    System.out.println(reverseStringInPlace("分歧。")); // output: 。歧分
    System.out.println(reverseStringInPlace("Marítimo")); // output: omitíraM
} 
}

Relevant to swap discussion can be found here: How to swap two numbers without using temp variables or arithmetic operations?

可以在此处找到与交换讨论相关的内容： 如何在不使用临时变量或算术运算的情况下交换两个数字？

回答by Joseph

Convert the string to a character array first and then use recursion.

首先将字符串转换为字符数组，然后使用递归。

public void reverseString(char[] s) {
    helper(0, s.length - 1, s);
}

private void helper(int left, int right, char[] s){
    if(left >= right) {
        return;
    }

    char temp = s[left];
    s[left++] = s[right];
    s[right--] = temp;
    helper(left, right, s);
}

So with the input [1,2,3,4], the helper function will be called as follows :

因此，对于输入[1,2,3,4]，辅助函数将按如下方式调用：

1. helper(0, 3, [1,2,3,4]), Swap 1 and 4
2. helper(1, 2, [1,2,3,4]), Swap 2 and 3
3. helper(2, 1, [1,2,3,4]) Terminates, left is now greater than right