Java基础学习（五）-- Java中常用的工具类、枚举、Java中的单例模式之详解

Java中的常用类

1.Math ： 位于java.lang包中

(1)Math.PI:返回一个最接近圆周率的

(2)Math.abs(-10):返回一个数的绝对值

(3)Math.cbrt(27)：返回一个数的立方根

(4)Math.sqrt(16)：返回一个数的平方根

(5)Math.max(10, 20)/Math.min(10, 20)：最大值，最小值

(6)Math.pow(20, 3)：求某个数的几次幂

(7)Math.floor(12.5)：传入一个double的值，返回一个小于指定数字的整数

(8)Math.ceil(12.5)：传入一个double的值，返回一个大于指定数字的整数

(9)Math.round(12.7) ： 四舍五入（如果传入double返回long，传入float返回int）

(10)Math.rint(10.5) ：返回最接近参数的一个整数，如果10.5和10与11同时接近，返回偶数。

(11)Math.random() ： 回[0.0,1.0)的double类型的随机数。

 

2.Date ： 位于java.util包中

(1)实例化： //空参构造

Date date = new Date();

//传入一个long类型的时间戳，取到制定时间

//date.getTime()：取到一个时间的时间戳，从0时区，1970年1月1日0：0：0到当前时间的毫米数。

Date date2 = new Date(date.getTime());

(2)setTime() :传入一个长整型（时间戳），重新设置时间。

(3)compareTo(data): 比较两个日期，两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。

(4)equals():比较两个日期是否相等。

(5)date.toString()：转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 。

(6)before()：检测一个时间是否在指定时间之前。

(7)after()： 检测一个时间是否在制定时间之后。

 

3.SimpleDateFormat 格式化日期

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

方法：

format()：用于传入一个Date类型的参数，并返回格式化之后的字符串。

parser()：将字符串格式的时间转换成Date类型， 要求传入的字符串格式必须与实例化时的格式完全一致。

toPattern()：返回描述此日期格式的模式字符串。

 

     //空参构造
        Date date = new Date();
        //SimpleDateFormat 格式化日期
        SimpleDateFormat sf = new SimpleDateFormat("y年M月d号 HH:mm:ss E");
        String format = sf.format(date2);
        System.out.println(format);        

4.Calendar 日历类

(1)calendar是一个抽象类，不能通过new关键字拿到对象，必须使用Calendar.getInstance()拿到日历类对象。

Calendar instance = Calendar.getInstance();

(2)add():add(instance.get(instance.MONTH), 2) 增加2个月。

(3)getTime():Date time = instance.getTime() 返回一个日期对象

(4)get(): instance.get(instance.MONTH) 返回当前要查的月份

 

---

5.Random 随机数类

构造： 空参构造：new Random();

带参构造：new Random(seed)：只要seed(种子数)相同，那么在相同次数取到的随机数肯定相同，这是一个伪随机数。

nextInt() ：随机获得一个整数。

nextInt(n) : 随机获得0-n的随机数。

nextDouble():随机获得一个0.0-1.0的随机数。

例：从95到102取随机数： random.nextInt(8)+95;

 

补充：UUID类

---

enum 枚举

枚举类是一种特殊的类，里面的值全部都是静态常量，每一个枚举值都相当于本类对象，只不过对象的值就是对象名。

enum colors {

BLUE,YELLOW,RED,GREEN;

}

实际上每一个枚举值都是一个本类对象，所以声明一个枚举值.相当于执行了：public static final XXX = new Color();

枚举类的是构造函数必须是私有化的（private），在声明枚举值时自动调用。

在枚举类中，枚举值必须在所以代码的第一行，其他所有代码必须放在枚举值的后面，枚举值以逗号分割，以分号结束。

 

value()：获取枚举类中所有的枚举值，返回的是枚举类的数组。

toString()：在使用的时候自动调用，也可重写

 enum Person {
    　　　　p1("张三", 18), p2("李四", 22), p3("王五", 13);
    　　　　private String name;
   　　　　 private int age;
    　　　　private Person(String name, int age) {
      　　　　  this.name = name;
      　　　　  this.age = age;
  　　　　  }
   　　　　 @Override
   　　　　 public String toString() {
      　　　　  return this.name+"-"+this.age;
   　　　　 }
　　　　}
　　　　System.out.println(Person.p1);

---

单例模式

单例模式其定义是单例对象的类只能允许一个实例存在。

【1】静态常量单例模式（饿汉式）

设计思路：

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

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

3.属性要是静态的，否则会实例化多个属性，不属于单例模式。

优点：线程安全。

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

class singLeton{

    private static final singLeton sing = new singLeton();

    private singLeton() {
        System.out.println("单例模式");
    }

    public static singLeton getInstance() {
        return sing;
    }

}

【2】懒汉式单例模式

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

　　　　缺点：线程不安全。

class singLeton{

    private static singLeton sing = null;

    private singLeton() {
        System.out.println("单例模式");
    }

    public static singLeton getInstance() {

        if (sing==null) {
            sing = new singLeton();
        }

        return sing;
    }
}

　【3】线程锁的懒汉式单例模式

　　优点：使用synchroized关键字对方法进行加锁，将一个方法或者代码块加锁，同一时间只允许一个线程访问，确保懒汉式单例可以线程安全。

　　缺点：效率低下。

class singLeton{

    private static singLeton sing = null;

    private singLeton() {
        System.out.println("单例模式");
    }

    public static synchronized singLeton getInstance() {

        if (sing==null) {
            sing = new singLeton();
        }

        return sing;
    }
}

【4】双层加锁的懒汉式单例模式

　　只有第一次sing为null的时候才进行线程锁，当后续sing不为null的时候就无需调用线程锁，可以允许多个线程同时拿走sing。

class singLeton{

    private static singLeton sing = null;
    private singLeton() {
        System.out.println("单例模式");
    }
    public static  singLeton getInstance() {
        System.out.println(singLeton.class);
        if(sing==null){
            synchronized (singLeton.class) {
                if (sing==null) {
                    sing = new singLeton();
                }
            }
        }
        return sing;
    }
}

【5】静态内部类单例模式【推荐使用】

　　将饿汉式的静态属性放到静态内部类中，getInstance()方法返回静态内部类的sing。解决了饿汉式提前占用资源的问题，解决了懒汉式线程不安全的问题。

class singLeton{

    private static class Singletion1{
        private static final singLeton sing = new singLeton();
    }

    private singLeton() {
        System.out.println("单例模式");
    }

    public static singLeton getInstance() {
        return Singletion1.sing;
    }

}