首先，看下两种排序的示意图：
选择排序：


冒泡排序：


选择排序的思：每一次排序过程，我们获取当前没有排好序中的最大（小）的元素和数组最右（左）端的元素交换，循环这个过程即可实现对整个数组排序。

冒泡排序的思想：每一次排序过程，通过相邻元素的交换，将当前没有排好序中的最大（小）移到数组的最右（左）端。
同样数据的情况下，2种算法的循环次数是一样的，但选择排序只有0到1次交换，而冒泡排序只有0到n次交换，选择排序的平均时间复杂度比冒泡排序的稍低。

1. import java.util.*;
   
2. /*
   
3.     对给定数组进行排序。
   
4.         {5,1,6,4,2,8,9}
   
5. */
   
6. class ArrayTest2
   
7. {
   
8.         /*
   
9.           选择排序。
   
10.           内循环结束一次，最值出现头角标位置上。
    
11.         */
    
12.         public static void selectSort(int[] arr)
    
13.         {
    
14.                 for (int x=0; x<arr.length-1 ; x++)
    
15.                 {
    
16.                         for(int y=x+1; y<arr.length; y++)
    
17.                         {
    
18.                                 if(arr[x]>arr[y])
    
19.                                 {
    
20.                                         /*
    
21.                                         int temp = arr[x];
    
22.                                         arr[x] = arr[y];
    
23.                                         arr[y]= temp;
    
24.                                         */
    
25.                                         swap(arr,x,y);
    
26.                                 }
    
27.                         }
    
28.                 }
    
29.         }
    
30. 
    
31.         /*
    
32.            冒泡排序
    
33.         */
    
34.         public static void bubbleSort(int[] arr)
    
35.         {
    
36.                 for(int x=0; x<arr.length-1; x++)
    
37.                 {                                                                       
    
38.                         for(int y=0; y<arr.length-x-1; y++)//-x:让每一次比较的元素减少，-1：避免角标越界。
    
39.                         {
    
40.                                 if(arr[y]<arr[y+1])
    
41.                                 {
    
42.                                         /*
    
43.                                         //封装成一个单独的方法
    
44.                                         int temp = arr[y];
    
45.                                         arr[y] = arr[y+1];
    
46.                                         arr[y+1] = temp;
    
47.                                         */
    
48.                                         swap(arr,y,y+1);
    
49.                                 }
    
50.                         }
    
51.                 }
    
52.         }
    
53. 
    
54.         /*
    
55.         发现无论什么排序。都需要对满足条件的元素进行位置置换。
    
56.         所以可以把这部分相同的代码提取出来，单独封装成一个函数。
    
57.         */
    
58.         public static void swap(int[] arr,int a,int b)
    
59.         {
    
60.                 int temp = arr[a];
    
61.                 arr[a] = arr[b];
    
62.                 arr[b] = temp;
    
63.         }
    
64.         public static void main(String[] args)
    
65.         {
    
66.                 int[] arr = {5,1,6,4,2,8,9};
    
67.                 //排序前；
    
68.                 printArray(arr);
    
69. 
    
70.                 //排序
    
71.                 //selectSort(arr);
    
72.                 //bubbleSort(arr);
    
73. 
    
74.                 //Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中，对数组排序。要使用该句代码。
    
75. 
    
76.                 //排序后：
    
77.                 printArray(arr);
    
78.                        
    
79.         }
    
80. 
    
81.     //打印数组中的元素
    
82.         public static void printArray(int[] arr)
    
83.         {
    
84.                 System.out.print("[");
    
85.                 for(int x=0; x<arr.length; x++)
    
86.                 {
    
87.                         if(x!=arr.length-1)
    
88.                                 System.out.print(arr[x]+", ");
    
89.                         else
    
90.                                 System.out.println(arr[x]+"]");
    
91. 
    
92.                 }               
    
93.         }
    
94. }
    

复制代码

