1. import java.util.Arrays;
   
2. 
   
3. public class BubbleSort {
   
4. 
   
5.         /**
   
6.          * 冒泡排序： 相邻元素两两比较，大的往后放，第一次比较完后，最大元素出现在最大索引处。
   
7.          */
   
8.         public static void main(String[] args) {
   
9. 
   
10.                 // 定义要排序的数组
    
11.                 int[] arr = { 12, 45, 42, 0, -15, 99 };
    
12. 
    
13.                 /*
    
14.                  * 方式一： 冒泡排序法
    
15.                  */
    
16.                 //输出排序前数组
    
17.                 System.out.println("排序前：");
    
18.                 printArray(arr);
    
19. 
    
20.                 // 调用排序功能
    
21.                 bubSort(arr);
    
22.                
    
23.                 //输出排序后数组
    
24.                 System.out.println("排序后：");
    
25.                 printArray(arr);
    
26. 
    
27.                 /*
    
28.                  * 方式二：直接调用Arrays类的sort方法进行排序
    
29.                  */
    
30.                 //输出排序前数组
    
31.                 System.out.println("排序前：");
    
32.                 printArray(arr);
    
33. 
    
34.                 // 调用排序算法
    
35.                 Arrays.sort(arr);
    
36. 
    
37.                 //输出排序后数组
    
38.                 System.out.println("排序后：");
    
39.                 printArray(arr);
    
40.         }
    
41. 
    
42.         // 冒泡排序代码实现
    
43.         public static void bubSort(int[] arr) {
    
44. 
    
45.                 // 外循环变量是冒泡比较的次数
    
46.                 for (int i = 0; i < arr.length - 1; i++) {
    
47.                         // 其中，arr.length-1 是为了防止越界，因为后面出现了j+1
    
48.                         // arr.length-1-x 是每一次比较的次数在递减
    
49.                         for (int j = 0; j < arr.length - 1 - i; j++) {
    
50.                                
    
51.                                 //如果前一个元素比后又一个元素大
    
52.                                 if (arr[j] > arr[j + 1]) {
    
53.                                         // 元素交换
    
54.                                         int temp = arr[j];
    
55.                                         arr[j] = arr[j + 1];
    
56.                                         arr[j + 1] = temp;
    
57.                                 }
    
58.                         }
    
59.                 }
    
60.         }
    
61. 
    
62.         // 遍历数组
    
63.         public static void printArray(int[] arr) {
    
64.                 //输出左括号
    
65.                 System.out.print("[");
    
66.                
    
67.                 //遍历输出数组
    
68.                 for (int x = 0; x < arr.length; x++) {
    
69.                         //如果是最后一个元素，则补上又括号
    
70.                         if (x == arr.length - 1) {
    
71.                                 System.out.println(arr[x] + "]");
    
72.                         }
    
73.                         //如果不是则输出元素和“， ”
    
74.                         else {
    
75.                                 System.out.print(arr[x] + ", ");
    
76.                         }
    
77.                 }
    
78.         }
    
79. }
    

复制代码

原理图：

楼主对冒泡排序理解的好什么呀，适合新手，学过的也能加深理解！