关于字符串反转和数组反转的问题

import java.util.Stack;

public class StringInverse {
public static void main(String[] args) {
System.out.println(reverse7("abcde"));
}
//方式一
public static String reverse1(String s) {
int length = s.length();
if (length <= 1)
return s;
String left = s.substring(0, length / 2);//ab
String right = s.substring(length / 2, length);//de
return reverse1(right) + reverse1(left);//此处用到了递归!!!
}
//方式二
public static String reverse2(String s) {
int length = s.length();
String reverse = "";//空字符串
for (int i = 0; i < length; i++)
reverse = s.charAt(i) + reverse;//reverse放在后面
//charAt()返回的是一个char
return reverse;
}
//方式三
public static String reverse3(String s) {
char[] array = s.toCharArray();
String reverse = "";//空字符串
for (int i = array.length - 1; i >= 0; i--)
reverse += array[i];
//reverse放在前面
return reverse;
}
//方式四
public static String reverse4(String s) {
//JDK提供的API
return new StringBuffer(s).reverse().toString();
}
//方式五
public static String reverse5(String str) {
//把字符串编程一个字符数组,利用数组的下标来更换字符的位置.
char[] s = str.toCharArray();
//返回值是char[] toCharArray()将此字符串转换为一个新的字符数组。
int n = s.length - 1;
int halfLength = n / 2;
for (int i = 0; i <= halfLength; i++) {
char temp = s[i];
s[i] = s[n - i];
s[n - i] = temp;
}
//利用String(char[])这个构造方法.
return new String(s);
}
//方式六
public static String reverse6(String s) {
char[] str = s.toCharArray();
int begin = 0;
int end = s.length() - 1;
while (begin < end) {
//同一个数字或者字符串等异或两次还是这个对象.下边的操作就是对str[begin]和str[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 String reverse7(String s) {
char[] str = s.toCharArray();
Stack<Character> stack = new Stack<Character>();
for (int i = 0; i < str.length; i++)
stack.push(str[i]);
String reversed = "";
for (int i = 0; i < str.length; i++)
reversed += stack.pop();
//pop()移除堆栈顶部的对象，并作为此函数的值返回该对象。
return reversed;
}
}

import java.lang.reflect.Array;

public class ArrayInverse {

public static void main(String[] args) {
int[] myarray = { 1, 2, 3 };
int[] newarray = invertArray(myarray);

for (int i = 0; i < newarray.length; i++) {
System.out.print(newarray[i] + " ");
}
}

/**
* 反转数组
*
*/
public static <T> T invertArray(T array) {
int len = Array.getLength(array);
// 获取泛型的类型(既数组的类型)
Class<?> classz = array.getClass().getComponentType();
// newInstance(Class<?> componentType,int length)
// 创建一个具有指定的组件类型和长度的新数组。调用此方法等效于创建如下数组：
Object dest = Array.newInstance(classz, len);

// arraycopy()从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
System.arraycopy(array, 0, dest, 0, len);

Object temp;

for (int i = 0; i < (len / 2); i++) {
temp = Array.get(dest, i);// get(Object array, int index)返回指定数组对象中索引组件的值。
Array.set(dest, i, Array.get(dest, len - i - 1));
Array.set(dest, len - i - 1, temp);
}
return (T) dest;
}
}