Singleton 单例
饿汉式
最简单的方式
/*** 饿汉式* 类加载到内存后，就实例化一个单例，JVM保证线程安全* 简单实用，推荐使用！* 唯一缺点：不管用到与否，类装载时就完成实例化* Class.forName("")* （话说你不用的，你装载它干啥）*/
public class Mgr01 {private static final Mgr01 INSTANCE = new Mgr01();private Mgr01() {};public static Mgr01 getInstance() {return INSTANCE;}public void m() {System.out.println("m");}public static void main(String[] args) {Mgr01 m1 = Mgr01.getInstance();Mgr01 m2 = Mgr01.getInstance();System.out.println(m1 == m2);//true}
}
双重检测锁
/*** lazy loading* 也称懒汉式* 虽然达到了按需初始化的目的，但却带来线程不安全的问题* 可以通过synchronized解决，但也带来效率下降*/
public class Mgr06 {private static volatile Mgr06 INSTANCE; //JITprivate Mgr06() {}public static Mgr06 getInstance() {if (INSTANCE == null) {//双重检查synchronized (Mgr06.class) {if(INSTANCE == null) {try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}INSTANCE = new Mgr06();}}}return INSTANCE;}public void m() {System.out.println("m");}public static void main(String[] args) {for(int i=0; i<100; i++) {new Thread(()->{System.out.println(Mgr06.getInstance().hashCode());}).start();}}
}
静态内部类
/*** 静态内部类方式* JVM保证单例* 加载外部类时不会加载内部类，这样可以实现懒加载*/
public class Mgr07 {private Mgr07() {}private static class Mgr07Holder {private final static Mgr07 INSTANCE = new Mgr07();}public static Mgr07 getInstance() {return Mgr07Holder.INSTANCE;}public void m() {System.out.println("m");}public static void main(String[] args) {for(int i=0; i<100; i++) {new Thread(()->{System.out.println(Mgr07.getInstance().hashCode());}).start();}}
}
枚举方式
/*** 不仅可以解决线程同步，还可以防止反序列化。*/
public enum Mgr08 {INSTANCE;public void m() {}public static void main(String[] args) {for(int i=0; i<100; i++) {new Thread(()->{System.out.println(Mgr08.INSTANCE.hashCode());}).start();}}
}
Strategy 策略
Comparator接口
比较猫的属性排序
public class CatHeightComparator implements Comparator<Cat> {@Overridepublic int compare(Cat o1, Cat o2) {if(o1.height > o2.height) return -1;else if (o1.height < o2.height) return 1;else return 0;}
}
Comparable接口
public class Apple implements Compareable{priavte double redius;//半径值public int compateTo(Object obj){if(obj!=null && obj instanceof Apple){Apple app = (Apple)obj;if(this.redius> app.redius){return 1;}else if(this.redius == app.redius){return 0;}}return -1;}
}
冒泡排序
public class BubbleSort{public void Sort(Comparable[] arr){for(int i = 1;i<arr.length;i++){for(int j = i; j<arr.length-i;j++){if(arr[j].comparableTo(arr[j+1]) > 0){Comparable tmp = arr[j];arr[j] = arr[j+1];arr[j+1] = tmp;}}}}
}
Comparable：强行对实现它的每个类的对象进行整体排序。
这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。
只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。
实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。
可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。
还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序
