给定一个数组，对其进行反转。  如下：

{1,2,3,4,5,6}
-->
{6,5,4,3,2,1};

刚开始的想法是新建一个数组，从旧数组的最后一个值遍历到最前一个值赋值给新数组。
后来大拍脑袋，其实不就是以中间为轴，轴对称的两个数交换吗~~~~

1. class  ArrayTest {   
   
2.         public static void printArray(int[] arr)  {
   
3.                 System.out.print("[");   
   
4.                 for(int x=0; x<arr.length; x++)   
   
5.                 {     
   
6.                         if(x!=arr.length-1)      
   
7.                         System.out.print(arr[x]+", ");   
   
8.                         else      
   
9.                         System.out.println(arr[x]+"]");   
   
10.                 }  
    
11.         }   
    
12.        
    
13.         public static void main(String[] args)   
    
14.         {   
    
15.                 int[] arr = {4,1,8,7,3,8,2};   
    
16.                 printArray(arr);   
    
17.                 reverseArray(arr);   
    
18.                 printArray(arr);  
    
19.         }   
    
20.        
    
21.         public static void reverseArray(int[] arr)  {
    
22.                 for(int start=0,end=arr.length-1; start<end; start++,end--)   
    
23.                 {     
    
24.                         swap(arr,start,end);   
    
25.                 }  
    
26.         }  
    
27.        
    
28.         public static void swap(int[] arr,int a,int b)  {
    
29.                 int temp = arr[a];  
    
30.                 arr[a] = arr[b];   
    
31.                 arr[b] = temp;  
    
32.         }
    
33. }

复制代码

这么多知识点 都记混了

我也搞了个，感觉还麻烦多了，主要是int是基本数据类型，操作起来要转来转去。
思路就是转成list，再用collection的reverse，再toArray.

1. import java.util.*;
   
2. 
   
3. 
   
4. public class Test3 {
   
5.         /*
   
6.          * int[]转换成Integer[]
   
7.          */
   
8.         static Integer[] toInteger(int [] a){
   
9.                 Integer [] itg=new Integer[a.length];
   
10.                 for(int i=0;i<a.length;i++){
    
11.                         itg[i]=new Integer(a[i]);
    
12.                 }
    
13.                 return itg;
    
14.         }
    
15.         public static void main(String[] args) {
    
16.                 int []a={1,45,5,6,7,82,};
    
17.                
    
18.                 List<Integer> lt =Arrays.asList(toInteger(a));//只有Interge[]才能用，详情见张孝祥老师反射视频里的说明原因
    
19.                 System.out.println(lt.size());
    
20.                 Collections.reverse(lt);
    
21. //                System.out.println(lt);
    
22.                 Integer[]c=(Integer[]) lt.toArray();
    
23.                 for (Integer integer : c) {
    
24.                         System.out.println(integer);
    
25.                 }
    
26.         }
    
27. }
    

复制代码

刘意的视频讲的

要这么复杂嘛~~

选择排序，冒泡排序都挺好的啊，，嫌麻烦希尔排序也许吧。。

Hi_about... 发表于 2015-8-18 00:30
觉得还是 StringBuffer 中的  reverse（）方法好 直接调用反转

数组不是StringBuffer呀......

觉得还是 StringBuffer 中的  reverse（）方法好 直接调用反转 {:2_44:}

ooyeah 发表于 2015-8-18 00:18
路过，友情顶贴........

谢谢，嘻嘻~~~~

路过，友情顶贴........