冒泡排序+单例

第一种：始终比较第一层for循环的第i个元素

/**
     * 冒泡排序，升序排序
     * 始终将第i个数与第j个数相比较
     *
     * @author Mekhi
     * @date 2019/10/17 16:23
     */
    public static void bubbleSort(){
        int[] arr = {5,2,43,56,7,4,1,2,8};
        //外层for循环控制循环次数
        for (int i = 0; i < arr.length; i++) {
            for(int j = i+ 1;j < arr.length;j++){
                if(arr[i] > arr[j]){
                    int tem = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tem;
                }
            }
        }
        for(int item : arr){
            System.out.print(item + ",");
        }
    }

第二种：相邻元素两两比较

/**
     * 冒泡排序，升序排序
     * 始终将最大的向上冒泡
     * 第一遍for完成后，最后一个必然是最大的
     * 此时，在进行下一次的for循环时，j<arr.length-1-i,
     * 这个i减的是已经进行的次数，即已经冒出最大的数的次数
     *
     * @author Mekhi
     * @date 2019/10/17 16:23
     */
    public static void bubbleSort(){
        int[] arr = {5,2,43,56,7,4,1,2,8};
        for(int i=0;i<arr.length-1;i++){ //控制轮数
            for(int j=0;j<arr.length-1-i;j++){ //控制次数
            	//相邻元素进行比较
                if(arr[j]>arr[j+1]){
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
        }
        for(int item : arr){
            System.out.print(item + ",");
        }
    }

单例

public class Singleton {
    private volatile static  Singleton singleton;
    private Singleton(){

    }

    public Singleton getSingleton(){
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}