Java实现字符串反转的8种方法

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