JAVA中在运用数组进行排序功能时，一般有四种方法：
1，快速排序法、
（速度最快，代码最简单，但需要导包）
快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。
2，冒泡法
(相邻比较，胜出者与下一个比较，两两比较)
冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，
如果他们的顺序错误就把他们交换过来。走访数组的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越小(或者越大)的元素会经由交换过程中慢慢“浮”到数列的顶端。


　　 冒泡排序算法的运作如下:
  1),比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2),对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
  3),针对所有的元素重复以上的步骤，除了最后一个。
  4),持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
  
比如初始数组：int[] arr={5,4,2,4,9,1};

冒泡法的第1轮比较结果：[4, 2, 4, 5, 1, 9]拿5和4比，5比4大，5和4换位；arr[0]=4
    拿5和2比，5比2打，和2换位        arr[1]=2
    拿5和4比，5比4大，5和4换位； arr[2]=4
    拿5和9比，9比5大，不用换位；   arr[3]=5
    拿9和1比，9比1打，9和1换位     arr[4]=1
    所以相邻两两相比，不符合升序就换位，符合就不换，
冒泡法的第2轮比较结果：[2, 4, 4, 1, 5, 9]
冒泡法的第3轮比较结果：[2, 4, 1, 4, 5, 9]
冒泡法的第4轮比较结果：[2, 1, 4, 4, 5, 9]
冒泡法的第5轮比较结果：[1, 2, 4, 4, 5, 9]

3，选择排序法（以升序为例）
(类似一个擂台，从第一个元素（作为擂台）开始，最后站在擂台上的元素肯定是本轮的最小值)
擂台是从角标0到最大角标依次往后移动的。
选择排序是不稳定的排序方法。

选择排序法是将数组的第一个数据作为最小的值，然后通过与后面的每个元素相比较，最小的总是放在最前面（擂台上）
然后逐渐循环，最终输出升序的数组。

比如初始数组：int[] arr={5,1,6,3,7,9}
选择排序法的第1轮比较结果：[1, 5, 6, 3, 7, 9]第一轮擂台在角标0上，以arr[0]作为最小值（擂主）。后面的前来挑战，
只要比擂主小就可以作为新擂主站在台上，到最后站在台上的是最小值1.
选择排序法的第2轮比较结果：[1, 3, 6, 5, 7, 9]第二轮擂台在角标1上，以arr[]1作为最小值（擂主）。后面的前来挑战，
只要比擂主小就可以作为新擂主站在台上，到最后站在台上的是最小值1.
选择排序法的第3轮比较结果：[1, 3, 5, 6, 7, 9]
选择排序法的第4轮比较结果：[1, 3, 5, 6, 7, 9]
选择排序法的第5轮比较结果：[1, 3, 5, 6, 7, 9]依次类推，到最后，擂台移到最大的角标上，
也就没人和它比了，这时排序也就完成了
4，插入排序法。
插入排序是选择一个数组中的数据，通过不断的插入比较,每次插入到第i个角标上，就与比i小的角标相比较
就类似于从右向左找到比插入点小(对升序而言)的元素，符合就往左进行，不符合就交换后继续向左，直到数组的最左面
直到插入最后一角标,从右向左比较完以后，整个排序过程就算完成.

比如初始数组：int[] arr={5,4,2,4,9,1};
插入排序法的第1轮比较结果：[4, 5, 2, 4, 9, 1]插在角标1上，就从1往前开始两两比较（冒泡法比较）
插入排序法的第2轮比较结果：[2, 4, 5, 4, 9, 1]插在角标2上，就从2往前开始两两比较（就是对4,5,2冒泡排序）
插入排序法的第3轮比较结果：[2, 4, 4, 5, 9, 1]插在角标3上，就从3往前开始两两比较（就是对2,4,,5,4冒泡排序）
插入排序法的第4轮比较结果：[2, 4, 4, 5, 9, 1]插在角标3上，就从3往前开始两两比较（就是对2, 4, 4, 5, 9冒泡排序）
插入排序法的第5轮比较结果：[1, 2, 4, 4, 5, 9]插在角标5上，就从5往前开始两两比较（冒泡法比较）


插入排序结合了冒泡排序，比冒泡排序多了一步插入，不如直接用冒泡，

