Java学习笔记===》11.JDK相关类

最新推荐文章于 2024-08-23 15:54:50 发布

kinbow_0923

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量123

点赞数

分类专栏：学习笔记文章标签： java 学习笔记

本文链接：https://blog.csdn.net/m0_59318477/article/details/131091764

版权

学习笔记专栏收录该内容

30 篇文章 2 订阅

订阅专栏

JDK相关类

一、JDK7以前时间相关类

Date 时间

（1）世界标准时间

①格林威治时间/格林尼治时间（Greenwich Mean Time）简称GMT

②目前世界标准时间（UTC）已经替换为：原子钟

（2）中国标准时间

世界标准时间+8小时

（3）时间换算单位

1秒 = 1000毫秒

1毫秒 = 1000微秒

1微秒 = 1000纳秒

1.Date时间类

★Date时间类是一个JDK已经写好的JavaBean类，用来描述时间，精确到毫秒

★利用空参构造创建的对象，默认表示系统当前的时间

★利用有参构造创建的对象，表示指定的时间

（1）关于Date时间类的方法

方法	说明
public Date()	创建Date对象，表示当前时间
public Date( long date)	创建Date对象，表示指定时间
public void setTime(long time)	设置/修改毫秒值
public long getTime()	获取事件对象的毫秒值

package com_04_myAPI.API09_JDK_DATE;

import java.util.Date;

public class test01_Date {
    public static void main(String[] args) {

        //创建对象表示一个时间
        Date d1 = new Date();
        System.out.println(d1); //Fri Apr 21 20:32:22 HKT 2023

        //创建对象表示一个指定的时间
        Date d2 = new Date(0L);
        System.out.println(d2); //Thu Jan 01 08:00:00 HKT 1970

        //setTime  修改时间
        d2.setTime(10000000L);
        System.out.println(d2); //Thu Jan 01 10:46:40 HKT 1970

        //getTime  获取时间
        long time = d2.getTime();
        System.out.println(time);   //10000000
    }
}

练习

（1）需求1：打印时间原点开始一年之后的时间

（2）需求2：定义任意两个Date对象，比较一下哪个时间在前，哪个时间在后

package com_04_myAPI.API09_JDK_DATE;

import java.util.Date;
import java.util.Random;

public class test02 {
    public static void main(String[] args) {
        /*
        （1）需求1：打印时间原点开始一年之后的时间
        （2）需求2：定义任意两个Date对象，比较一下哪个时间在前，哪个时间在后
         */

        //1.创建一个时间对象,表示时间原点
        Date d1 = new Date(0L);
        //2.获取d1时间的毫秒值形式
        long t1 = d1.getTime();
        //3.在这个基础上，我们要加一年的毫秒值
        t1 = t1 + 1000L * 60 * 60 * 24 * 365;
        //4.把计算之后的时间毫秒值，再设置回d1
        d1.setTime(t1);
        //打印d1
        System.out.println(d1);



        //（2）需求2：定义任意两个Date对象，比较一下哪个时间在前，哪个时间在后
        Random r = new Random();

        Date d2 = new Date(Math.abs(r.nextInt()));
        Date d3 = new Date(Math.abs(r.nextInt()));

        if (d2.getTime() > d3.getTime()){
            System.out.println("第一个时间在后，第二个时间在前面");
        }else if (d2.getTime() < d3.getTime()){
            System.out.println("第一个时间在前面，第二个时间在后面");
        }else {
            System.out.println("两个时间是同一时间");
        }
    }
}

（2）Date时间类小结

①如何创建日期对象

★Date date = new Date();

★Date date = new Date(指定毫秒值);

②如何修改时间对象中的毫秒值

★setTime（毫秒值）；

③如何获取时间对象中的毫秒值

★getTime（）；

2.SimpleDateFormat 格式化时间

（1）作用：

①格式化：把时间变成我们喜欢的格式

2023年10月1日 /2023-10-1/2023/10/1

②解析：把字符串表示的时间变成Date对象

（2）SimpleDateFormat类方法

构造方法	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat，使用指定的格式
常用方法	说明
public final String format(Date date)	格式化（日期对象==》字符串）
public Date parse(String source)	解析（字符串===》日期对象）

（3）格式化时间形式的常用的模式对应关系

日期
2023-11-11 13:13:13	yyyy-MM-DD HH:mm:ss
2023年11月11日 13:13:13	yyyy年MM月dd日 HH:mm:ss
y ===》年	M ===》月
d ===》日	H ===》时
m ===》分	是===》秒

package com_04_myAPI.API09_JDK_DATE;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class test03_SimpleDateFormat {
    public static void main(String[] args) throws ParseException {
        /*
| 构造方法                                  | 说明                                     |
| --------------------------------------- | ---------------------------------------- |
| public  SimpleDateFormat()              | 构造一个SimpleDateFormat，使用默认格式   |
| public SimpleDateFormat(String pattern) | 构造一个SimpleDateFormat，使用指定的格式 |
| 成员方法                                  | 说明                                 |
| public final String format(Date date)   | 格式化（日期对象==》字符串）             |
| public Date parse(String source)        | 解析（字符串===》日期对象）              |
         */

        //设置格式
        Method1();

        //解析
        //定义一个时间字符串、
        String date1 = "2023-11-11 13:13:13";
        String date2 = "2023年11月11日 13:13:13";
        //1.利用空参构造创建SimpleDateFormat对象，
        //细节：创建的对象的格式要和字符串的格式完全一致，否则会报错
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date d1 = sdf1.parse(date1);
        Date d2 = sdf2.parse(date2);

        System.out.println(d1);
        System.out.println(d2);


    }

    private static void Method1() {
        //1.利用空参构造创建SimpleDateFormat对象，默认格式
        SimpleDateFormat sdf1 = new SimpleDateFormat();
        Date d1 = new Date(0L);
        String str1 = sdf1.format(d1);
        System.out.println(str1);   //1970/1/1 上午8:00

        //2.利用带参构造创建SimpleDateFormat对象，默认格式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date d2 = new Date(0L);
        String str2 = sdf2.format(d2);
        System.out.println(str2);   //1970年01月01日 08:00:00

        //课堂练习  yyyy年MM月dd日 时:分:秒  星期
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE");
        Date d3 = new Date(0L);
        String str3 = sdf2.format(d1);
        System.out.println(str3);      // 1970年01月01日 08:00:00 星期四
    }
}

