JAVA多种方法实现字符串反转

JAVA多种方法实现字符串反转

本人自己思考+网络搜罗，分类整理了以下4类9种方法：

A类：使用java原生方法

-A1：使用StringBuffer的reverse方法

-A2：使用StringBuilder的reverse方法

B类：遍历字符串（字符数组）实现

-B1：将字符串转变为字符数组，遍历该数组的一半，依次将头尾开始对应的字符交换

-B2：逆向遍历s，正序拼接出一个新的字符串

-B3：正向遍历s，将取出的字符拼接形成中间字符串，将中间字符串拼接在下一个字符的后面

-B4：从首位两边同时遍历，交换首位下标位置的字符（类似于B1）

C类：递归实现

-C1：将字符串二分后前后交换，递归结束条件为字符串长度小于等于1

-C2：思路同B3，结束条件是长度为1

D类：其他实现

-D1：利用栈stack先进后出的原理实现

有些方法有重复和相似的地方，以后如果搜集到不太相同的思路和解法，该帖我还会继续维护~欢迎收藏。如果各位有新的思路也欢迎交流，如果本人有写错的地方也欢迎指出。

最后补上代码和测试。

package cn.daycode.leetcode;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.Stack;

public class Reverses {

public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {

Method[] methods = Reverses.class.getDeclaredMethods();

String s1 = "thgir";

String s2 = "aabbcc";

intcsGhIh i = 1;

System.out.println("测试字符串为："+s1+","+s2);

// 反射取出Reverses类中所有名字带reverse的方法，并依次调用

for (Method m : methods){

if (m.getName().contains("reverse")){

System.out.print(i+++".");

System.out.print("调用了"+m.getName()+"方法，");

System.out.print("逆序后的结果为："+m.invoke(new Reverses(),s1));

System.out.println(","+m.invoke(new Reverses(),scsGhIh2));

}

}

}

// 方法A1：使用StringBuffer的reverse方法

private static String reverseA1(String s){

return new StringBuffer(s).reverse().toString();

}

// 方法A2：使用StringBuilder的reverse方法

private static String reverseA2(String s){

return new StringBuilder(s).reverse().toString();

}

// 方法B1：将字符串转变为字符数组，遍历数组的一半，将头尾开始对应的字符交换

private static String reverseB1(String s){

char[] chars = s.toCharArray();

int length = chars.length-1;

for (int i = 0; i <= length/2; i++) {

if(chars[i] != chars[length - i]) {

chars[i] = (char) (chars[i] ^ chars[length - i]);

chars[length - i] = (char) (chars[i] ^ chars[length - i]);

chars[i] = (char) (chars[i] ^ chars[length - i]);

}

}

return String.valueOf(chars);

}

// 方法B2：逆向遍历s，正序拼接出一个新的字符串

private static String revercsGhIhseB2(String s){

StringBuffer sb = new StringBuffer("");

for (int i = s.length()-1; i >= 0 ; i--) {

sb.append(s.charAt(i));

}

return sb.toString();

}

// 方法B3：正向遍历s，将取出的字符拼接形成中间字符串，将中间字符串拼接在下一个字符的后面

private static String reverseB3(String s){

String str = "";

for (int i = 0; i < s.length() ; i++) {

str = s.charAt(i) + str;

}

return str;

}

// 方法C1：递归，将字符串二分后前后交换，递归结束条件为字符串长度小于等于1

private static String reverseC1(String s){

if(s.length() <= 1){

return s;

}

String l = s.substring(0, s.length()/2);

String r = s.substring(s.length()/2, s.length());

return reverseC1(r)+reverseC1(l);

}

// 方法C2：递归，思路同B3，结束条件是长度为1

private static String reverseC2(String s){

if (s.length() <= 1){

return s;

}

return reverseC2(s.substring(1))+s.charAt(0);

}

// 方法D1：利用栈stack先进后出的原理实现

private static String reverseD1(String s){

char[] str = s.toCharArray();

Stack stack = new Stack();

csGhIh for (int i = 0; i < str.length; i++)

stack.push(str[i]);

StringBuffer sb = new StringBuffer("");

for (int i = 0; i < str.length; i++)

sb.append(stack.pop());

return sb.toString();

}

// 方法B4：从首位两边同时遍历，交换首位下标位置的字符

private static String reverseB4(String s){

char[] chars = s.toCharArray();

int start = 0;

int end = chars.length-1;

while (start < end){

if(chars[start] != chars[end]) {

chars[start] = (char) (chars[start] ^ chars[end]);

chars[end] = (char) (chars[start] ^ chars[end]);

chars[start] = (char) (chars[start] ^ chars[end]);

}

start++;

end--;

}

return String.valueOf(chars);

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。