JAVASE-16：常见对象Date类、SimpleDateFormat类、Calendar类、BigInteger类

最新推荐文章于 2022-03-20 19:57:43 发布

绝世球王秃光光

最新推荐文章于 2022-03-20 19:57:43 发布

阅读量190

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/hannen/article/details/107801035

版权

JavaSE 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

Date类

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

构造方法
空参构造：public Date()
有参构造：public Date(long date)
把一个long类型的毫秒值转换成一个日期对象（给计算机元年1970 01-01加上时间，形式是毫秒分时，填入括号中）

public static void main(String[] args) {
    // 类 Date 表示特定的瞬间，精确到毫秒
    Date date = new Date();
    // Sun Aug 02 09:15:27 CST 2020
    System.out.println(date);
    /* Date( long date)
    分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，
    即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。*/
    // 给 1970 年 1 月 1 日 00:00:00 计算机元年加上相应的时间量
    Date date1 = new Date(1000*60*60);
    // Fri Jan 02 08:00:00 CST 1970
    System.out.println(date1); // Thu Jan 01 09:00:00 CST 1970
}

成员方法

1.获取当前系统毫秒值：public long getTime() ，获取计算机元年到当前的毫秒值

2.给计算机元年加时间：public void setTime(long time)，方法和有参构造一样，例：date.setTime(1000 * 60 * 60)

3.一些过时方法也可以用，如.getYear() .getMonth()

注解：标注过时对类或方法 @Deprecated

public static void main(String[] args) {
    Date date = new Date();
    //获取从 1970 年 1 月 1 日 00:00:00 到现在 所间隔的毫秒值
    long time = date.getTime();
    
    long l = System.currentTimeMillis();

    System.out.println(time);// 1596520947754
    System.out.println(l);// 1596520947754

    System.out.println("==============================");

    Date date2 = new Date();
    date2.setTime(1000*60*60*24);
    System.out.println(date2);// Fri Jan 02 08:00:00 CST 1970
    
    System.out.println(date.getYear());// 120
    //月份由从 0 至 11 的整数表示；0 是一月、1 是二月等等；因此 11 是十二月
    System.out.println(date.getMonth());
    MyUtils myUtils = new MyUtils();// 7
    myUtils.add();
}

Date、long类型相互转换

public static void main(String[] args) {
    //Date-----long
    Date date = new Date();
    long time = date.getTime();
    
    //long-----Date
    //方式1
    Date date1 = new Date(1000 * 60);//传入毫秒值
	//方式2
    Date date2 = new Date();
    date2.setTime(200000);
}

SimpleDateFormat类实现日期和字符串的相互转换

设置时间表示格式-格式化日期的类

构造方法:

空参构造： new SimpleDateFormat(); 按照默认格式进行格式化

有参构造：new SimpleDateFormat(“yyyy-MM-dd HH-mm-ss”);

规则的定义	-
y	年
M	月
d	天
H	时
m	分
s	秒
E	星期

成员方法:
public String format(Date date): 把一个日期对象格式化成一个字符串
public Date parse(String dateStr): 把一个日期字符串解析成一个日期对象注意要以指定格式解析

public static void main(String[] args) {
    Date date = new Date();
    System.out.println(date);
    //Tue Aug 04 14:11:41 CST 2020

    //格式化日期的一个类，可以按照我们自己喜欢的日期格式，进行格式化
    //空参构造，是按照默认格式，进行格式化
    SimpleDateFormat dateFormat = new SimpleDateFormat();
    //format(date); 把日期格式化成一个字符串
    String dateStr = dateFormat.format(date);
    System.out.println(dateStr);// 20-8-4 下午2:11

    System.out.println("============================================");
    //按照我们指定的 格式来进行格式化
    SimpleDateFormat dateFormat2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E D");
    String format = dateFormat2.format(date);
    System.out.println(format);// 2020年08月04日 14时11分41秒 星期二 217
}

String转换成Date 日期字符串解析成日期对象：
new SimpleDateFormat(与要转的String字符串格式一致);
调方法 .parse();

public static void main(String[] args) throws ParseException {
    //Date----String format(date);
    //String----Date parse(str);
    String str="2020-01-01 16:30:30";
    //注意：日期字符串和指定的格式要对应
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //把日期字符串，解析成日期对象。
    Date date = dateFormat.parse(str);
    System.out.println(date);// Wed Jan 01 16:30:30 CST 2020
}

public class DateUtils {
    private DateUtils() {
    }
    //把日期对象格式成日期字符串
    public static String convertDateToString(String format){
        Date date = new Date();
        String format1 = new SimpleDateFormat(format).format(date);
        return format1;
    }

    //把日期字符串转成日期对象
    public static Date convertStringToDate(String dateStr, String format) throws ParseException {
        Date date= new SimpleDateFormat(format).parse(dateStr);
        return date;
    }
}

案例演示：算一下你来到这个世界多少天?
分析：

a: 键盘录入一个生日(日期字符串)
b: 把这个日期字符串对象解析成一个日期对象
c: 获取b中的日期对象对应的毫秒值
d: 获取当前系统时间对应的毫秒值
e: 使用d中的毫秒值 - c中的毫秒值
f: 把e中的差值换算成对应的天差值/1000/60/60/24
g: 输出

