java常用类-下

一，Date类

表示特定的瞬间，精确到毫秒。

Date 类本质上拥有一个long fastTime属性的包装类，提供了很多属性和方法用于快速获取年月日、时分秒。而fastTime就是时间戳

（时间戳(timestamp):距离特定时间的时间间隔。

计算机时间戳是指距离历元(1970-01-01 00:00:00:000)的时间间隔(ms)）

基本的创建时间：

public static void main(String[] args) {
        // 创建时间
        Date date1=new Date();
        System.out.println(date1);
      //获取date1的时间戳
        long time1=date1.getTime();
        System.out.println(time1);
        //通过时间戳创建date对象
        long a=0;
        Date date2=new Date(a);
        System.out.println(date2);
        //需求，构建未来某一天的时间
        long b=date1.getTime()+24*3600*1000; //date1.getTime表示当前时间，后面的表示多一天的，多几天就*n
        Date date3=new Date(b);
        System.out.println(date3);
        
    }

时间日期的比较：

public static void main(String[] args) {
        //时间比较
        Date date1=new Date();
        Date date2=new Date(date1.getTime()+5000);
        System.out.println(date1.before(date2));
        System.out.println(date1.after(date2));
        System.out.println(date1.compareTo(date2));
        
        //setTime：改变date对象的时间戳
        date1.setTime(date1.getTime()+24*3600*1000); 
       System.out.println(date1);
       
    }

日期时间的格式化：

【1】把Date对象格式化成特定的字符串

public static void main(String[] args) {
        //把date对象格式化成特定的字符串
        Date date1=new Date();
        //使用默认的模式和环境语言转换
        SimpleDateFormat sd=new SimpleDateFormat();
        String str=sd.format(date1);
        System.out.println(str);
        
        //使用指定的模式
        SimpleDateFormat sd2=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        String str2=sd2.format(date1);
        System.out.println(str2);
        
        // 修改模式
        // df2.applyPattern("yyyy-MM-dd");
        sd2.applyPattern("yyyy/MM/dd");
        String dateStr3 = sd2.format(date1);
        System.out.println(dateStr3);    
    }

【2】把特定字符串解析成date对象

public static void main(String[] args) {
        //把特定的字符串解析成date对象
           String str="2019-04-29 20:52:00";
           SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
           try {
            Date date1=sd.parse(str);
            System.out.println(date1);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

二，calendar 日历类

Date本身很多方法在jdk1.1已经过时，jdk推荐使用Calendar取代Date获取单独的年、月、日、时、分、秒。

Calendar是日历类，本质上内部拥有一个属性 long time。 表示该日历所具体的时间戳。

同时Calendar内部通过对time的运算计算出很多日历字段，把这些日历字段存在一个容器中，并提供set/get方法用于设置或者访问这些字段

public static void main(String[] args) {
        // 工厂模式创建的日期(所有的日历属性都在里面了，只需要我们用方法取出来而已)
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);

        // 获取年
        System.out.println(cal.get(Calendar.YEAR));
        // 获取月，索引从0开始，0-表示1月 .和 获取日
        System.out.println(cal.get(Calendar.MONTH));
        System.out.println(cal.get(Calendar.DAY_OF_MONTH));
        // 时
        System.out.println(cal.get(Calendar.HOUR_OF_DAY));
        // 分
        System.out.println(cal.get(Calendar.MINUTE));
        // 秒
        System.out.println(cal.get(Calendar.SECOND));
        System.out.println(cal.get(Calendar.MILLISECOND));

        // 获取星期 一周的第一天是周日开始
        System.out.println(cal.get(Calendar.DAY_OF_WEEK));

        // 本月的第一天和本月的最后一天
        System.out.println(cal.getActualMinimum(Calendar.DAY_OF_MONTH));
        System.out.println(cal.getActualMaximum(Calendar.DAY_OF_MONTH));

    }

三，Math类

Math 类包含用于执行基本数学运算的方法。例如，随机数、平方、立方

public static void main(String[] args) {
        
        // 常用属性
        System.out.println(Math.PI);
        
        // 常用方法
        // 绝对值
        System.out.println(Math.abs(-10));
        
        // ceil/floor
        // 返回比10.1大的最小整数=> 向上取整
        System.out.println(Math.ceil(10.1));
        // 返回比10.1小的最大整数=> 向下取整
        System.out.println(Math.floor(10.1));
        
        
        // max/min
        System.out.println(Math.max(10, 20));
        System.out.println(Math.min(10, 20));
        
        // pow(x,y) x的y次方
        System.out.println(Math.pow(2, 3));
        
        
        // Math.random 随机数
        // 产生[m,n]随机整数 <=> (int)(Math.random()*(n-m+1)) + m

        //四舍五入
        System.out.println(Math.round(4.4));
        
        // 把弧度转角度
        System.out.println(Math.toDegrees(Math.PI/2));
        // 把角度转化成弧度
        System.out.println(Math.toRadians(180));
        
        // (C)sin(a)/cos(a)/tan(a)
        System.out.println(Math.sin(Math.toRadians(30)));

// 需求:求两点之间的距离（x1，y1）-（x2，y2）的距离。
        // Math.sqrt(Math.pow((y1-y2), 2)+Math.pow((x1-x2),2))
    }

四，枚举 类

枚举是由一组固定的常量组成的类型，自定义数据类型。语法:

[修饰符] enum enumName{
  常量值1,
  常量值2,
  常量值3，
    ...,
  常量值n[;]
}

枚举的常量值一定是可列举的有限值。常量值的类型都是public static final

枚举的本质也是一个类，隐性继承于Enum ，不过这个类基本只放一些常量类属性，不放方法。

Gender 是一种自定义的数据类型，可以用于声明变量，且变量的取值必须是枚举值的其中一个。

举例枚举声明：

public enum Gender {
    男,
    女,
    保密;
}

public static void main(String[] args) {    
        // 声明一个Gender枚举类型的变量gender,并取值为男
        Gender gender = Gender.男;
    }

枚举与字符串之间的相互转化：

public static void main(String[] args) {
        
        // 声明一个Gender枚举类型的变量gender,并取值为男
        Gender gender = Gender.男;
        
        
        // 枚举值->字符串
        System.out.println(gender.toString());
        
        // 字符串串-> 枚举值
        String str = "保密"; // 这个字符串必须是枚举列表里的数据
        // 可能产生IllegalArgumentException 非法参数异常
        Gender gender2 = Enum.valueOf(Gender.class, str);
        System.out.println(gender2);
        
    }

枚举与switch：

public static void main(String[] args) {
        Week week=Week.SATURDAY;
        switch (week) {
        case manday:
        case TUESDAY:
        case THURSDAY:
        case FRIDAY:
        case SATURDAY:{
            System.out.print("上课");
            break;}
        
        case WEDNESDAY:
        case SUNDAY:{
            System.out.print("自习");
            break;}
        }

    }

enum Week {
    manday,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY;
}

小结：个人感觉就是用更具体的变量名代替了之前switch中的type用数字的习惯，防止出现“魔鬼数字”（如下：之前的switch用法）

public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    switch (a) {
    case 1:
    case 2:
    case 4:
    case 5:
    case 6:{
        System.out.print("上课");
        break;
    }
    case 3:
    case 7:{
        System.out.print("自习");
        break;}
    }
    }

总结

1. 只能够取特定值中的一个
2. 使用enum关键字
3. 所有的枚举类型隐性地继承自 java.lang.Enum。（枚举实质上还是类！而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是public static final的。可以直接通过枚举类型名直接使用它们。）
4. 强烈建议当你需要定义一组常量时，使用枚举类型