单例

冒泡

优化（价格flag判断）

public static  void BubleSort(int[] arr) {
    boolean flag = true;
    for(int i=0;i<arr.length;i++) {
        //记得减一(因为j+1会超出范围)
        for(int j=0;j<arr.length-i-1;j++) {
            if(arr[j]<arr[j+1]) {
                flag = false;
                int temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
        if(flag) {
            break;
        }else {
            flag = true;
        }
    }
}

快排

代码

public class QuickSort2 {

    public static void main(String[] args) {

        int[] arr = {3,9,2,6,7,0,2,1};
        quickSort(arr,0,arr.length-1);
        for(int n:arr) {
            System.out.println(n);
        }
    }
    public static void quickSort(int[] arr,int l,int r) {
        if(l<r){
            // 一趟快排，并返回交换后基数的下标
            int index = partition(arr,l,r);
            // 递归排序基数左边的数组
            quickSort(arr,l,index-1);
            // 递归排序基数右边的数组
            quickSort(arr,index+1,r);
        }
    }
    public static int partition(int[] arr,int l,int r) {
        // p为基数，即待排序数组的第一个数
        int p = arr[l];
        int i = l;
        int j = r;
        while(i < j) {
            // 从右往左找第一个小于基数的数
            while(i < j && arr[j] >= p)j--;
            // 从左往右找第一个大于基数的数
            while(i < j && arr[i] <= p)i++;
            // 找到后交换两个数
            swap(arr,i,j);
        }
        // 使划分好的数分布在基数两侧
        swap(arr,l,i);
        return i;
    }
    public static void swap(int[] arr,int l,int r) {
        int temp = arr[l];
        arr[l] = arr[r];
        arr[r] = temp;
    }
}

手写单例(保证只有一个实例对象)

什么类使用单例

全局使用的类

消耗很多资源的类(数据库连接池，工厂类)

实现要点

私有化构造器

持有该类的属性

对外提供获取实例的静态方法

饿汉式

• 优点：类加载时就创建好的
• 缺点：不需要加载它的时候加载了浪费资源，并且对于反射和反序列化是不安全的

public class Singleton {
	//类加载的时候就初始化
	private static Singleton instance = new Singleton();
    //私有构造方法
	private Singleton() {
		
	}
	//getInstance方法返回已经创建的对象
	public static Singleton getInstance() {
		return instance;
	}
}

懒汉式

• 优点：第一次使用时才加载，节约资源

//volatile防止指令重排(先指向地址，后初始化对象，此时其他对象拿走地址里面的对象可能为空)
	private static volatile Singleton instance = null;
	private Singleton() {
	}
	public static Singleton getInstance() {
		//加一层判断，不需要每次都去判断是否被锁
		if(instance == null) {
			synchronized (Singleton.class) {//不加锁的话，有可能多个对象都进入if里创建对象
				if(instance == null) {
					instance = new Singleton();
				}
			}
		}
		return instance;
	}

遍历hashmap

Map<String,String> map=new HashMap<String,String>();
map.put(“1”, “value1”);
map.put(“2”, “value2”);
for(String v:map.values())
{
System.out.println("The value is "+v);
}

字符串1fee8fs9fd8，编程输出里面数字1898

String s = “1fee8fs9fd8”;
s = Regex.Replace(s,"[a-zA-Z]","");