字符串反转的所有代码方法

package 编程之法;


import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
/**
 * 三步翻转法
 * @author Administrator
 *
 */


public class 字符串旋转 {


/**
* 将字符串反转,传入的是字符数组，则void，传入的是字符串，则要返回字符串
* @param ch
* @param begin
* @param end
*/
public static void reverseStr0(char[] ch,int begin,int end)
{
while(begin <end)
{
char temp = ch[begin];
ch[begin++] = ch[end];
ch[end--] = temp;


}
}
/**
* 将字符串按照指定个数反转
* @param str
* @param n
* @return
*/
public static char[] reverseStrN(String str,int n)
{
char[] ch = str.toCharArray();


//编程考虑三层测试，功能测试，边界测试，非法输入测试
//如果移动的字符个数超过了字符串的长度呢
int len = ch.length;
if(n > len)
n = n%len;
//若只有一个字符，就不让进入函数，提高效率
if(len == 1)
return ch;
reverseStr0(ch,0,n-1);
reverseStr0(ch,n,len-1);
reverseStr0(ch,0,len-1);
return ch;
}
/**
* 7种字符串反转
*/


//1. 递归反转字符串
public static String reverseStr1(String str)
{
int len = str.length();
//递归必须有结束条件，不然会栈溢出错误
if(len <= 1)
return str;


String left = str.substring(0,len/2);
String right = str.substring(len/2,len);
return reverseStr1(right)+reverseStr1(left);
}
//2. 字符串String拼接，不推荐
public static String reverseStr2(String s) {
int length = s.length();
String reverse = "";
for (int i = 0; i < length; i++)
reverse = s.charAt(i) + reverse;//及其不推荐，每一次+的时候都会申请新的内存空间，差评
return reverse;
}




//3. 跟2差不多，不推荐,用StringBuilder改进
public static String reverseStr3(String str)
{
// String res = "";//跟String有关的拼接操作都不推荐
StringBuilder sb = new StringBuilder();
char[] ch = str.toCharArray();
for(int i = ch.length-1;i>=0;i--)
{
// res = res+ch[i];
sb.append(ch[i]);
}
// return res;
return sb.toString();
}


//4. 用jdk封装的接口
public static String reverseStr4(String str)
{
return new StringBuilder(str).reverse().toString();


}


//5. 一想到字符串反转，就想到堆栈stack
public static String reverseStr5(String str)
{
char[] ch = str.toCharArray();
Stack<Character> stack  = new Stack<Character>();
StringBuilder sb = new StringBuilder();
for(int i = 0;i<ch.length;i++)
{
stack.push(ch[i]);
}
while(!stack.isEmpty())
{
sb.append(stack.pop());
}
return sb.toString();


}
//6. 这里练习一下队列，突然想到先进先出
public static String reverseStr6(String str)
{
char[] ch = str.toCharArray();
Queue<Character> queue = new LinkedList<Character>();
StringBuilder sb = new StringBuilder();
for(int i = 0;i<ch.length;i++)
{
queue.offer(ch[i]);
}
while(!queue.isEmpty())
{
sb.append(queue.poll());
}
return sb.toString();
}
//7. 新型栈
public static String reverseStr7(String str)
{
char[] ch = str.toCharArray();
// Deque<Character> deque = new ArrayDeque<Character>();
// Deque<Character> deque = new LinkedList<Character>();
LinkedList<Character> list = new LinkedList<Character>();
StringBuilder sb = new StringBuilder();
for(int i = 0;i<ch.length;i++)
{
// deque.addFirst(ch[i]);
// deque.push(ch[i]);
list.push(ch[i]);
}
while(!list.isEmpty())
{
// sb.append(deque.removeFirst());
// sb.append(deque.pop());
sb.append(list.pop());
}
return sb.toString();


}


//8. 推荐，效率源码
public static String reverseStr8(String orig) {
char[] s = orig.toCharArray();
int n = s.length - 1;
int halfLength = n / 2;
for (int i = 0; i <= halfLength; i++) {//n/2
char temp = s[i];
s[i] = s[n - i];
s[n - i] = temp;
}
return new String(s);
}


//9.更快，异或操作
public static String reverseStr9(String s) {


char[] str = s.toCharArray();


int begin = 0;
int end = s.length() - 1;


while (begin < end) {
str[begin] = (char) (str[begin] ^ str[end]);
str[end] = (char) (str[begin] ^ str[end]);
str[begin] = (char) (str[end] ^ str[begin]);
begin++;
end--;
}
return new String(str);
}


public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
char[] ch = reverseStrN(str,3);
int i = 0;
while(i < ch.length)
{
System.out.print(ch[i]+" ");
i++;
}
System.out.print(reverseStr9(str));//字符串反转测试
}
































}