冒泡排序，是怎么回事？

多看看forfor嵌套循环，然后就能明白点

冒泡排序：就是紧挨着的两个元素进行比较，两者较大的赋给后者。这样第一轮结束后，数组的最后一个元素就是整个数组的最大值了，因此，在下一轮的比较中，最后一个元素不参与比较了。然后进行第二轮比较，依然从第一个元素开始，两两比较，值大的赋给后者，然后数组的倒数第二个元素就是第二大的了，一直这样比较下去。
举例：[3, 10  5,  4]
第一轮：3和10比较，10大，所以不用交换，继续比较10和5，进行交换，此时，数组变为【3, 5, 10, 4】,然后再将10和4比较，10大于4，所以继续交换，交换之后，变为：【3,5，4,10】第一轮结束。
第二轮：3和5比较，再比较5和4，交换，变为：【3,4,5,10】
第三轮：比较3和4，大的在后面，不用交换。结束比较，最终结果为：【3，4,5，10】
实现代码如下：

1. class BubbleSortDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr = {3, 10, 5, 4};
   
6. 
   
7.                 bubbleSort(arr);
   
8.                
   
9.                 //打印结果
   
10.                 System.out.print("[");
    
11.                 for(int i=0; i<arr.length; i++)
    
12.                 {
    
13.                         if(i==arr.length-1)
    
14.                                 System.out.println(arr[i] + "]");
    
15.                         else
    
16.                                 System.out.print(arr[i] + ",");
    
17.                 }
    
18.         }
    
19. 
    
20.         private static void bubbleSort(int[] arr)
    
21.         {
    
22.                 //外循环主要用于内循环里的控制条件
    
23.                 for(int i=0; i<arr.length; i++)
    
24.                 {
    
25.                         //内循环的控制条件：每一轮比较次数逐渐减1，用“-i”表示。
    
26.                         //减1是因为，数组的最大下标。
    
27.                         for(int j=0; j<arr.length - i -1; j++)
    
28.                         {
    
29.                                 if(arr[j] > arr[j+1])
    
30.                                         swap(arr, j, j+1);
    
31.                         }
    
32.                 }
    
33.         }
    
34.         //交换数组中i和j角标的元素
    
35.         private static void swap(int[] arr, int i, int j)
    
36.         {
    
37.                 int temp = arr[i];
    
38.                 arr[i] = arr[j];
    
39.                 arr[j] = temp;
    
40.         }
    
41. }
    

复制代码

希望，能够帮助到楼主！

可以多看看老毕视频呀

冒泡排序就是像水泡从水底往上升，最上面的最大，所以排序的时候相邻的两个两两比较，就会把最大的排到最后面，以此类推。

楼上都详细说名了，加油把少年

                                     看看

概括的说就是一个数和相邻的进行比较，大的往后走，用for循环嵌套实现