（4）练习

需求：

假设，一个人的出生年月日为：2000-11-11

请用字符串表示这个数据，并将其转换为2000年11月11日

package com_04_myAPI.API09_JDK_DATE;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class test04 {
    public static void main(String[] args) throws ParseException {
        /*
        需求：
        假设，一个人的出生年月日为：2000-11-11
        请用字符串表示这个数据，并将其转换为2000年11月11日
         */
        String s1 = "2000-11-11";
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        Date d1 = sdf1.parse(s1);
        System.out.println(d1);
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");
        String str = sdf2.format(d1);
        System.out.println(str);

    }
}

需求：

某品牌秒杀活动开始时间为：2023年11月11日00：00：00，结束时间为2023年11月11日 00：10：00

①小贾下单并付款的时间为：2023年11月11日 00：01：00

②小张下单并付款的时间为：2023年11月11日00：11：00

用代码说明谁没有参加上秒杀活动

package com_04_myAPI.API09_JDK_DATE;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class test05 {
    public static void main(String[] args) throws ParseException {
        /*
        需求：
        某品牌秒杀活动开始时间为：2023年11月11日00：00：00，结束时间为2023年11月11日 00：10：00
        ①小贾下单并付款的时间为：2023年11月11日 00：01：00
        ②小张下单并付款的时间为：2023年11月11日00：11：00
        用代码说明谁没有参加上秒杀活动
         */
        //比较两个时间
        //下单比你高付款的时间 跟 开始时间 和 结束时间 比较

        //比较两个时间
        String start = "2023年11月11日 00:00:00";
        String end = "2023年11月11日 00:10:00";
        String jiaOrder ="2023年11月11日 00:01:00";
        String zhangOrder ="2023年11月11日 00:11:00";


        //创建SimpleDateFromat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date startDate = sdf.parse(start);
        Date endDate = sdf.parse(end);
        Date jia = sdf.parse(jiaOrder);
        Date zhang = sdf.parse(zhangOrder);


        //获取时间的毫秒值
        long startTime = startDate.getTime();
        long endtTime = endDate.getTime();
        long jiaTime = jia.getTime();
        long zhangTime = zhang.getTime();


        if (zhangTime >= startTime && zhangTime <= endtTime){
            System.out.println("参加秒杀成功");
        }else{
            System.out.println("参加秒杀失败");
        }


        if (jiaTime >= startTime && jiaTime <= endtTime){
            System.out.println("参加秒杀成功");
        }else{
            System.out.println("参加秒杀失败");
        }

    }
}

（5）小结：

①SimpleDateFormat的两个作用

★格式化

★解析

②如何指定格式

★yyyy年MM月dd日 HH：mm：ss

3.Calendar 日历

为什么要学习calendar？

应用场景：

需求：将2023年11月11日增加一个月

（1）概述

★calendar类代表了系统当前时间的日历对象，可以单独修改、获取事件中的年、月、日

★细节：calendar是一个抽象类，不能直接创建对象

（2）获取calendar日历类对象的方法

★public static Calendar getInstance(); 获取当前时间的日历对象

（3）Calendar常用方法

方法	说明
public final Date getTime();	获取日期对象
public final setTime(Date date)	给日历设置日期对象
public long getTimeInMillis()	拿到时间毫秒值
Public void setTimeInMillis(long millis)	给日历设置时间毫秒值
public int get(int filed)	取日历中的某个字段信息
public void set (int filed,int value)	修改日历的某个字段信息
public void add（int filed,int amount）	为某个字段增加/减少指定的值

package com_04_myAPI.API10_Calendar;

import java.util.Calendar;
import java.util.Date;