首先，看下两种排序的示意图：
选择排序：


冒泡排序：


选择排序的思：每一次排序过程，我们获取当前没有排好序中的最大（小）的元素和数组最右（左）端的元素交换，循环这个过程即可实现对整个数组排序。

冒泡排序的思想：每一次排序过程，通过相邻元素的交换，将当前没有排好序中的最大（小）移到数组的最右（左）端。
同样数据的情况下，2种算法的循环次数是一样的，但选择排序只有0到1次交换，而冒泡排序只有0到n次交换，选择排序的平均时间复杂度比冒泡排序的稍低。

1. import java.util.*;
   
2. /*
   
3.     对给定数组进行排序。
   
4.         {5,1,6,4,2,8,9}
   
5. */
   
6. class ArrayTest2
   
7. {
   
8.         /*
   
9.           选择排序。
   
10.           内循环结束一次，最值出现头角标位置上。
    
11.         */
    
12.         public static void selectSort(int[] arr)
    
13.         {
    
14.                 for (int x=0; x<arr.length-1 ; x++)
    
15.                 {
    
16.                         for(int y=x+1; y<arr.length; y++)
    
17.                         {
    
18.                                 if(arr[x]>arr[y])
    
19.                                 {
    
20.                                         /*
    
21.                                         int temp = arr[x];
    
22.                                         arr[x] = arr[y];
    
23.                                         arr[y]= temp;
    
24.                                         */
    
25.                                         swap(arr,x,y);
    
26.                                 }
    
27.                         }
    
28.                 }
    
29.         }
    
30. 
    
31.         /*
    
32.            冒泡排序
    
33.         */
    
34.         public static void bubbleSort(int[] arr)
    
35.         {
    
36.                 for(int x=0; x<arr.length-1; x++)
    
37.                 {                                                                       
    
38.                         for(int y=0; y<arr.length-x-1; y++)//-x:让每一次比较的元素减少，-1：避免角标越界。
    
39.                         {
    
40.                                 if(arr[y]<arr[y+1])
    
41.                                 {
    
42.                                         /*
    
43.                                         //封装成一个单独的方法
    
44.                                         int temp = arr[y];
    
45.                                         arr[y] = arr[y+1];
    
46.                                         arr[y+1] = temp;
    
47.                                         */
    
48.                                         swap(arr,y,y+1);
    
49.                                 }
    
50.                         }
    
51.                 }
    
52.         }
    
53. 
    
54.         /*
    
55.         发现无论什么排序。都需要对满足条件的元素进行位置置换。
    
56.         所以可以把这部分相同的代码提取出来，单独封装成一个函数。
    
57.         */
    
58.         public static void swap(int[] arr,int a,int b)
    
59.         {
    
60.                 int temp = arr[a];
    
61.                 arr[a] = arr[b];
    
62.                 arr[b] = temp;
    
63.         }
    
64.         public static void main(String[] args)
    
65.         {
    
66.                 int[] arr = {5,1,6,4,2,8,9};
    
67.                 //排序前；
    
68.                 printArray(arr);
    
69. 
    
70.                 //排序
    
71.                 //selectSort(arr);
    
72.                 //bubbleSort(arr);
    
73. 
    
74.                 //Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中，对数组排序。要使用该句代码。
    
75. 
    
76.                 //排序后：
    
77.                 printArray(arr);
    
78.                        
    
79.         }
    
80. 
    
81.     //打印数组中的元素
    
82.         public static void printArray(int[] arr)
    
83.         {
    
84.                 System.out.print("[");
    
85.                 for(int x=0; x<arr.length; x++)
    
86.                 {
    
87.                         if(x!=arr.length-1)
    
88.                                 System.out.print(arr[x]+", ");
    
89.                         else
    
90.                                 System.out.println(arr[x]+"]");
    
91. 
    
92.                 }               
    
93.         }
    
94. }
    

复制代码