反轉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實現，其他虛擬機可能具有其他名稱的這些字段，或以另一種方式存儲字符串。