反转java中的字符串

Question

反转java中字符串的代码： 注意：一个或两个附加变量都可以。数组的额外副本不是。

现在我实现了一个算法中，如下所示：

public static void removeDuplicates(char[] str) { 
    if (str == null) return; 
    int len = str.length; 
    if (len < 2) return; 

    int tail = 1; 

    for (int i = 1; i < len; ++i) { 
    int j; 
    for (j = 0; j < tail; ++j) { 
     if (str[i] == str[j]) break; 
    } 
    if (j == tail) { 
     str[tail] = str[i]; 
     ++tail; 
    } 
    } 
    str[tail] = something //something to mark end of char array eg '\0' as we have in C 
} 

Answer 1

尝试阿帕奇百科全书StringUtils类：

http://commons.apache.org/lang/api-2.3/org/apache/commons/lang/StringUtils.html

它有一个很大的反向功能：

static String reverse(String str); 

Answer 2

也许像这样？

string input = "ABCD"; 
string result = ""; 
for (int i = input.length-1; i >= 0; i--) 
{ 
    result = result + input[i]; 
} 

Answer 3

不能在没有额外空间的情况下在Java中反转String，因为String在Java中是不可变的。
似乎是一个有趣的问题......
如果你想翻领的char []应该是这样的：

char[] str = "abcdefg".toCharArray(); 
    int len = str.length; 
    int n = len/2; 
    for (int i = 0;i<n;i++) { 
     char temp = str[i]; 
     str[i] = str[len-1-i]; 
     str[len-1-i] = temp; 
    } 
    System.out.println(str); 

Answer 4

我会做这样的（伪）：

// s is array of char that holds the string 
i=0 
j=s.length - 1 
while (i < j) 
    swap characters at positions i and j 
    i++ 
    j-- 

Answer 5

由于说，反转一个String对象是不可能的，因为Java中的字符串对象是不可变的。

你可以通过使用反射来访问底层数组来避开这个（见下面），但这不可取。

如果我们采取了一个问题，在char[]（或任何其他阵列）的工作，相反，它变得容易：

/** 
* reverses an array by swapping its elements. 
*/ 
public static void reverse(char[] array) { 
    reverse(array, 0, array.length); 
} 

/** 
* reverses a section of an array by swapping its elements. 
* @param start the start of the section, inclusive 
* @param end the end of the section, exclusive 
*/ 
public static void reverse(char[] array, int start, int end) { 
    for(int i = start, j = end-1; i < j; i++, j--) { 
     swap(array, i, j); 
    } 
} 

/** 
* swaps two array elements. 
*/ 
private static void swap(char[] array, int i, int j) { 
    char help = array[i]; 
    array[i] = array[j]; 
    array[j] = help; 
} 

到这一点，我们现在也可以欺骗扭转现有的字符串：

public static void reverse(String s) { 
    Class<String> sClass = String.class; 
    char[] array = (char[])sClass.getDeclaredField("value").get(s); 
    int start = sClass.getDeclaredField("offset").getInt(s); 
    int len = sClass.getDeclaredField("count").getInt(s); 
    reverse(array, start, start+len); 
} 

至于说，这是不可取的，因为整个虚拟机和标准库是基于这样的事实，字符串是不可变的。此外，这里的字段名称取自1.6.0_13 Sun实现，其他虚拟机可能具有其他名称的这些字段，或以另一种方式存储字符串。