public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的生日：例如 1990-01-01");
        String birthday = sc.nextLine();
        long time = new SimpleDateFormat("yyyy-MM-dd").parse(birthday).getTime();
       //long time = DateUtils.convertStringToDate(birthday, "yyyy-MM-dd").getTime();
        long now = System.currentTimeMillis();
        System.out.println((now - time) / 1000 / 60 / 60 / 24/365+"年");
        System.out.println("=====================================================");
        //JDK1.8 提供的关于日期的类
        LocalDate birthdayDate = LocalDate.of(1997, 03, 23);
        LocalDate nowDate = LocalDate.now();
        Period period = Period.between(birthdayDate, nowDate);
        int years = period.getYears();
        int months = period.getMonths();
        int days = period.getDays();
        System.out.println(years);// 23
        System.out.println(months);// 4
        System.out.println(days);// 12
    }

Calendar类

Calendar 类是一个抽象类，不能直接new对象，可以通过他的一个静态成员方法getInstance()来获取他的对象它为特定瞬间与一组诸如 YEAR、MONTH DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

成员方法

public static Calendar getInstance() 使用默认时区和语言环境获得一个日历对象
Calendar.getInstance();

public int get(int field)获得给定日历字段对应的值 field通过
.get(Calender.YEAR);
.get(Calender.MONTH);
.get(Calender.DAY_OF_MONTH);

public static void main(String[] args) {
    Calendar rightNow = Calendar.getInstance();
    //System.out.println(rightNow);
    int year = rightNow.get(Calendar.YEAR);
    int month = rightNow.get(Calendar.MONTH);
    int day = rightNow.get(Calendar.DAY_OF_MONTH);
    int hour = rightNow.get(Calendar.HOUR);
    int minute = rightNow.get(Calendar.MINUTE);
    int s = rightNow.get(Calendar.SECOND);
    System.out.println(year + " "+month + " "+day + " "+hour + " "+minute + " "+s);
    // 2020 7 4 2 38 13
}

Calendar提供的字段来拿
public void add(int field,int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量
.add(Calendar.YEAR,2);
.add(Calendar.MONTH,1);

public final void set(int year,int month,int date) 设置日历时间年月日
.set(Calendar.YEAR,2018);
.set(Calendar.MONTH,10);

public static void main(String[] args) {
    Calendar instance = Calendar.getInstance();
    //设置对应的日期。
    instance.set(Calendar.YEAR,2018);
    instance.set(Calendar.MONTH, 10);
    instance.set(Calendar.DAY_OF_MONTH,10);
    System.out.println(instance.get(Calendar.YEAR));//2018
    System.out.println(instance.get(Calendar.MONTH));//10
    System.out.println(instance.get(Calendar.DAY_OF_MONTH));//10
    System.out.println("========================================");

    Calendar instance2 = Calendar.getInstance();
    //add(Calendar.YEAR,-2); 给对应的日期。添加或减去相应的时间量 你传入负数，就是减去。
    instance2.add(Calendar.YEAR,-2);
    System.out.println(instance2.get(Calendar.YEAR));//2018
}

案例演示：
Calendar类的成员方法使用，判断是否是闰年 .isLeapYear();

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入年份");
    int year = sc.nextInt();
    /*  //判断闰年
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
        System.out.println("是闰年");
    }
    */

    /* @Override
    public boolean isLeapYear ( long prolepticYear){
        return ((prolepticYear & 3) == 0) && ((prolepticYear % 100) != 0 || (prolepticYear % 400) == 0);
    }*/
	//方法1
    //把这个日期设置为这一年的3月1号
    //然后再减去1天。
    Calendar cal = Calendar.getInstance();
    cal.set(year,2,1);
    cal.add(Calendar.DAY_OF_MONTH,-1);
    int i = cal.get(Calendar.DAY_OF_MONTH);
    System.out.println(i);

    System.out.println("=============================");
    //方法2
    LocalDate of = LocalDate.of(2020, 01, 01);
    //判断是否是闰年
    boolean b = of.isLeapYear();
    System.out.println(b);

}

BigInteger类

可以计算超过long范围的数据

构造方法
public BigInteger(String val)

成员方法
public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger val)
public BigInteger divide(BigInteger val)
public BigInteger[] divideAndRemainder(BigInteger val)

使用示例：

BigInteger bi1=new BigInteger("100");
BigInteger bi2=new BigInteger("2");
System.out.println(bi1.add(bi2));   //+
System.out.println(bi1.subtract(bi2));   //-
System.out.println(bi1.multiply(bi2));   //*
System.out.println(bi1.divide(bi2));    //(除)
BigInteger[] arr=bi1.divideAndRemainder(bi2);    //取除数和余数
for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
}

public static void main(String[] args) {
    // BigInteger概述 可以计算超过long范围的数据
    /* long max=Long.MAX_VALUE;
    System.out.println(max+1);*/
    BigInteger a = new BigInteger(Long.MAX_VALUE + "");
    BigInteger b = new BigInteger(Long.MAX_VALUE + "");
    BigInteger add = a.add(b);
    System.out.println(add);
}