public class test01 {
    public static void main(String[] args) {
        /*
    （2）获取calendar日历类对象的方法
public  static  Calendar getInstance();     获取当前时间的日历对象

| 方法                                      | 说明                        |
| ----------------------------------------- | --------------------------- |
| public final Date getTime();              | 获取日期对象                |
| public final setTime(Date date)           | 给日历设置日期对象          |
| public long getTimeInMillis()             | 拿到时间毫秒值              |
| Public void setTimeInMillis(long  millis) | 给日历设置时间毫秒值        |
| public int get(int filed)                 | 取日历中的某个字段信息      |
| public void set (int filed,int value)     | 修改日历的某个字段信息      |
| public void add（int filed,int amount）   | 为某个字段增加/减少指定的值 |
         */

        //1.获取日历对象
        //细节1：
        //Calendar是一个抽象类，不能直接new，而是通过一个静态方法获取到子类对象
        //底层原理：会根据系统的不同时区来获取不同的日历对象,默认表示当前时间
        //把事件中的纪元，年，月，日，时，分，秒，星期，等等放到一个数组当中
        //每个索引所代表的的含义
        //0：纪元       1：年      2：月       3：一年中的第几周      4：一个月中的第几周
        //5：一个月中的第几天（日期）    6：

        //细节2：
        //月份：范围0-11，如果获取的月份是0，那么实际月份是0，也就是实际月份等于获取到的月份+1
        //星期：在老外的眼里，星期日是一周中的第一天1（星期日），2（星期一），3(星期二)，4（星期三），5（星期四），6（星期五），7（星期六）
        Calendar c1 = Calendar.getInstance();
        System.out.println(c1);

        //2.获取日期对象
        Date time = c1.getTime();
        System.out.println(time);

        //3.给日历设置日期对象
        Date date = new Date(1000*10^11L);
        c1.setTime(date);
        System.out.println(c1);

        //4.拿到时间的毫秒值
        long timeInMillis = c1.getTimeInMillis();
        System.out.println(timeInMillis);

        //5.给日历设置时间毫秒值
        c1.setTimeInMillis(10*10^20L);
        System.out.println(c1);

        //6.取日历中的某个字段信息
        int year = c1.get(Calendar.YEAR);
        int month = c1.get(Calendar.MONTH)+1;
        int dt = c1.get(Calendar.DAY_OF_MONTH);
        int week = c1.get(Calendar.DAY_OF_WEEK);
        System.out.println(year+"年"+month+"月"+dt+"日"+getWeek(week));

        //7.修改日历的某个字段信息
        c1.set(Calendar.YEAR,1999);
        System.out.println(c1);

        //8.为某个字段增加/减少指定的值
        c1.add(Calendar.YEAR,-12);
        System.out.println(c1);
    }

    //查表法：
    //表：容器
    //让数据和索引产生对应关系
    public static String getWeek(int index){
        //定义一个数组，让汉字星期几和数字1-7产生对应关系
        String [] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
        //根据索引返回对应的星期
        return arr[index];
    }
}

（4）Calendar日历类小结

1.Calendar表示什么？

★表示一个时间的日历对象

2.如何获取对象

★通过getInstance方法获取对象

3.常见方法

★setXxx ：修改

★getXxx ：获取

★add：在原有的基础上进行增加或减少

4.细节

★日历类中月份的范围：0-11，平常书写月份+1

★日历类中兴起的特点：星期日是一周中的第一天

二、JDK8新增时间相关类

为什么要学JDK8新增相关时间类呢？

	代码层面	安全层面
JDK 7	代码麻烦》日期对象(计算、比较) ==》毫秒值	在多线程环境下会导致数据安全的问题
JDK 8	简单 ==》1.判断的方法 2.计算时间间隔的方法	时间日期对象都是不可变的，解决了这个问题（不会改变原有的数据，会新建一个时间日期对象存储新的数据）

1.JDK8新增类

（1）DATE类

①ZoneeId ：时区

书写：洲名/城市名国家名/城市名

例如：Asia/Shanghai Asia/Taipei Asia/Chongqing

方法名	说明
static Set< String > getAvailableZoneIds()	获取Java中支持的所有时区
static ZoneId systemDefault（）	获取系统默认时区
static ZoneId of(String zoneId)	获取一个指定时区

package com_04_myAPI.API11_JDK8_increase;

import java.time.ZoneId;
import java.util.Set;

public class ZoneIdTest01 {
    public static void main(String[] args) {
        /*
| 方法名                                      | 说明                     |
| ------------------------------------------- | ------------------------ |
| static Set< String >  getAvailableZoneIds() | 获取Java中支持的所有时区 |
| static ZoneId systemDefault（）             | 获取系统默认时区         |
| static ZoneId of(String zoneId)             | 获取一个指定时区         |
         */

        //1.获取所有的时区名称
        Set<String> z1 = ZoneId.getAvailableZoneIds();
        //这里会得到一个Set集合，但是这个集合没有索引，所以不能使用for循环遍历
        System.out.println(z1);
        System.out.println(z1.size());

        //2.获取当前系统的默认时区
        ZoneId z2 = ZoneId.systemDefault();
        System.out.println(z2);

        //3.获取一个指定的时区
        ZoneId z3 = ZoneId.of("America/New_York");
        System.out.println(z3);
    }
}

②Instant ：时间戳

方法名	说明
static Instance now()	获取当前时间的I你Stance对象（标准时间）
static Instance ofXxxx(long epochMilli)	根据（秒/毫秒/纳秒）获取Instant对象
ZonedDateTime atZone（ZoneId zone）	指定时区
boolean isXxxx(Instant otherInstant)	判断系列的方法
Instandt minusXxxx（long millisTosubTract）	减少时间系列的方法
Instant plusXxxx（long millisToSubtract）	增加时间系列的方法

