import java.util.*;
class KuaiPai
{
        public static void main(String[] args)  
        {
                int[] arr = {5,1,6,4,2,8,9};
                printArray(arr);
                Arrays.sort(arr);
                printArray(arr);
        }
        public static int printArray(int[] arr)
        {
                System.out.print("[");
                for(int x=0;x<arr.length;x++)
                {
                        if(x!=arr.length-1)
                                System.out.print(arr[x]+",");
                        else
                                System.out.println(arr[x]+"]");
                }
        }
}

  int[] arr = {5,1,6,4,2,8,9}; //有这样写的吗。。
C里也不是这样写的
C的写法： int arr[]={5,1,6,4,2,8,9};

int[] arr = {5,1,6,4,2,8,9};  
  你这句话 改一下
  int [] arr=new int[]{5,1,6,4,2,8,9};

没看明白Arrays.sort(arr);？？什么意思 数组？ 记得好像没这么用的 集合？ 好像前面又缺点东西而且sort好像是集合用的，集合排序是很快但你要先把数组转成集合才可以

根据你的代码来看
printArray()这方法应该没有返回值的
所以，应该把int 改为void

不好意思 丢脸了 我一直以为sort排序只有集合才可以用没想到数组也可以这样直接用 谢谢

我直接分开回答：
先回答第二个问题：
public static int printArray(int[] arr){  /这个方法的返回值类型是int型的，你不需要返回具体的返回值。改为                               void
。。。。
}

再回到第一个问题。这个排序方法不是最快的：只是使用了工具类。对于你写代码的时候更方便了

更快的是希尔算法

1. 
   
2. /**希尔排序是基于插入排序的一种算法，时间复杂度为 O(N*(logN)2)。
   
3. *下面的希尔排序要求待排序的数组必须实现Comparable接口
   
4. */
   
5. public class ShellSort
   
6. {
   
7.        private int[] increment;
   
8.        /**
   
9.        *利用希尔排序算法对数组obj进行排序
   
10.        */
    
11.        public void sort(Comparable[] obj)
    
12.        {
    
13.               if (obj == null)
    
14.               {
    
15.                      throw new NullPointerException("The argument can not be null!");
    
16.               }
    
17. 
    
18.               //初始化步长
    
19.               initGap(obj);
    
20. 
    
21.               //步长依次变化（递减）
    
22.               for (int i = increment.length - 1 ;i >= 0 ;i-- )
    
23.               {
    
24.                      int step = increment;                    
    
25.                      //由步长位置开始
    
26. 
    
27.                      for (int j = step ;j < obj.length ;j++ )
    
28.                      {
    
29.                             Comparable tmp;
    
30. 
    
31.                             //如果后面的小于前面的（相隔step），则与前面的交换
    
32.                             for (int m = j ;m >= step ;m = m - step )
    
33.                             {
    
34.                                    if (obj[m].compareTo(obj[m - step]) < 0)
    
35.                                    {
    
36.                                           tmp = obj[m - step];
    
37.                                           obj[m - step] = obj[m];
    
38.                                           obj[m] = tmp;
    
39.                                    }
    
40.                                    //因为之前的位置必定已经比较过，所以这里直接退出循环
    
41.                                    else
    
42.                                    {
    
43.                                           break;
    
44.                                    }
    
45.                             }
    
46.                      }
    
47.               }
    
48.        }
    
49. 
    
50. 
    
51.        /**
    
52.        *根据数组的长度确定求增量的公式的最大指数,公式为pow(4, i) - 3 * pow(2, i)
    
53. + 1和9 * pow(4, i) - 9 * pow(2, i) + 1
    
54.        *@return int[] 两个公式的最大指数
    
55.        *@param length 数组的长度
    
56.        */
    
57.        private int[] initExponent(int length)
    
58.        {
    
59.               int[] exp = new int[2];
    
60.               exp[0] = 1;
    
61.               exp[1] = -1;
    
62.               int[] gap = new int[2];
    
63.               gap[0] = gap[1] = 0;
    
64. 
    
65.               //确定两个公式的最大指数
    
66.               while (gap[0] < length)
    
67.               {
    
68.                      exp[0]++;
    
69.                      gap[0] = (int)(Math.pow(4, exp[0]) - 3 * Math.pow(2, exp[0]) + 1);                     
    
70.               }
    
71.               exp[0]--;
    
72. 
    
73.               while (gap[1] < length)
    
74.               {
    
75.                      exp[1]++;
    
76.                      gap[1] = (int)(9 * Math.pow(4, exp[1]) - 9 * Math.pow(2, exp[1]) + 1);                       
    
77.               }
    
78.               exp[1]--;
    
79.               return exp;
    
80.        }
    
81. 
    
82.        private void initGap(Comparable[] obj)
    
83.        {
    
84.               //利用公式初始化增量序列
    
85.               int exp[] = initExponent(obj.length);
    
86.               int[] gap = new int[2];
    
87. 
    
88.                increment = new int[exp[0] + exp[1]];              
    
89. 
    
90. 
    
91. 
    
92. 
    
93. 
    
94. 
    
95.               //将增量数组由大到小赋值
    
96.               for (int i = exp[0] + exp[1] - 1 ;i >= 0 ;i-- )
    
97.               {
    
98.                      gap[0] = (int)(Math.pow(4, exp[0]) - 3 * Math.pow(2, exp[0]) + 1);
    
99.                      gap[1] = (int)(9 * Math.pow(4, exp[1]) - 9 * Math.pow(2, exp[1]) + 1);
    
100. 
     
101.                      //将大的增量先放入增量数组，这里实际上是一个归并排序
     
102.                      //不需要考虑gap[0] == gap[1]的情况，因为不可能出现相等。
     
103.                      if (gap[0] > gap[1])
     
104.                      {
     
105.                             increment = gap[0];
     
106.                             exp[0]--;
     
107.                      }
     
108.                      else
     
109.                      {
     
110.                             increment = gap[1];
     
111.                             exp[1]--;
     
112.                      }
     
113.               }            
     
114.        }
     
115. }
     

复制代码

谢谢7楼这么详细的讲解，学习啦

对于程序员来说，代码写的少就减少了很多时间。所以你选择了这个挺不错的。但是运行的时候还是需要时间去调用util 包中的Arrays类的方法。如果你想要自己写的话你也可以用毕老师交的排序方法。两个典型的排序法。选择排序和冒泡排序。我觉得这两个排序法挺简单的。有需要请看毕老师的第四天视频中有。这里我就不详细解说了。你代码中PrintArray是打印方法。是没有返回值的。所以把int的类型改成void类型就可以了。