1. public class arraySort {  
   
2.   
   
3.     public static void main(String[] args) {  
   
4.         int[] arr={5,4,2,4,9,1};     
   
5. //      Arraysort(arr);//快速排序法（这个既高效又方便）  
   
6.         bubbleSort(arr);//冒泡  
   
7. //      selectSort(arr);//选择排序（低效不稳定）  
   
8. //      insertSort(arr);//插入排序（方法内部又冒泡功能）  
   
9.          
   
10.          
    
11.         System.out.println(Arrays.toString(arr));  
    
12.     }  
    
13. //  <1>利用Arrays带有的排序方法快速排序  
    
14.     public static int[] Arraysort(int [] a){  
    
15.         Arrays.sort(a);  //进行排序     
    
16.         return a;  
    
17.     }  
    
18.       
    
19. //  <2>冒泡排序算法  
    
20.     public static int[] bubbleSort(int[] arr){//冒泡排序算法   
    
21.         System.out.println("没有排序前的数组："+Arrays.toString(arr));  
    
22.         for(int x=0;x<arr.length-1;x++){  
    
23.             for(int y=0;y<arr.length-x-1;y++){//-x:让每次比较的元素减少，-1：避免角标越界  
    
24.                 if(arr[y]>arr[y+1]){//这种方法每次比较的是相邻两个元素。  
    
25.                     int temp=arr[y];//如果他们的顺序错误就把他们交换过来   
    
26.                     arr[y]=arr[y+1];//最主要的是每进行下一次比较时，都会把遍历出的最值排除。  
    
27.                     arr[y+1]=temp;  
    
28.                 }  
    
29.             }  
    
30.             System.out.println("冒泡法的第"+(x+1)+"轮比较结果："+Arrays.toString(arr));      
    
31.               
    
32.         }  
    
33.         return arr;  
    
34.          
    
35.     }   
    
36.       
    
37. //  <3>选择排序算法  
    
38.     public static int[] selectSort(int[] arr){//选择排序算法     
    
39.         //  个人觉得这个类似抢擂台，当i=0时，拿第一个和数组中所有元素比较  
    
40.         //  这样会是效率变低。  
    
41.         for(int i=0;i<arr.length-1;i++){     
    
42.            for(int j=i+1;j<arr.length;j++){   
    
43.             
    
44.                if (arr[i]>arr[j]){//如果他们的顺序错误就把他们交换过来      
    
45.                    int temp=arr[i];//临时变量记录最大值  
    
46.                    arr[i]=arr[j];     
    
47.                    arr[j]=temp;     
    
48.                }     
    
49.            }  
    
50.            System.out.println("选择排序法的第"+(i+1)+"轮比较结果："+Arrays.toString(arr));  
    
51.             
    
52.         }  
    
53.         return arr;  
    
54.    }   
    
55. //  <4>插入排序算法  
    
56.     public static int[] insertSort(int[] arr){//插入排序算法     
    
57.          for(int i=1;i<arr.length;i++){//必须从数组中第二个元素开始插入（就是从角标为1的元素开始插入）     
    
58.                  for(int j=i;j>0;j--){//依次将比i小的角标从右向左进行冒泡排序。     
    
59.                          if (arr[j]<arr[j-1]){     
    
60.                                  int temp=arr[j-1];   
    
61.                                  arr[j-1]=arr[j];   
    
62.                                  arr[j]=temp;            
    
63.                         }//else break; //可写可不写。   
    
64.                 }   
    
65.                 System.out.println("插入排序法的第"+(i)+"轮比较结果："+Arrays.toString(arr));  
    
66.          }  
    
67.         /*小石头自己定义的插入排序法，与上面的正好颠倒，每次比较是从左向右。
    
68.         int count =0;
    
69.         for(int i=arr.length-2;i>=0;i--){
    
70.             for(int j=i;j<arr.length-1;j++){
    
71.                 if(arr[j]>arr[j+1]){
    
72.                     int temp=arr[j+1];
    
73.                     arr[j+1]=arr[j];
    
74.                     arr[j]=temp;
    
75.                 }
    
76.             }
    
77.             ++count;
    
78.             System.out.println("插入排序法的第"+count+"轮比较结果："+Arrays.toString(arr));
    
79.         }*/  
    
80.            
    
81.          return arr;   
    
82.     }   
    
83.   
    
84. }  

复制代码

代码可以直接复制，自己运行一下，然后根据上面我写的分析，一步步看看，相信你能熟练的掌握java数组的排序方法。
个人建议用快速排序法比较好（当然前期你要对Arrays有一定的了解）

不错不错，学习了

很好，学习了

总结的不错，学习学习