package com_04_myAPI.API11_JDK8_increase;

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class Test02_Instant {
    public static void main(String[] args) {
        /*
        | 方法名                                      | 说明                                    |
| ------------------------------------------- | --------------------------------------- |
| static Instance now()                       | 获取当前时间的Instance对象（标准时间） |
| static Instance ofXxxx(long epochMilli)     | 根据（秒/毫秒/纳秒）获取Instant对象     |
| ZonedDateTime atZone（ZoneId zone）         | 指定时区                                |
| boolean isXxxx(Instant otherInstant)        | 判断系列的方法                          |
| Instandt minusXxxx（long millisTosubTract） | 减少时间系列的方法                      |
| Instant plusXxxx（long millisToSubtract）   | 增加时间系列的方法                      |
         */


        //1.获取当前时间的Instance对象（标准时间）
        Instant i1 = Instant.now();
        System.out.println(i1);

        //2.根据（秒/毫秒/纳秒）获取Instant对象(从时间原点开始获取)
        Instant i2 = Instant.ofEpochMilli(100L*100^100);
        Instant i3 = Instant.ofEpochSecond(100L*100^100);    //根据秒获取对象
        Instant i4 = Instant.ofEpochSecond(100L*100^100,100L*100^100); //根据秒、纳秒获取对象
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);

        //3.指定时区
       ZonedDateTime zdt =  Instant.now().atZone(ZoneId.of("America/New_York"));
        System.out.println(zdt);

        //4.判断系列的方法
        Instant i5 = Instant.ofEpochMilli(0L);
        Instant i6 = Instant.ofEpochSecond(10000L);    //根据秒获取对象

        //用于时间的判断
        //isAfter：判断调用者代表的时间是否在参数表示时间的后面
        boolean result1 = i5.isAfter(i6);
        //isBefore：判断调用者代表的时间是否在参数表示时间的前面
        boolean result2 = i5.isBefore(i6);
        System.out.println(result1);
        System.out.println(result2);


        //5.减少时间系列的方法
        Instant i7 = Instant.ofEpochMilli(0L);
        System.out.println(i7);     //1970-01-01T00:00:00Z
        Instant i8 = i7.minusMillis(1000^20L);
        System.out.println(i8);     //1969-12-31T23:59:58.980Z

        //增加时间系列的方法
        Instant i9 = Instant.ofEpochMilli(0L);
        System.out.println(i9);     //1970-01-01T00:00:00Z
        Instant i10 = i9.plusMillis(10000000000L);
        System.out.println(i10);     //1970-04-26T17:46:40Z
    }
}

③ZoneDateTime ：带时区的时间

方法名	说明
static ZonedDateTime now()	获取当前时间的ZonedDateTime对象
static ZonedDateTime ofXxx(…)	获取指定时间的ZonedDateTime对象
ZonedDateTime withXxxx(时间)	修改时间系列的方法
ZonedDateTime minusXxxx（时间）	减少时间系列的方法
ZonedDateTime plusXxxx（时间）	增加时间系列的方法

package com_04_myAPI.API11_JDK8_increase;

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class Test03_ZonedDateTime {
    public static void main(String[] args) {
        /*
| 方法名                          | 说明                            |
| ------------------------------- | ------------------------------- |
| static ZonedDateTime now()      | 获取当前时间的ZonedDateTime对象 |
| static ZonedDateTime ofXxx(...) | 获取指定时间的ZonedDateTime对象 |
| ZonedDateTime withXxxx(时间)    | 修改时间系列的方法              |
| ZonedDateTime minusXxxx（时间） | 减少时间系列的方法              |
| ZonedDateTime plusXxxx（时间）  | 增加时间系列的方法              |
         */

        //1.获取当前时间对象（带时区）
        ZonedDateTime z1 = ZonedDateTime.now();
        System.out.println(z1);     //2023-04-22T16:54:50.664307200+08:00[Asia/Shanghai]

        //2.获取指定时间的对象（带时区）
        //年月日时分秒纳秒方式指定
        ZonedDateTime z2 = ZonedDateTime.of(2023,4,19,20,29,45,000234, ZoneId.of("Asia/Shanghai"));
        System.out.println(z2);     //2023-04-19T20:29:45.000000156+08:00[Asia/Shanghai]

        //3.通过Instant+时区的方式指定获取的时间对象
        Instant instant = Instant.ofEpochMilli(0L);
        ZoneId zoneId = ZoneId.of("Asia/Shanghai");
        ZonedDateTime z3 = ZonedDateTime.ofInstant(instant,zoneId);
        System.out.println(z3);     //1970-01-01T08:00+08:00[Asia/Shanghai]


        //4.修改系列时间
        ZonedDateTime z4 = z3.withYear(2023);       //2023-01-01T08:00+08:00[Asia/Shanghai] 将年份修改为2023
        //还可以修改年月日时分秒星期等等
        System.out.println(z4);     //2023-04-22T22:58:58.222929100+08:00[Asia/Shanghai]

        //5.减少时间
        ZonedDateTime z5 = z4.minusMonths(2);       //将月份减少两个月
        //还可以修改年月日时分秒星期等等
        System.out.println(z5);     //2022-11-01T08:00+08:00[Asia/Shanghai]

        //6.增加时间
        ZonedDateTime z6 = z5.plusYears(10);        //将年份增加10年
        //还可以修改年月日时分秒星期等等
        System.out.println(z6);     //2032-11-01T08:00+08:00[Asia/Shanghai]

        //细节：
        //JDK8新增的事件对象都是不可变的
        //如果我们修改了，减少了，增加了时间
        //那么调用者是不会发生改变的
        //而是会产生一个新的时间
    }
}

（2）日期格式化类

①DateTimeFoematter ：用于时间的格式化和解析

方法名	说明
static DateTimeFormatter ofPattern()	获取格式对象
String format(时间对象)	按照指定方式格式化

package com_04_myAPI.API11_JDK8_increase;

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class Test04_DateTimeFormatter {
    public static void main(String[] args) {
        /*
| 方法名                               | 说明               |
| ------------------------------------ | ------------------ |
| static DateTimeFormatter ofPattern() | 获取格式对象       |
| String format(时间对象)              | 按照指定方式格式化 |
         */

        //1.获取时间对象
        ZonedDateTime z1 = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));

        //解析/格式化
        DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss EEEE a");
        //格式化
        String time = dtf1.format(z1);
        System.out.println(time);       //2023年04月22日 17:25:57 星期六 下午
    }
}

（3）日历类

①LocalDate ：年、月、日

②LocalTime：时、分、秒

③LocalDateTime ：年、月、日、时、分、秒

方法名	说明
static XXX now()	获取当前时间的对象
static XXX of(…)	获取指定时间的对象
get开头的方法	获取日历中的年、月、日、时、分、秒等信息
isBefore，isAfter	比较两个LocalDate谁在前谁在后
with开头的	修改时间系列的方法
minus开头的	减少时间系列的方法
plus开头的	增加时间系列的方法

