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

 1 import java.util.Stack;
 2 
 3 public class StringInverse {
 4     public static void main(String[] args) {
 5         System.out.println(reverse7("abcde"));
 6     }
 7     //方式一
 8     public static String reverse1(String s) {
 9         int length = s.length();
10         if (length <= 1)
11             return s;
12         String left = s.substring(0, length / 2);//ab
13         String right = s.substring(length / 2, length);//de
14         return reverse1(right) + reverse1(left);//此处用到了递归!!!
15     }
16     //方式二
17     public static String reverse2(String s) {
18         int length = s.length();
19         String reverse = "";//空字符串
20         for (int i = 0; i < length; i++)
21             reverse = s.charAt(i) + reverse;//reverse放在后面
22         //charAt()返回的是一个char
23         return reverse;
24     }
25     //方式三
26     public static String reverse3(String s) {
27         char[] array = s.toCharArray();
28         String reverse = "";//空字符串
29         for (int i = array.length - 1; i >= 0; i--)
30             reverse += array[i];
31         //reverse放在前面
32         return reverse;
33     }
34     //方式四
35     public static String reverse4(String s) {
36         //JDK提供的API
37         return new StringBuffer(s).reverse().toString();
38     }
39     //方式五
40     public static String reverse5(String str) {
41         //把字符串编程一个字符数组,利用数组的下标来更换字符的位置.
42         char[] s = str.toCharArray();
43         //返回值是char[] toCharArray()将此字符串转换为一个新的字符数组。
44         int n = s.length - 1;
45         int halfLength = n / 2;
46         for (int i = 0; i <= halfLength; i++) {
47             char temp = s[i];
48             s[i] = s[n - i];
49             s[n - i] = temp;
50         }
51         //利用String(char[])这个构造方法.
52         return new String(s);
53     }
54     //方式六
55     public static String reverse6(String s) {
56         char[] str = s.toCharArray();
57         int begin = 0;
58         int end = s.length() - 1;
59         while (begin < end) {
60             //同一个数字或者字符串等异或两次还是这个对象.下边的操作就是对str[begin]和str[end]调换位置.
61             str[begin] = (char) (str[begin] ^ str[end]);
62             str[end] = (char) (str[begin] ^ str[end]);
63             str[begin] = (char) (str[end] ^ str[begin]);
64             begin++;
65             end--;
66         }
67         return new String(str);
68     }
69     //方式七
70     public static String reverse7(String s) {
71         char[] str = s.toCharArray();
72         Stack<Character> stack = new Stack<Character>();
73         for (int i = 0; i < str.length; i++)
74             stack.push(str[i]);
75         String reversed = "";
76         for (int i = 0; i < str.length; i++)
77             reversed += stack.pop();
78         //pop()移除堆栈顶部的对象，并作为此函数的值返回该对象。
79         return reversed;
80     }
81 }

 1 import java.lang.reflect.Array;
 2 
 3 public class ArrayInverse {
 4 
 5     public static void main(String[] args) {
 6         int[] myarray = { 1, 2, 3 };
 7         int[] newarray = invertArray(myarray);
 8 
 9         for (int i = 0; i < newarray.length; i++) {
10             System.out.print(newarray[i] + " ");
11         }
12     }
13 
14     /**
15      * 反转数组
16      * 
17      */
18     public static <T> T invertArray(T array) {
19         int len = Array.getLength(array);
20         // 获取泛型的类型(既数组的类型)
21         Class<?> classz = array.getClass().getComponentType();
22         // newInstance(Class<?> componentType,int length)
23         // 创建一个具有指定的组件类型和长度的新数组。调用此方法等效于创建如下数组：
24         Object dest = Array.newInstance(classz, len);
25 
26         // arraycopy()从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
27         System.arraycopy(array, 0, dest, 0, len);
28 
29         Object temp;
30 
31         for (int i = 0; i < (len / 2); i++) {
32             temp = Array.get(dest, i);// get(Object array, int index)返回指定数组对象中索引组件的值。
33             Array.set(dest, i, Array.get(dest, len - i - 1));
34             Array.set(dest, len - i - 1, temp);
35         }
36         return (T) dest;
37     }
38 }