单例模式详解及java常用类

【单例模式】

     确保某一个类，只能产生一个实例。

设计思路：

====将构造函数私有化，确保类外部，不能使用new关键字自行创建对象。

====在类内部实例化一个对象，并通过静态方法返回。

（1）饿汉式单例模式

优点：线程安全

缺点：在类加载的时候，就实例化对象，提前占用系统资源

 class Dog{

     private Dog(){

         System.out.println("小蠢狗");
     }

     private static Dog cutedog=new Dog();

     public static Dog getInstanca(){
         return cutedog;
     }

 }

（2.）懒汉式单例模式：

优点：解决了饿汉式单例，一加载就提前占用资源的问题。

缺点：线程不安全

 class Dog{

     private Dog(){

         System.out.println("小蠢狗");
     }

     private static Dog cutedog=null;

     public static Dog getInstanca(){
         if (cutedog==null) {
             cutedog=new Dog();
         }
         return cutedog;
     }

 }

（3.）线程锁懒汉式模式

通俗来说，就是在懒汉式单例模式的方法上加锁

synchronized：将一个方法或者代码块进行加锁，同一时间只允许一个线程访问

使用同步块对方法进行加锁，确保懒汉式单例，可以线程安全

缺点：效率低下

 class Dog{

     private Dog(){

         System.out.println("小蠢狗");
     }

     private static Dog cutedog=null;

     public static synchronized Dog getInstanca(){
         if (cutedog==null) {
             cutedog=new Dog();
         }
         return cutedog;
     }

 }

（4.）双重加锁懒汉模式：

只有第一次Dog为null时，才进行线程锁，当后续Dog不为null时，说明第一次已经赋值了，·产生了一个实例，就无需线程锁，可以允许多个线程同时拿走dog

class Dog{

    private Dog(){

        System.out.println("小蠢狗");
    }

    private static Dog cutedog=null;

    public static synchronized Dog getInstanca(){
        if (cutedog==null) {
            synchronized (Dog.class) {
                if (cutedog==null) {
                    cutedog=new Dog();
                }
            }
        }
        return cutedog;
    }

}

(5.)静态内部类实现单例

优点：解决了饿汉式提前占用资源的问题，解决了懒汉式线程不安全的问题，静态内部类只有当被调用的时候才开始首次被加载。

 class Dog{

     private Dog(){

         System.out.println("小蠢狗");
     }

     private static class KIttyDod{
         private static Dog cutedog=new Dog();
     }
     public static Dog getInstance(){
         return KIttyDod.cutedog;
     }

 }

【Math】

;?Math位于Java.lang包中

（1.）Math.abs(); 求绝对值

（2.）Math.cbrt(); 求立方根

（3.）Math..sprt();求平方根

（4.）Math.max/min(double1,double2); 返回两个值中最大最小值

（5.）Math.pow(a,b); 求a的b次方

（6.）Math.floor();返回小于指定浮点数的一个整数，返回的是double类型，例如10.0

Math.ceil();------大于---------

（6.）Math.round();四舍五入，返回一个整数类型，如果传入double，返回long，传入float，返回int

（7.）Math.rint();返回最接近参数的整数，如果10.5与10和11同时接近，返回偶数

（8.）Math.random()；返回[0.1,1.0)之间的double随机值

 

【求一个数保留几位小数】

double a=23.22122222;

double b=Math.round(a*Math.pow(10, 3))/Math.pow(10, 3);

System.out.println(b);

 

【Date】

/**实例化

* 空参构造，默认取到当前时间

*/

Date date=new Date();

Date d=new Date();

/**

* 传入一个long类型的时间戳，取到指定时间。

* date.getTime(); 取到一个时间的时间戳，从0时区，1970年1月1日0:0:0到当前时间毫秒数。

*/

System.out.println(d);

 

（1.）equals();比对两个时间是否相等

（2.）a.before(b); 检测一个时间是不是在制定时间之前

after(): --------------------------------------之后

（3.）a.compare to(b); 前面>参数 返回1 前面<小于参数，返回-1 相等,返回0

（4.）setTime()；传入一个长整型（时间戳），重新设置时间

（5.）toString();格式化日期转义格式yyyy-mm-dd。

【SimpleDateFormat】

对日期格式进行实例化。

实例化对象时，传入格式化参数，用字母代表对应部分。

*  字母  日期或时间元素  表示  示例  

 * y  年  Year  1996; 96  

 * M  年中的月份  Month  July; Jul; 07  

 * d  月份中的天数  Number  10  

 * E  星期中的天数  Text  Tuesday; Tue  

 * H  一天中的小时数（0-23）  Number  0  

 * h  am/pm 中的小时数（1-12）  Number  12  

 * m  小时中的分钟数  Number  30  

 * s  分钟中的秒数  Number  55  

（1.）format();用于传人一个Date类型的参数，并返回格式化之后的字符串

Date date=new Date();

SimpleDateFormat sf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E" );

String s=sf.format(date);

System.out.println(s);

（2.）sf.parse("2018年04月13日 14:08:15 星期五");将字符串格式的时间，转成Date类型，要求传入的字符串格式，必须与实例化时的模式，保持一致。

（3.）toPattern();返回当前格式化的模式字符串。

【Calendar日历类】

Calendar ca=Calendar.getInstance();

（1.）Calendar日历类是一个抽象类，不能直接通过new拿到对象，必须使用Calendar.getInstance();拿到一个Calendar日历类对象

（2.）ca.getTime(); 返回一个日期对象

（3.）ca.add(int field, int amount) ; 根据日历的规则，将指定的时间量添加或减去给定的日历字段。

【Random随机数类】

取随机数，有两种构造：

--------------空参构造------------

Random ran=new Random();

--------------传入一个种子数--------只要种子数相同，那么在相同次数取到的随机数肯定相同，这是伪随机数。

Random ran=new Random(100);

Random ran=new Random(System.currentTimeMillis());

System.currentTimeMillis()；拿到当前时间戳，这样就是取随机数了。

（1.）nextInt(); 随机获得一个整数

（2.）nextInt(n); 随机获得从0到n随机数，含0不含n

随机生成两位随机数： System.out.println(ran.nextInt(90)+10);