LocalDateTime转换===》LocalDate/LocalTime
方法名	说明
public LocalDate toLocalDate()	LocalDateTime转换成一个LocalDate对象
public LocalTime toLocalTime()	LocalDateTime转换成一个LocalTime对象

package com_04_myAPI.API11_JDK8_increase;

import java.time.LocalDate;
import java.time.Month;
import java.time.MonthDay;

public class Test05_LocalDate {
    public static void main(String[] args) {
/*
| 方法名             | 说明                                     |
| ------------------ | ---------------------------------------- |
| static XXX now()   | 获取当前时间的对象                       |
| static XXX of(...) | 获取指定时间的对象                       |
| get开头的方法      | 获取日历中的年、月、日、时、分、秒等信息 |
| isBefore，isAfter  | 比较两个LocalDate谁在前谁在后            |
| with开头的         | 修改时间系列的方法                       |
| minus开头的        | 减少时间系列的方法                       |
| plus开头的         | 增加时间系列的方法                       |

| LocalDateTime转换===》LocalDate/LocalTime |                                      |
| ----------------------------------------- | ------------------------------------ |
| 方法名                                    | 说明                                 |
| public LocalDate toLocalDate()            | LocalDateTime转换成一个LocalDate对象 |
| public LocalTime toLocalTime()            | LocalDateTime转换成一个LocalTime对象 |
 */

        //1.获取当前时间的日历对象
        LocalDate ldt1 = LocalDate.now();
        System.out.println("今天的日期为："+ldt1);     //今天的日期为：2023-04-22T17:46:58.722469

        //2.获取指定的日历对象
        LocalDate ldt2 = LocalDate.of(2023,12,11);
        System.out.println(ldt2);       //2023-12-11T13:12

        //3.get系列方法获取日历中的每一个属性值
        //获取年
        int year = ldt2.getYear();
        //获取月（方式1）
        Month month = ldt2.getMonth();
        System.out.println("获取到的年份为"+year);     //获取到的年份为2023
        System.out.println("获取到的月份为"+month);        //获取到的月份为DECEMBER
        //方式2
        int mon = ldt2.getMonthValue();
        System.out.println("获取到的月份为"+mon);      //获取到的月份为12


        //4.is开头的方法表示判断
        System.out.println(ldt2.isBefore(ldt1));        //false
        System.out.println(ldt2.isAfter(ldt1));     //true

        //5.with开头的方法表示修改，只修改年月日
        LocalDate ldt3 = ldt2.withYear(2099);
        System.out.println(ldt3);       //2099-12-11T13:12

        //6.minus开头的方法表示减少，只能减少年月日
        LocalDate ldt4 = ldt3.minusYears(20);
        System.out.println(ldt4);       //2079-12-11T13:12

        //7.plus开头的方法表示增加，只能增加年月日
        LocalDate ldt5 = ldt3.plusYears(20);
        System.out.println(ldt5);       //2119-12-11T13:12


        //练习：判断今天是不是自己的生日
        LocalDate birthday = LocalDate.of(2000,12,18);
        LocalDate today = LocalDate.now();
        MonthDay check = MonthDay.of(birthday.getMonthValue(),birthday.getDayOfMonth());
        MonthDay now = MonthDay.from(today);

        System.out.println("今天是你的生日吗"+birthday.equals(now));
    }
}

package com_04_myAPI.API11_JDK8_increase;

import java.time.LocalTime;

public class Test06_LocalTime {
    public static void main(String[] args) {
        //1.获取本地的日历对象（包含时分秒）
        LocalTime lt1 = LocalTime.now();
        System.out.println("当前时间为"+lt1);

        //2.get获取
        int hour = lt1.getHour();
        int minute = lt1.getMinute();
        int second = lt1.getSecond();
        int nano = lt1.getNano();
        System.out.println("当前是"+hour+"时"+minute+"分"+second+"秒"+nano+"纳秒");

        //3.指定时间
        System.out.println(LocalTime.of(8,20));
        System.out.println(LocalTime.of(8,20,30));
        System.out.println(LocalTime.of(8,20,30,150));
        LocalTime lt2 = LocalTime.of(8,20,30,150);

        //4.is的用法
        System.out.println(lt1.isAfter(lt2));
        System.out.println(lt1.isBefore(lt2));

        //5.with修改(只能修改时分秒)
        System.out.println(lt2.withHour(12));

        //6.minus减少时间(只能修改时分秒)
        System.out.println(lt2.minusMinutes(23));

        //7.plus增加时间(只能修改时分秒)
        System.out.println(lt2.plusSeconds(100));

    }
}

package com_04_myAPI.API11_JDK8_increase;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Test07_LocalDateTime {
    public static void main(String[] args) {
        // 当前时间的的日历对象(包含年月日时分秒)
        LocalDateTime nowDateTime = LocalDateTime.now();

        System.out.println("今天是:" + nowDateTime);//今天是：
        System.out.println(nowDateTime.getYear());//年
        System.out.println(nowDateTime.getMonthValue());//月
        System.out.println(nowDateTime.getDayOfMonth());//日
        System.out.println(nowDateTime.getHour());//时
        System.out.println(nowDateTime.getMinute());//分
        System.out.println(nowDateTime.getSecond());//秒
        System.out.println(nowDateTime.getNano());//纳秒
        // 日:当年的第几天
        System.out.println("dayofYear:" + nowDateTime.getDayOfYear());
        //星期
        System.out.println(nowDateTime.getDayOfWeek());
        System.out.println(nowDateTime.getDayOfWeek().getValue());
        //月份
        System.out.println(nowDateTime.getMonth());
        System.out.println(nowDateTime.getMonth().getValue());

        LocalDate ld = nowDateTime.toLocalDate();
        System.out.println(ld);

        LocalTime lt = nowDateTime.toLocalTime();
        System.out.println(lt.getHour());
        System.out.println(lt.getMinute());
        System.out.println(lt.getSecond());
    }
}

