Java實現字符串反轉的8種9種方法

/**


*/
package com.wsheng.aggregator.algorithm.string;

import java.util.Stack;
/**

8 種字符串反轉的方法, 其實可以是9種方法，第9種是使用StringBuffer和StringBuilder中實現的方法
@author Josh Wang(Sheng)

@email  swang6@ebay.com
*/
public class StringReverse {
/**

二分遞歸地將后面的字符和前面的字符連接起來。

@param s
@return
*/
public static String reverse1(String s) {
 int length = s.length();
 if (length <= 1)

 return s;

String left = s.substring(0, length / 2);
 String right = s.substring(length / 2, length);
 return reverse1(right) + reverse1(left);
}
/**

取得當前字符并和之前的字符append起來
@param s
@return
*/
public static String reverse2(String s) {
 int length = s.length();
 String reverse = "";
 for (int i=0; i<length; i++)

 reverse = s.charAt(i) + reverse;

return reverse;
}
/**

將字符從后往前的append起來
@param s
@return
*/
public static String reverse3(String s) {
 char[] array = s.toCharArray();
 String reverse = "";
 for (int i = array.length - 1; i >= 0; i--) {

 reverse += array[i];

}
 return reverse;
}
/**

和StringBuffer()一樣，都用了Java自實現的方法，使用位移來實現
@param s
@return
*/
public static String reverse4(String s) {
 return new StringBuilder(s).reverse().toString();
}
/**

和StringBuilder()一樣，都用了Java自實現的方法，使用位移來實現
@param s
@return
*/
public static String reverse5(String s) {
 return new StringBuffer(s).reverse().toString();
}
/**

二分交換，將后面的字符和前面對應的那個字符交換
@param s
@return
*/
public static String reverse6(String s) {
 char[] array = s.toCharArray();
 int end = s.length() - 1;
 int halfLength = end / 2;
 for (int i = 0; i <= halfLength; i++) {

 char temp = array[i];
 array[i] = array[end-i];
 array[end-i] = temp;

}
return new String(array);
}
/**

原理是使用異或交換字符串
a=a^b; 
b=b^a; 

a=b^a;



@param s
@return
*/
public static String reverse7(String s) {
 char[] array = s.toCharArray();
int begin = 0;
   int end = s.length() - 1;
while (begin < end) {

    array[begin] = (char) (array[begin] ^ array[end]);
    array[end] = (char) (array[end] ^ array[begin]);
    array[begin] = (char) (array[end] ^ array[begin]);
    begin++;
    end--;

}
return new String(array);
}
/**

基于棧先進后出的原理

@param s
@return
*/
public static String reverse8(String s) {
 char[] array = s.toCharArray();
 Stack<Character> stack = new Stack<Character>();
 for (int i = 0; i < array.length; i++)

 stack.push(array[i]);


String reverse = "";
 for (int i = 0; i < array.length; i++)

 reverse += stack.pop();


return reverse;
}
public static void main(String[] args) {
 System.out.println(reverse1("Wang Sheng"));
 System.out.println(reverse2("Wang Sheng"));
 System.out.println(reverse3("Wang Sheng"));
 System.out.println(reverse4("Wang Sheng"));
 System.out.println(reverse5("Wang Sheng"));
 System.out.println(reverse6("Wang Sheng"));
 System.out.println(reverse7("Wang Sheng"));
 System.out.println(reverse8("Wang Sheng"));
}
}
</pre> 

 來自：http://josh-persistence.iteye.com/blog/2205772