冒泡排序算法原理：（从小到大排序）
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，交换一趟后，最后的元素会是最大的数
3.针对所有的元素重复以上的步骤，除了最后一个
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

源码

public static void search2(int[] nums) {
            int[] list = {2,1,3,6,5};
            int temp = 0,i=0,j=0; // 开辟一个临时空间, 存放交换的中间值
            // 要遍历的次数
            for ( i = 0; i < list.length-1; i++) {
                int flag = 1; //设置一个标志位
                //依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
                for ( j = 0; j < list.length-1-i; j++) {
                    // 比较相邻的元素，如果前面的数小于后面的数，交换
                    if (list[j] > list[j+1]) {
                        temp = list[j+1];
                        list[j+1] = list[j];
                        list[j] = temp;
                        flag = 0;  //发生交换，标志位置0\1
                    }
                }
                System.out.format("第 %d 遍最终结果：", i+1);
                for(int count:list) {
                    System.out.print(count);
                }
                System.out.println("");        
            }
        }

第 1 遍最终结果：12356
第 2 遍最终结果：12356
第 3 遍最终结果：12356
第 4 遍最终结果：12356

第一次优化
我们可以设置一个标志位，用来表示当前第 i 趟是否有交换，如果有则要进行 i+1 趟，如果没有，则说明当前数组已经完成排序

public static void search2(int[] nums) {
            int[] list = {2,1,3,6,5};
            int temp = 0,i=0,j=0; // 开辟一个临时空间, 存放交换的中间值
            // 要遍历的次数
            for ( i = 0; i < list.length-1; i++) {
                int flag = 1; //设置一个标志位
                //依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
                for ( j = 0; j < list.length-1-i; j++) {
                    // 比较相邻的元素，如果前面的数小于后面的数，交换
                    if (list[j] > list[j+1]) {
                        temp = list[j+1];
                        list[j+1] = list[j];
                        list[j] = temp;
                        flag = 0;  //发生交换，标志位置0\1
                    }
                }
                System.out.format("第 %d 遍最终结果：", i+1);
                for(int count:list) {
                    System.out.print(count);
                }
                System.out.println("");
                if (flag == 1) {//如果没有交换过元素，则已经有序
                    System.out.println("i: "+i+" j: "+j);
                    return;
                }
            }
        }

第 1 遍最终结果：12356
第 2 遍最终结果：12356
i:  1  j: 3

优化内层循环

public static void search2(int[] nums) {
            int[] list = {2,1,3,6,5};
            int temp = 0,i=0,j=0,len=list.length; // 开辟一个临时空间, 存放交换的中间值
            int temp2 = 0;
            // 要遍历的次数
            for ( i = 0; i < list.length-1; i++) {
                int flag = 1; //设置一个标志位
                //依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
                for ( j = 0; j < len-1-i; j++) {
                    // 比较相邻的元素，如果前面的数小于后面的数，交换
                    if (list[j] > list[j+1]) {
                        temp = list[j+1];
                        list[j+1] = list[j];
                        list[j] = temp;
                        flag = 0;  //发生交换，标志位置0\1t
                        temp2 = j;
                    }
                }
                len = temp2;
                System.out.format("第 %d 遍最终结果：", i+1);
                for(int count:list) {
                    System.out.print(count);
                }
                System.out.println("");
                if (flag == 1) {//如果没有交换过元素，则已经有序
                    System.out.println("i: "+i+" j: "+j);
                    return;
                }
            }
        }

第 1 遍最终结果：12356
第 2 遍最终结果：12356
i:  1  j: 1