关于字符串反转和数组反转的问题详解编程语言

 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 }