在java基础中，数组的冒泡排序的原理是什么？具体是个什么思路。

冒泡排序：总是在比较相邻的两个元素。简单的理解数字就像是气泡，体积大的气泡下沉，体积小的气泡上升（从小到大排序），实现数字的排序，用到循环嵌套。
例如，一列随机数字（无序），要求按照从小到大排列。
思路：1.定义数组存放参加比较的随机数字；
2，利用循环嵌套，进行比较；
3，输出比价结果。
代码实现：

1. class  BubbleSort
   
2. {
   
3. public static void main(String[] args)
   
4.         {
   
5.                 int[] arr = {2,3,6,34,14,21,15};
   
6. //排序前
   
7.                 printArray(arr);
   
8. //冒泡排序
   
9.                 bubble(arr);
   
10. //排序后
    
11.                 printArray(arr);
    
12.         }
    
13. 
    
14. 
    
15.         public static void bubble(int[] arr)
    
16.         {
    
17.                 for (int x=0;x<arr.length-1 ;x++ )
    
18.                 {
    
19.                         for(int y =0 ;y<arr.length-x-1 ;y++ )//-x:让每一次比较的元素减少；-1是避免角标月越界
    
20.                         {
    
21.                                 if (arr[y]>arr[y+1])
    
22.                                 {
    
23.                                         int temp = arr[y];
    
24.                                         arr[y] = arr[y+1];
    
25.                                         arr[y+1] = temp;
    
26.                                 }
    
27.                         }
    
28.                 }
    
29.         }
    
30.        
    
31. 
    
32.         public static void printArray(int[] arr)
    
33.         {
    
34.                 System.out.print("[");
    
35.                 for (int i=0;i<arr.length ;i++ )
    
36.                 {
    
37.                         if(i!=arr.length-1)
    
38.                                 System.out.print(arr[i]+",");
    
39.                         else
    
40.                                 System.out.print(arr[i]+"]");
    
41.                 }
    
42.        
    
43.         }
    
44. }
    

复制代码

楼上解释很详细

多看，慢慢就理解了，多敲就熟悉了

假如我们对一个五位数的数组进行排序比较。
                        50 10 30 20 40
        第一步；我们拿40跟20比，发现40是老大，不用交换。
        第二步；然后向前推一步，就是拿20跟30比，发现30是老大，就要交换了。
        第三步：拿交换后的20跟10比，发现自己是老大，不用交换。
        第四步：拿10跟50交换，发现50是老大，进行交换。
        最后，我们经过一次遍历，把数组中最小的数字送上去了，以此类推

卤煮没仔细看毕老师的视频吧

两两对比，小者上浮

涨姿势了