反转字符串，如输入“ABC”，输出“CBA”

搜集的java字符串反转方法，一般用于面试，项目中用的很少···

[java]  view plain  copy

1. package com.Reverse;  
2.    
3. import java.util.Stack;  
4.    
5. /** 
6.  * 8 种字符串反转的方法, 其实可以是9种方法，第9种是使用StringBuffer和StringBuilder中实现的方法 
7.  */  
8. public class StringReverse {  
9.    
10.     /** 
11.      * 二分递归地将后面的字符和前面的字符连接起来。 
12.      * 
13.      * @param s 
14.      * @return 
15.      */  
16.     public static String reverse1(String s) {  
17.         int length = s.length();  
18.         if (length <= 1)  
19.             return s;  
20.         String left = s.substring(0, length / 2);  
21.         String right = s.substring(length / 2, length);  
22.         return reverse1(right) + reverse1(left);  
23.     }  
24.        
25.     /** 
26.      * 取得当前字符并和之前的字符append起来 
27.      * @param s 
28.      * @return 
29.      */  
30.     public static String reverse2(String s) {  
31.         int length = s.length();  
32.         String reverse = "";  
33.         for (int i=0; i<length; i++)  
34.             reverse = s.charAt(i) + reverse;  
35.         return reverse;  
36.     }  
37.        
38.     /** 
39.      * 将字符从后往前的append起来 
40.      * @param s 
41.      * @return 
42.      */  
43.     public static String reverse3(String s) {  
44.         char[] array = s.toCharArray();  
45.         String reverse = "";  
46.         for (int i = array.length - 1; i >= 0; i--) {  
47.             reverse += array[i];  
48.         }  
49.         return reverse;  
50.     }  
51.        
52.     /** 
53.      * 和StringBuffer()一样，都用了Java自实现的方法，使用位移来实现 
54.      * @param s 
55.      * @return 
56.      */  
57.     public static String reverse4(String s) {  
58.         return new StringBuilder(s).reverse().toString();  
59.     }  
60.        
61.     /** 
62.      * 和StringBuilder()一样，都用了Java自实现的方法，使用位移来实现 
63.      * @param s 
64.      * @return 
65.      */  
66.     public static String reverse5(String s) {  
67.         return new StringBuffer(s).reverse().toString();  
68.     }  
69.        
70.     /** 
71.      * 二分交换，将后面的字符和前面对应的那个字符交换 
72.      * @param s 
73.      * @return 
74.      */  
75.     public static String reverse6(String s) {  
76.         char[] array = s.toCharArray();  
77.         int end = s.length() - 1;  
78.         int halfLength = end / 2;  
79.         for (int i = 0; i <= halfLength; i++) {  
80.             char temp = array[i];  
81.             array[i] = array[end-i];  
82.             array[end-i] = temp;  
83.         }  
84.            
85.         return new String(array);  
86.     }  
87.        
88.     /** 
89.      * 原理是使用异或交换字符串 
90.      * a=a^b; 
91.      * b=b^a; 
92.          * a=b^a; 
93.      * 
94.      * @param s 
95.      * @return 
96.      */  
97.     public static String reverse7(String s) {  
98.         char[] array = s.toCharArray();  
99.              
100.           int begin = 0;  
101.           int end = s.length() - 1;  
102.              
103.           while (begin < end) {  
104.                array[begin] = (char) (array[begin] ^ array[end]);  
105.                array[end] = (char) (array[end] ^ array[begin]);  
106.                array[begin] = (char) (array[end] ^ array[begin]);  
107.                begin++;  
108.                end--;  
109.           }  
110.              
111.           return new String(array);  
112.     }  
113.        
114.     /** 
115.      * 基于栈先进后出的原理 
116.      * 
117.      * @param s 
118.      * @return 
119.      */  
120.     public static String reverse8(String s) {  
121.         char[] array = s.toCharArray();  
122.         Stack<Character> stack = new Stack<Character>();  
123.         for (int i = 0; i < array.length; i++)  
124.             stack.push(array[i]);  
125.    
126.         String reverse = "";  
127.         for (int i = 0; i < array.length; i++)  
128.             reverse += stack.pop();  
129.              
130.         return reverse;  
131.     }  
132.        
133.     public static void main(String[] args) {  
134.         System.out.println(reverse1("ABC"));  
135.         System.out.println(reverse2("ABC"));  
136.         System.out.println(reverse3("ABC"));  
137.         System.out.println(reverse4("ABC"));  
138.         System.out.println(reverse5("ABC"));  
139.         System.out.println(reverse6("ABC"));  
140.         System.out.println(reverse7("ABC"));  
141.         System.out.println(reverse8("ABC"));  
142.     }  
143. }