（4）工具类

①Duration ：时间间隔（秒、纳秒）

package com_04_myAPI.API11_JDK8_increase;

import java.time.LocalDate;
import java.time.Period;

public class Test08_Period {
    public static void main(String[] args) {
        // 当前本地 年月日
        LocalDate today = LocalDate.now();
        System.out.println(today);

        // 生日的 年月日
        LocalDate birthDate = LocalDate.of(2000, 1, 1);
        System.out.println(birthDate);

        Period period = Period.between(birthDate, today);//第二个参数减第一个参数

        System.out.println("相差的时间间隔对象:" + period);
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());

        System.out.println(period.toTotalMonths());
    }
}

②Period ：时间间隔（年、月、日）

package com_04_myAPI.API11_JDK8_increase;

import java.time.Duration;
import java.time.LocalDateTime;

public class Test09_Duration {
    public static void main(String[] args) {
        // 本地日期时间对象。
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        // 出生的日期时间对象
        LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1, 0, 0, 0);
        System.out.println(birthDate);

        Duration duration = Duration.between(birthDate, today);//第二个参数减第一个参数
        System.out.println("相差的时间间隔对象:" + duration);

        System.out.println("============================================");
        System.out.println(duration.toDays());//两个时间差的天数
        System.out.println(duration.toHours());//两个时间差的小时数
        System.out.println(duration.toMinutes());//两个时间差的分钟数
        System.out.println(duration.toMillis());//两个时间差的毫秒数
        System.out.println(duration.toNanos());//两个时间差的纳秒数
    }
}

③ChronoUnit ：时间间隔，所有单位

package com_04_myAPI.API11_JDK8_increase;

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class Test10_ChronoUnit {
    public static void main(String[] args) {
        // 当前时间
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);
        // 生日时间
        LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1,
                0, 0, 0);
        System.out.println(birthDate);

        System.out.println("相差的年数:" + ChronoUnit.YEARS.between(birthDate, today));
        System.out.println("相差的月数:" + ChronoUnit.MONTHS.between(birthDate, today));
        System.out.println("相差的周数:" + ChronoUnit.WEEKS.between(birthDate, today));
        System.out.println("相差的天数:" + ChronoUnit.DAYS.between(birthDate, today));
        System.out.println("相差的时数:" + ChronoUnit.HOURS.between(birthDate, today));
        System.out.println("相差的分数:" + ChronoUnit.MINUTES.between(birthDate, today));
        System.out.println("相差的秒数:" + ChronoUnit.SECONDS.between(birthDate, today));
        System.out.println("相差的毫秒数:" + ChronoUnit.MILLIS.between(birthDate, today));
        System.out.println("相差的微秒数:" + ChronoUnit.MICROS.between(birthDate, today));
        System.out.println("相差的纳秒数:" + ChronoUnit.NANOS.between(birthDate, today));
        System.out.println("相差的半天数:" + ChronoUnit.HALF_DAYS.between(birthDate, today));
        System.out.println("相差的十年数:" + ChronoUnit.DECADES.between(birthDate, today));
        System.out.println("相差的世纪(百年)数:" + ChronoUnit.CENTURIES.between(birthDate, today));
        System.out.println("相差的千年数:" + ChronoUnit.MILLENNIA.between(birthDate, today));
        System.out.println("相差的纪元数:" + ChronoUnit.ERAS.between(birthDate, today));
    }
}

2.小结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6cPYaX7w-1686128382616)(D:\java笔记\笔记图片\JDK8新增类.png)]

三、包装类

包装类：基本数据类型对应的引用数据类型（对象）

内存：

在这里插入图片描述

通俗的说，就是用一个对象将基本数据类型给包起来

1.常用的包装类

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
boolean	Boolean
long	Long
float	Float
double	Double

在JDK5以前需要我们主动去创建获取对象

package com_04_myAPI.API12_Wrap;

public class Test01_Integer_beforeJDK5 {
    public static void main(String[] args) {
        /*
            public Integer(int value) 根据传递的整数创建一个Integer对象
            public Integer(String s) 根据传递的字符串创建一个Integer对象
            public static Integer valueOf(int i) 根据传递的整数创建一个Integer对象
            public static Integer valueof(String s) 根据传递的字符串创建一个Integer对象
            public static Integer valueof(String s, int radix) 根据传递的字符串和进制创建一个Integer对象
        */

        //1.利用构造方法获取Integer的对象(JDK5以前的方式)
        Integer i1 = new Integer(1);
        Integer i2 = new Integer("1");
        System.out.println(i1);
        System.out.println(i2);

        //2.利用静态方法获取Integer的对象(JDK5以前的方式)
        Integer i3 = Integer.valueOf(123);
        Integer i4 = Integer.valueOf("123");
        Integer i5 = Integer.valueOf("123", 8);

        System.out.println(i3);
        System.out.println(i4);
        System.out.println(i5);

        //3.这两种方式获取对象的区别(掌握)
        //底层原理：
        //因为在实际开发中，-128~127之间的数据，用的比较多。
        //如果每次使用都是new对象，那么太浪费内存了
        //所以，提前把这个范围之内的每一个数据都创建好对象
        //如果要用到了不会创建新的，而是返回已经创建好的对象。
        Integer i6 = Integer.valueOf(127);
        Integer i7 = Integer.valueOf(127);
        System.out.println(i6 == i7);//true

        Integer i8 = Integer.valueOf(128);
        Integer i9 = Integer.valueOf(128);
        System.out.println(i8 == i9);//false

        //因为看到了new关键字，在Java中，每一次new都是创建了一个新的对象
        //所以下面的两个对象都是new出来，地址值不一样。
        Integer i10 = new Integer(127);
        Integer i11 = new Integer(127);
        System.out.println(i10 == i11);

        Integer i12 = new Integer(128);
        Integer i13 = new Integer(128);
        System.out.println(i12 == i13);
    }
}

package com_04_myAPI.API12_Wrap;

public class Test02_Intrger {
    public static void main(String[] args) {
        //在以前，包装类如何进行计算
        Integer i1 = new Integer(1);
        Integer i2 = new Integer(2);

        //要把两个数据进行相加得到结果
        //注意对象之间按不能直接进行计算的
        //步骤：
        //1.把对象进行拆箱，变成基本数据类型

        //2.进行计算
        //3.把得到的结果再进行装箱
        int sum = i1.intValue()+i2.intValue();
        Integer i3 = new Integer(sum);
        System.out.println(i3);
    }
}

package com_04_myAPI.API12_Wrap;

public class Test03_Integer_AfterJDK5 {
    public static void main(String[] args) {
        //再jdk5的时候提出了一个机制：自动装箱、自动拆箱
        //自动装箱：把基本数据类型会自动的变成其对应的包装类
        //自动拆箱：将包装类自动的变成其基本数据类型

        Integer i1 = 10;    //自动装箱动作
        //在底层，此时还会自动调用静态方法valueof得到一个Integer对象，只不过这个动作不需要我们自己去操作了

        Integer i2 = new Integer(10);

        int i = i2;  //自动拆箱动作

        //在JDK5以后interesting和integer可以看作是同一个东西，因为在内部可以自动转化

    }
}

2.包装类的作用：

（1）什么是包装类

基本数据类型对应的对象

（2）JDK5以后对包装类新增了什么特性

自动装箱、自动拆箱

（3）我们以后如何获取包装类对象？

不需要new，不需要调用方法，直接赋值即可

3.Integer成员方法

方法名	说明
public static String toBinaryString(int i)	得到二进制
public static String toOctslString(int i)	得到八进制
public static String toHexString(int i)	得到十六进制
public static int parseInt(String s)	将字符串类型的整数转换成int类型的整数

package com_04_myAPI.API12_Wrap;

public class Test04_Integer {
    public static void main(String[] args) {
/*
| 方法名                                     | 说明                                  |
| ------------------------------------------ | ------------------------------------- |
| public static String toBinaryString(int i) | 得到二进制                            |
| public static String toOctslString(int i)  | 得到八进制                            |
| public static String toHexString(int i)    | 得到十六进制                          |
| public static int parseInt(String s)       | 将字符串类型的整数转换成int类型的整数 |
 */

        //1.把证整数转成二进制
        String er = Integer.toBinaryString(100);
        1.把证整数转成八进制
        String ba = Integer.toOctalString(100);
        1.把证整数转成十六进制
        String sixteen = Integer.toHexString(100);

        System.out.println(er);
        System.out.println(ba);
        System.out.println(sixteen);

        //将字符串类型的整数转换成int类型的整数
        //在Java中，Java是一门强类型语言，也就是每种数据在Java中都有各自的数据类型
        //在计算的时候，如果不是同一种书类型，是无法直接计算的
        int i = Integer.parseInt("1000");
        System.out.println(i);
        //细节1：在类型转换的时候，括号中的参数只能是数字不能是其他，否则代码会报错
        //细节2：8中包装类中，除了Character都有对应的parseXxx的方法，进行类型转换

        String str = "239.98";
        float f = Float.parseFloat(str);
        System.out.println(f);

        

    }
}

小练习

package com_04_myAPI.API12_Wrap;

import java.util.Scanner;

public class Test05_Warp_Scanner {
    public static void main(String[] args) {
        //改写键盘录入的代码
        //键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        /* String str = sc.next();
        System.out.println(str);*/
        //弊端:
        //当我们在使用next，nextInt，nextDouble在接收数据的时候，遇到空格，回车，制表符的时候就停止了
        //键盘录入的是123 123 那么此时只能接收到空格前面的数据
        //我想要的是接收一整行数据
        //约定:
        //以后我们如果想要键盘录入，不管什么类型，统一使用nextLine
        //特点:遇到回车才停止
        String line = sc.nextLine();
        System.out.println(line);
        double v = Double.parseDouble(line);
        System.out.println(v);
    }
}

四、综合练习

1.键盘录入一些1-100之间的数据，并添加加到集合当中，直到集合中所有数据的和超过200为止

package com_04_myAPI.API12_Wrap;

import java.util.ArrayList;
import java.util.Scanner;

public class Test06_pratice1 {
    public static void main(String[] args) {
        /*
    需求：.键盘录入一些1-100之间的数据，并添加加到集合当中，直到集合中所有数据的和超过200为止
     */

        //1.创建一个集合用来添加数据
        ArrayList<Integer> list = new ArrayList();
        //2.创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //接受键盘录入的数据添加到集合
        while (true){
            System.out.println("请输入一个整数");
            String numStr = sc.nextLine();
            int num = Integer.parseInt(numStr);
            if(num<0 || num>100){
                System.out.println("当前输入的数据超出1-100的范围，请重新输入");
                continue;
            }else{
                //添加到集合当中
                //细节：这里的num是基本数据类型，集合里面的数据是Integer
                //在添加数据的时候出发了自动装箱
                list.add(num);  //list.add（Integer.valueOf(num)）;  这里的两句代码效果是一样的
                //统计集合中所有的数据和
                int sum = getSum(list);
                if (sum>200){
                    System.out.println("集合中所有的数据和满足要求");
                    break;
                }else {
                    continue;
                }
            }
        }
        //验证：遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    private static int getSum(ArrayList<Integer> list) {
        int sum = 0;
        for (int i = 0; i < list.size(); i++) {
            int num = list.get(i);
            sum += num;
        }
        return sum;
    }
}

2.实现parseInt方法的效果，将字符串形式的数据转成整数。

要求：字符串只能是数字不能有其他字符

最少一位，最多10位，不能以0开头

package com_04_myAPI.API12_Wrap;

import java.util.Scanner;

public class Test07_pratice2 {
    public static void main(String[] args) {
        /*
        需求：2.实现parseInt方法的效果，将字符串形式的数据转成整数。
        要求：字符串只能是数字不能有其他字符
        最少一位，最多10位，不能以0开头
         */

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一串数字");
        String str = sc.nextLine();
        //先校验错误的数据
        if (!str.matches("[1-9]\\d{0,9}")){
            System.out.println("格式有误");
            //再书写数据正确的情况下的代码
        }else{
            System.out.println("数据格式正确");
            //定义一个变量，表示最终的结果
            int number = 0;
            //遍历字符串得到里面的每一个字符
            for (int i = 0; i < str.length(); i++) {
                int num = str.charAt(i) - '0';
                //System.out.print(num+",");
                //再将每一位数字放到number中
                number = number * 10 + num;       
            }
            System.out.println(number);
        }
    }
}

3.定义一个方法试下toBinaryString方法的效果，将一个十进制数转成字符串表示的二进制

解题思路：除基取余法

不断地除以基数（几进制，基数就是几），得到余数

知道商为0，再将余数倒着拼起来即可

package com_04_myAPI.API12_Wrap;

public class Test08_pratice3 {
    public static void main(String[] args) {
        /*

            定义一个方法自己实现toBinaryString方法的效果，将一个十进制整数转成字符串表示的二进制

         */
        System.out.println(tobinarystring(123));
        System.out.println(Integer.toBinaryString(123));
    }


    public static String tobinarystring(int number) {//6
        //核心逻辑:
        //不断的去除以2，得到余数，一直到商为日就结束。
        //还需要把余数倒着拼接起来

        //定义一个StringBuilder用来拼接余数
        StringBuilder sb = new StringBuilder();
        //利用循环不断的除以2获取余数
        while (true) {
            if (number == 0) {
                break;
            }
            //获取余数 %
            int remaindar = number % 2;//倒着拼接
            sb.insert(0, remaindar);
            //除以2 /
            number = number / 2;
        }
        return sb.toString();
    }
}

4.请用代码实现计算你活了多少天，用jdk7和jdk8两种完成

package com_04_myAPI.API12_Wrap;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.Date;

public class Test09_pratice {
    public static void main(String[] args) throws ParseException {
        //请用代码实现计算你活了多少天，用jdk7和jdk8两种完成

        //jdk7
        //规则：只要对时间进行计算或者判断，都需要先获取当前时间的毫秒值

        //1.计算出生年月日的毫秒值
        String birthday = "2000年12月28日";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date date = sdf.parse(birthday);
        long birthdayTime = date.getTime();
        System.out.println(birthdayTime);
        //2.当前时间的毫秒值
        long now = System.currentTimeMillis();

        //计算
        long lifeDate = (now - birthdayTime)/1000/60/60/24;
        System.out.println("我一共活了"+lifeDate+"天");


        //jdk8
        LocalDate ld1 = LocalDate.of(2000,12,28);
        LocalDate ld2 = LocalDate.now();

        long days = ChronoUnit.DAYS.between(ld1, ld2);
        System.out.println("我一共活了"+days+"天");

    }
}

5.判断任意的一个年份是闰年还是平年

要求：用jdk7和jdk8两种方式判断

提示：二月有29天是闰年

一年有366天是闰年

package com_04_myAPI.API12_Wrap;

import java.time.LocalDate;
import java.util.Calendar;

public class Test10_pratice {
    public static void main(String[] args) {
        /*
            判断任意的一个年份是闰年还是平年要求:用JDK7和JDK8两种方式判断提示:
            二月有29天是闰年一年有366天是闰年
        */

        //jdk7
        //我们可以把时间设置为2000年3月1日
        Calendar c = Calendar.getInstance();
        c.set(2000, 2, 1);
        //月份的范围:0~11
        //再把日历往前减一天
        c.add(Calendar.DAY_OF_MONTH, -1);
        //看当前的时间是28号还是29号?
        int day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);


        //jdk8
        //月份的范围:1~12
        //设定时间为2000年的3月1日
        LocalDate ld = LocalDate.of(2001, 3, 1);
        //把时间往前减一天
        LocalDate ld2 = ld.minusDays(1);
        //获取这一天是一个月中的几号
        int day2 = ld2.getDayOfMonth();
        System.out.println(day2);

        //true:闰年
        //false:平年
        System.out.println(ld.isLeapYear());


    }
}

kinbow_0923

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记===》11.JDK相关类

★calendar类代表了系统当前时间的日历对象，可以单独修改、获取事件中的年、月、日★细节：calendar是一个抽象类，不能直接创建对象基本数据类型对应的对象解题思路：除基取余法不断地除以基数（几进制，基数就是几），得到余数知道商为0，再将余数倒着拼起来即可/*定义一个方法自己实现toBinaryString方法的效果，将一个十进制整数转成字符串表示的二进制//6 //核心逻辑: //不断的去除以2，得到余数，一直到商为日就结束。
复制链接

扫一扫