【Java学习笔记】

最新推荐文章于 2024-08-06 10:22:43 发布
最新推荐文章于 2024-08-06 10:22:43 发布
阅读量802 收藏 18
点赞数 27
文章标签： java 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56612950/article/details/136307247
版权

API

JDK7以前时间相关类

1.Date-时间

  1. 时间相关知识点

    全世界的时间，有一个统一的计算标准。

    以前：格林尼治时间/格林威治时间（Greenwich Mean Time）简称GMT。

    计算核心：地球自转一天是24小时，太阳直射时为正午12点。

    现在：原子钟：利用铯原子的震动的频率计算出来的时间，作为世界标准时间（UTC）。

    中国标准时间：世界标准时间+8小时

    时间单位换算：1秒=1000毫秒 1毫秒=1000微秒 1微秒=1000纳秒

  2. Date时间类

    Date类是一个JDK写好的Javabean类，用来描述时间，精确到毫秒。

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

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

    public class Date {
    private long time;//当前时间的毫秒值

    public Date() {//空参构造方法
        this.time = System.currentTimeMillis();
    }

    public Date(long time) {//带参构造方法
        this.time = time;
    }

    public long getTime() {//get方法
        return time;
    }

    public void setTime(long time) {//set方法
        this.time = time;
    }
}

    public class DateDemo01 {
    public static void main(String[] args) {
        /*
            public Date()                   创建Date对象，表示当前时间
            public Date(long time)          创建Date对象，表示指定时间

            public void setTime(long time)  设置/修改毫秒值
            public long getTime()           获取时间对象的毫秒值
         */

        //1.创建对象表示一个时间
        Date d1 = new Date();
        System.out.println(d1);//Sat Feb 24 09:47:47 CST 2024

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

        //3.setTime 修改时间
        //1000毫秒 = 1秒
        d2.setTime(1000L);
        System.out.println(d2);//Thu Jan 01 08:00:01 CST 1970

        //4.getTime 获取当前时间的毫秒值
        long time = d2.getTime();
        System.out.println(time);//1000
    }
}

  3. 练习

    • 时间计算

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

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

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

        extracted();

        extracted1();
    }

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

        //创建两个时间对象
        Date d1 = new Date(Math.abs(r.nextInt()));
        Date d2= new Date(Math.abs(r.nextInt()));

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

        long time1 = d1.getTime();
        long time2 = d2.getTime();

        if(time1 > time2) {
            System.out.println("第一个时间在后面，第二个时间在前面");
        }else if (time1 < time2) {
            System.out.println("第二个时间在后面，第一个时间在前面");
        }else {
            System.out.println("两个时间一样");
        }
    }

    private static void extracted() {
        //需求1：打印时间原点开始一年之后的时间
        //1.创建一个对象，表示时间原点
        Date d1 = new Date(0L);

        //2.获取d1时间的毫秒值
        long time = d1.getTime();

        //3.在这个基础上加上一年的毫秒值即可
        time = time + 1000L * 60 * 60 * 24 * 365;

        //4.把计算之后的时间毫秒值再设置回d1当中
        d1.setTime(time);

        //5.打印d1
        System.out.println(d1);//Fri Jan 01 08:00:00 CST 1971
    }
}

2.SimpleDateFormat-格式化时间

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

  1. SimpleDateFormat类作用

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

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

    • 构造方法与常用方法

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

    • 格式化的时间形式的常用的模式对应关系如下：

      y-年/M-月/d-日/H-时/m-分/s-秒

      2023-11-11 13:27:06 / yyyy-MM-dd HH:mm:ss

      2023年11月11日 13:27:06 / yyyy年MM月dd日 HH:mm:ss

      public class SimpleDateFormatDemo01 {
    public static void main(String[] args) throws ParseException {
        /*
            public SimpleDateFormat()                 默认格式
            public SimpleDateFormat(String pattern)   指定格式

            public final String format(Date date)     格式化（日期对象->字符串）
            public Date parse(String source)          解析（字符串->日期对象）
         */

        //method();

        method1();
    }

    private static void method1() throws ParseException {
        //1.定义一个字符串表示时间
        String str = "2023-11-11 11:11:11";
        //2.利用空参构造创建SimpleDateFormat对象
        //细节：
        //创建对象的格式要跟字符串的格式完全一致
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse(str);
        //3.打印结果
        System.out.println(date.getTime());//1699672271000
    }

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

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

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

  2. 练习

    • 按照指定格式展示

      假设，你初恋的出生年月日为：2000-11-11

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

      public class SimpleDateFormatDemo02 {
    public static void main(String[] args) throws ParseException {
        /*
            假设，你初恋的出生年月日为：2000-11-11
            请用字符串表示这个数据，并将其转换为：2000年11月11日

            创建一个Date对象表示2000年11月11日
            创建一个SimpleDateFormat对象，并定义格式为年月日
            把时间变成：2000年11月11日
         */

        //1.可以通过2000-11-11进行解析，解析成一个Date对象
        String str = "2000-11-11";
        //2.解析
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf1.parse(str);
        //3.格式化
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");
        String result = sdf2.format(date);
        System.out.println(result);//2000年11月11日
    }
}

    • 秒杀活动

      秒杀开始时间：2023年11月11日 0:0:0

      秒杀结束时间：2023年11月11日 0:10:0

      需求：

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

      小皮下单并付款的时间为：2023年11月11日 0:11:0

      用代码说明这两位同学有没有参加上秒杀活动。

      public class SimpleDateFormatDemo03 {
    public static void main(String[] args) throws ParseException {
        /*
            秒杀开始时间：2023年11月11日 0:0:0
            秒杀结束时间：2023年11月11日 0:10:0
            需求：
            小贾下单并付款的时间为：2023年11月11日 0:01:00
            小皮下单并付款的时间为：2023年11月11日 0:11:0
            用代码说明这两位同学有没有参加上秒杀活动。
         */

        //1.比较两个时间(解析时间得到毫秒值)
        //下单并付款的时间 跟 开始时间  和  结束时间

        //2.定义字符串表示四个时间
        String startStr = "2023年11月11日 0:0:0";
        String endStr = "2023年11月11日 0:10:0";
        String orderStr1 = "2023年11月11日 0:01:0";
        String orderStr2 = "2023年11月11日 0:11:0";

        //3.解析上面的四个时间，得到Date对象
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date startDate = sdf1.parse(startStr);
        Date endDate = sdf1.parse(endStr);
        Date orderDate1 = sdf1.parse(orderStr1);
        Date orderDate2 = sdf1.parse(orderStr2);

        //3.得到四个时间的毫秒值
        long startTime = startDate.getTime();
        long endTime = endDate.getTime();
        long orderTime1 = orderDate1.getTime();
        long orderTime2 = orderDate2.getTime();

        //4.判断
        if(orderTime1 >= startTime && orderTime1 <= endTime) {
            System.out.println("小贾参加秒杀活动成功");
        }else {
            System.out.println("小贾参加秒杀活动失败");
        }

        if(orderTime2 >= startTime && orderTime2 <= endTime) {
            System.out.println("小皮参加秒杀活动成功");
        }else {
            System.out.println("小皮参加秒杀活动失败");
        }
    }
}

3.Calendar-日历

  1. Calendar概述

    • 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 field)取日历中的某个字段信息
    public void set(int field,int value)修改日历的某个字段信息
    public void add(int field,int amount)为某个字段增加/减少指定的值
    public class CalendarDemo01 {
    public static void main(String[] args) {
        /*
            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 field)                   取日历中的某个字段信息
            public void set(int field,int value)        修改日历的某个字段信息
            public void add(int field,int amount)       为某个字段增加/减少指定的值
         */

        //1.获取日历对象
        //细节1：Calendar是一个抽象类，不能直接new,而是通过一个静态方法获取到子类对象
        //底层原理：
        //会根据系统的不同时区来获取不同的日历对象,默认表示当前时间
        //会把时间中的纪元，年，月，日，时，分，秒，星期，等等的都放到一个数组当中
        //0：纪元
        //1：年
        //2：月
        //3：一年中的第几周
        //4：一个月中的第几周
        //5：一个月中的第几天（日期）
        //...
        
        //细节2：
        //月份：范围0~11 如果获取出来的是1，那么实际上是2月
        //星期：在老外的眼里，星期日是一周中的第一天
        //     1（星期日） 2（星期一） 3（星期二） 4（星期三） 5（星期四） 6（星期五） 7（星期六）
        Calendar c = Calendar.getInstance();
        //System.out.println(c);

        //2.修改一下日历代表的时间
        Date d = new Date(0L);
        c.setTime(d);
        System.out.println(c);

        //public int get(int field)                   取日历中的某个字段信息
        //public void set(int field,int value)        修改日历的某个字段信息
        //public void add(int field,int amount)       为某个字段增加/减少指定的值

        c.set(Calendar.YEAR,2023);
        c.set(Calendar.MONTH,8);
        c.set(Calendar.DAY_OF_MONTH,10);

        //调用方法在这个基础上减少一个月
        c.add(Calendar.MONTH,-1);

        //java在Calendar类中，把索引对应的数字都定义成常量
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int date = c.get(Calendar.DAY_OF_MONTH);
        int week = c.get(Calendar.DAY_OF_WEEK);
        System.out.println(year + "," + month + "," + date + "," + getWeek(week));//1970,1,1,星期四

    }

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

JDK8新增时间相关类

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

  1. 代码层面

    JDK7：代码麻烦——日期对象通过计算比较得到毫秒值

    JDK8：简单——判断的方法，计算时间间隔的方法

  2. 安全层面

    JDK7：多线程环境下会导致数据安全的问题

    JDK8：时间日期对象都是不可变的，解决了这个问题

2.JDK8时间

  1. Date类

    • ZoneId：时区

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

        //1.获取所有的时区名称
        Set<String> zoneIds = ZoneId.getAvailableZoneIds();
        System.out.println(zoneIds);
        System.out.println(zoneIds.size());//599

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

        //3.获取指定时区
        ZoneId zoneId1 = ZoneId.of("America/Cuiaba");
        System.out.println(zoneId1);//America/Cuiaba
    }
}

    • Instant：时间戳

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

        //1.获取当前时间的Instant对象（标准时间）
        //Instant now = Instant.now();
        //System.out.println(now);//2024-02-26T01:16:04.023Z

        //2.根据（秒/毫秒/纳秒）获取Instant对象
        Instant instant1 = Instant.ofEpochMilli(0L);
        System.out.println(instant1);//1970-01-01T00:00:00Z

        Instant instant2 = Instant.ofEpochSecond(1L);
        System.out.println(instant2);//1970-01-01T00:00:01Z

        Instant instant3 = Instant.ofEpochSecond(1L, 1000000000L);
        System.out.println(instant3);//1970-01-01T00:00:02Z

        //3.指定时区
        ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
        System.out.println(time);//2024-02-26T09:24:27.133+08:00[Asia/Shanghai]

        //4.isXxx 判断系列的方法
        Instant instant4 = Instant.ofEpochMilli(0L);
        Instant instant5 = Instant.ofEpochMilli(1000L);

        //5.用于时间的判断
        //isBefore:判断调用者代表的时间是否在参数表示时间的前面
        boolean result1 = instant4.isBefore(instant5);
        System.out.println(result1);//true

        //isAfter:判断调用者代表的时间是否在参数表示时间的后面
        boolean result2 = instant4.isAfter(instant5);
        System.out.println(result2);//false

        //6.Instant minusXxx(long millisToSubtract)  减少时间系列的方法
        Instant instant6 = Instant.ofEpochMilli(3000L);
        System.out.println(instant6);//1970-01-01T00:00:03Z

        Instant instant7 = instant6.minusSeconds(1);
        System.out.println(instant7);//1970-01-01T00:00:02Z
    }
}

    • ZoneDateTime：带时区的时间

      方法名说明
      static ZonedDateTime now()获取当前时间的ZonedDateTime对象
      static ZonedDateTime ofXxxx()获取指定时间的ZonedDateTime对象
      ZonedDateTime withXxx(时间)修改时间系列的方法
      ZonedDateTime minusXxx(时间)减少时间系列的方法
      ZonedDateTime plusXxx(时间)增加时间系列的方法
      public class ZonedDateTimeDemo01 {
    public static void main(String[] args) {
        /*
            static ZonedDateTime now()     获取当前时间的ZonedDateTime对象
            static ZonedDateTime ofXxxx()  获取指定时间的ZonedDateTime对象
            ZonedDateTime withXxx(时间)     修改时间系列的方法
            ZonedDateTime minusXxx(时间)    减少时间系列的方法
            ZonedDateTime plusXxx(时间)     增加时间系列的方法
         */

        //1.获取当前时间对象（带时区）
        ZonedDateTime now = ZonedDateTime.now();
        System.out.println(now);//2024-02-26T10:20:02.474+08:00[Asia/Shanghai]

        //2.获取指定的时间对象（带时区）
        //年、月、日、时、分、秒、纳秒方式指定
        ZonedDateTime time1 = ZonedDateTime.of(2023, 10, 1,
                11, 12, 12, 0,
                ZoneId.of("Asia/Shanghai"));
        System.out.println(time1);//2023-10-01T11:12:12+08:00[Asia/Shanghai]

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

        //3.withXxx(时间)     修改时间系列的方法
        ZonedDateTime time3 = time2.withYear(2000);
        System.out.println(time3);//2000-01-01T08:00+08:00[Asia/Shanghai]

        //4.减少时间
        ZonedDateTime time4 = time3.minusYears(1);
        System.out.println(time4);//1999-01-01T08:00+08:00[Asia/Shanghai]

        //5.增加时间
        ZonedDateTime time5 = time4.plusYears(1);
        System.out.println(time5);//2000-01-01T08:00+08:00[Asia/Shanghai]

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

  2. 日期格式化类（SimpleDateFormat）

    • DateTimeFormatter：用于时间的格式化和解析

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

        //获取时间对象
        ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
        System.out.println(time);//2024-02-26T10:39:23.999+08:00[Asia/Shanghai]

        //解析/格式化器
        DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EE a");
        //格式化
        System.out.println(dtf1.format(time));//2024-02-26 10:39:23 星期一 上午
    }
}

  3. 日历类（Calendar）

    • LocalDate：年、月、日

    • LocalTime：时、分、秒

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

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

      在这里插入图片描述

      方法名说明
      public LocalDate toLocalDate()LocalDateTime转换成一个LocalDate对象
      public LocalTime toLocalTime()LocalDateTime转换成一个LocalTime对象
      public static void main(String[] args) {
        //1.获取当前时间的日历对象（包含 年月日）
        LocalDate nowDate = LocalDate.now();
        System.out.println("今天的日期：" + nowDate);

        //2.获取指定时间的日历对象
        LocalDate ldDate = LocalDate.of(2023, 1, 1);
        System.out.println("指定日期：" + ldDate);

        //3.get系列方法获取日历中的每一个属性值
        //获取年
        int year = ldDate.getYear();
        System.out.println("year:" + year);

        //获取月
        //方式一：
        Month m = ldDate.getMonth();
        System.out.println(m);//JANUARY
        System.out.println(m.getValue());//1

        //方式二：
        int month = ldDate.getMonthValue();
        System.out.println("month：" + month);//month：1

        //获取日
        int day = ldDate.getDayOfMonth();
        System.out.println("day：" + day);

        //获取一年的第几天
        int dayOfYear = ldDate.getDayOfYear();
        System.out.println("dayOfYear：" + dayOfYear);

        //获取星期
        DayOfWeek dayOfWeek = ldDate.getDayOfWeek();
        System.out.println(dayOfWeek);
        System.out.println(dayOfWeek.getValue());

        //is开头的方法表示判断
        System.out.println(ldDate.isBefore(ldDate));
        System.out.println(ldDate.isAfter(ldDate));

        //with开头的方法表示修改，只能修改年月日
        LocalDate withLocalDate = ldDate.withYear(2000);
        System.out.println(withLocalDate);

        //minus开头的方法表示减少，只能减少年月日
        LocalDate minusLocalDate = ldDate.minusYears(1);
        System.out.println(minusLocalDate);

        //plus开头的方法表示增加，只能增加年月日
        LocalDate plusLocalDate = ldDate.plusDays(1);
        System.out.println(plusLocalDate);

        //--------------------------------
        //判断今天是否是你的生日
        LocalDate birDate = LocalDate.of(2000, 1, 1);
        LocalDate nowDate1 = LocalDate.now();

        MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
        MonthDay nowMd = MonthDay.from(nowDate1);
        System.out.println("今天是你的生日吗？" + birMd.equals(nowMd));//今天是你的生日吗？
    }
}

      public class LocalTimeDemo {
    public static void main(String[] args) {
        // 获取本地时间的日历对象。（包含时分秒）
        LocalTime nowTime = LocalTime.now();
        System.out.println("今天的时间：" + nowTime);

        int hour = nowTime.getHour();//时
        System.out.println("hour：" + hour);

        int minute = nowTime.getMinute();//分
        System.out.println("minute：" + minute);

        int second = nowTime.getSecond();//秒
        System.out.println("second：" + second);

        int nano = nowTime.getNano();//纳秒
        System.out.println("nano：" + nano);

        System.out.println("----------------------");
        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 mTime = LocalTime.of(8, 20, 30, 150);

        //is系列的方法
        System.out.println(nowTime.isBefore(mTime));
        System.out.println(nowTime.isAfter(mTime));

        //with系列的方法，只能修改时、分、秒
        System.out.println(nowTime.withHour(10));

        //minus系列的方法，减少时、分、秒
        System.out.println(nowTime.minusHours(10));

        //plus系列的方法，增加时、分、秒
        System.out.println(nowTime.plusHours(10));
    }
}

      public class LocalDateTimeDemo {
    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);
    }
}

  4. 工具类

    • Duration：时间间隔（秒、纳秒）——用于计算两个“时间”间隔（秒，纳秒）

    • Period：时间间隔（年、月、日）——用于计算两个“日期”间隔（年、月、日）

    • ChronoUnit：时间间隔（所有单位）——用于计算两个“日期”间隔

      public class DurationDemo {
    public static void main(String[] args) {
        //本地日期时间对象
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);//2024-02-26T15:14:26.949

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

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

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

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

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

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

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

        System.out.println("相差的时间间隔对象：" + period);//相差的时间间隔对象：P24Y1M25D
        System.out.println(period.getYears());//24
        System.out.println(period.getMonths());//1
        System.out.println(period.getDays());//25

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

      public class ChromoUnitDemo {
    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));
    }
}

包装类

1.什么是包装类？

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

2.如何理解包装类

public class Test {
    public static void main(String[] args) {
        int i = 10;
    }
}

用一个对象，把基本数据类型给包起来。

3.包装类

  • byte——Byte
  • short——Short
  • char——Character
  • int——Integer
  • long——Long
  • float——Float
  • double——Double
  • boolean——Boolean

  1. 获取Integer对象的方法（了解）

    方法名说明
    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对象
    public class IntegerDemo01 {
    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);//83

        //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

        Integer i10 = new Integer(127);
        Integer i11 = new Integer(127);
        System.out.println(i10 == i11);//false

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

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

        //需求：要把两个数据进行相加得到结果3
        //对象之间是不能直接进行计算的。
        //步骤：
        //1.把对象进行拆箱，变成基本数据类型
        //2.象假
        //3.把得到的结果再次进行装箱（再变回包装类）

        int result = i1.intValue() + i2.intValue();
        Integer i3 = new Integer(result);
        System.out.println(i3);
    }
}

    public class IntegerDemo03 {
    public static void main(String[] args) {
        //在JDK5的时候提出了一个机制：自动装箱和自动拆箱
        //自动装箱：基本数据类型会自动地变成其对应的包装类
        //自动拆箱：包装类会自动地变成其其对象的基本数据类型

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

        Integer i2 = new Integer(10);
        //自动拆箱的动作
        int i = i2;

        //在JDK5以后，int和Integer可以看作是同一个东西，因为在内部可以自动转换
    }
}

  2. Integer成员方法

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

        //1.把整数转成二进制
        String s1 = Integer.toBinaryString(100);
        System.out.println(s1);//1100100

        //2.把整数转成八进制
        String s2 = Integer.toOctalString(100);
        System.out.println(s2);//144

        //3.把整数转成十六进制
        String s3 = Integer.toHexString(100);
        System.out.println(s3);//64

        //4.将字符串类型的整数转成int类型的整数
        //强类型语言：每种数据在java中都有各自的数据类型
        //在计算的时候，如果不是同一种数据类型，是无法直接计算的
        int i = Integer.parseInt("123");
        System.out.println(i);//123
        System.out.println(i + 1);//124

        //细节1：
        //在类型转换的时候，括号中的参数只能是数字不能是其他，否则代码会报错
        //细节2：
        //8种包装类当中，除了Character都有对应的parseXxx的方法，进行类型转换
        String str = "true";
        boolean b = Boolean.parseBoolean(str);
        System.out.println(b);

        //改写键盘录入的代码
    }
}

    public class IntegerDemo05 {
    public static void main(String[] args) {
        //键盘录入
        Scanner sc = new Scanner(System.in);
        //System.out.println("请输入一个整数：");
        //int i = sc.nextInt();
        //System.out.println(i);

        //弊端：
        //当我们在使用next,nextInt,nextDouble在接收数据的时候，遇到空格，回车，制表符的时候就停止了
        //键盘录入的是123 123 那么此时只能接收到空格前面的数据
        //我想要的是接收一整行数据
        //约定：
        //以后如果想要键盘录入，不管什么类型，统一使用nextLine
        //特点遇到回车才停止
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        System.out.println(line);

    }
}

综合练习

  1. 键盘录入

    键盘录入一些1~100之间的整数，并添加到集合中。

    直到集合中所有数据和超过200为止。

    public class Test01 {
    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 < 1 || num > 100) {
                System.out.println("当前数字不在1~100的范围当中，请重新输入");
                continue;
            }
            //添加到集合中
            //细节：
            //num：基本数据类型
            //集合里面的数据是Integer
            //再添加数据的时候出发了自动装箱
            //list.add(Integer.valueOf(num))
            list.add(num);

            //统计集合中所有的数据和
            int sum = getSum(list);
            //对sum进行判断
            if(sum > 200) {
                System.out.println("集合中所有的数据和已经满足要求！");
                break;
            }
        }

        //验证一下结论
        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++) {
            //i: 索引
            //list.get(i);
            int num = list.get(i);
            sum = sum + num;
        }
        return sum;
    }
}

  2. 算法水题01

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

    要求：字符串中只能是数字不能有其他字符，最少一位，最多十位，不能以0开头

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

        //1.定义一个字符串
        String str = "123456789";
        //2.校验字符串
        //习惯：会先把异常数据进行过滤，剩下来就是正常的数据
        if(!str.matches("[1-9]\\d{0,9}")) {
            //错误的数据
            System.out.println("数据格式有误");
        }else {
            //正确的数据
            System.out.println("数据格式正确");

            //3.定义一个变量表示最终的结果
            int number = 0;
            //4.遍历字符串得到里面的每一个字符
            for (int i = 0; i < str.length(); i++) {
                int c = str.charAt(i) - '0';
                //'1'-'0'-->1
                //49 - 48   1
                number = number * 10 + c;
            }
            System.out.println(number);
            //System.out.println(number + 1);
        }
    }
}

  3. 算法水题02

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

    方法：

    除基取余法——不断地除以基数（几进制，基数就是几）得到余数，直到商为0，再将余数倒着拼起来即可。

    public class Test03 {
    public static void main(String[] args) {
        /*
            定义一个方法自己实现toBinaryString方法的效果，
            将一个十进制整数转成字符串表示的二进制
            方法：
            除基取余法——不断地除以基数（几进制，基数就是几）得到余数，
            直到商为0，再将余数倒着拼起来即可。
         */
        
        System.out.println(toBinaryString(6));
    }

    public static String toBinaryString(int number) {
        //核心逻辑：不断地除以2，得到余数，一直到商为0为止
        //还需要把余数倒着拼接起来

        //定义一个StringBuilder用来拼接余数
        StringBuilder sb = new StringBuilder();

        //利用循环不断地除以2获取余数
        while(true) {
            if(number == 0) {
                break;
            }
            //获取余数 %
            int remaindar = number % 2;
            System.out.println(remaindar);
            //倒着拼接
            sb.insert(0,remaindar);
            //除以2
            number = number / 2;
        }
        return sb.toString();
    }
}

  4. 算法水题03

    请使用代码实现计算你活了多少天，用JDK7和JDK8两种方式完成

    public class Test04 {
    public static void main(String[] args) throws ParseException {
        /*
            请使用代码实现计算你活了多少天，用JDK7和JDK8两种方式完成
         */

        //JDK7
        //规则：只要对时间进行计算，都需要先获取当前时间的毫秒值
        //1.计算出出生年月日的毫秒值
        String birthday = "2000年1月1日";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date date = sdf.parse(birthday);
        long birthdayTime = date.getTime();

        //2.获取当前时间的毫秒值
        long todayTime = System.currentTimeMillis();
        //3.计算时间间隔多少天
        long time = todayTime - birthdayTime;
        System.out.println(time / 1000 / 60 / 60 / 24);


        //JDK8
        LocalDate ld1 = LocalDate.of(2000, 1, 1);
        LocalDate ld2 = LocalDate.now();

        long days = ChronoUnit.DAYS.between(ld1, ld2);
        System.out.println(days);
    }
}

  5. 算法水题04

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

    要求：用JDK7和JDK8两种方式判断

    提示：闰年二月有29天（一年366天），平年二月有28天

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

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

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

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

说明：

以上笔记学习是学习b站黑马程序员时记下的笔记，仅限于帮助理解学习，不做任何其他商业用途。

黑马程序员

无浪484
关注
  • 27
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java入门第97课——使用setTime和getTime方法操作时间毫秒
Java学习博客
10-16 1875
码字不易，请大家关注公众号，转发，点赞，只需动动手指，不要钱，谢谢了老铁！ 问题 使用setTime和getTime方法操作毫秒表示的日期-时间，详细要求如下： 1)获取1970年1月1日零时距当前时刻的毫秒数。 2)获取明天此时此刻的日期-时间。 方案 1)首先，实例化Date类的对象获取当前日期-时间，代码如下所示： Datedate=ne...
JAVA处理日期（Date）时间（Time）以及相关类的介绍
热门推荐
JonnyWei的专栏
02-28 4万+
JAVA处理日期时间常用方法： 1.    java.util.Calendar Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:0
Java中set time方法_java中常用的时间操作
weixin_36123285的博客
02-26 3510
最近项目设计时间的转换和计算，长时间没用时间操作了，感觉手有点生，所以在这里记录一下：Date常用的方法： getTime() 、setTime()；SimpleDateFormate 常用的方法： Formate(Date)、parse(String s)；Calendar常用的方法：getInstance()、set() 、get()、getActualMaximum()、add()、...
java中settime_Java sql.Time setTime()方法与示例
weixin_39996234的博客
02-16 793
setTime()java.util.Time类的方法接受一个long类型的变量，该变量表示从纪元时间(1970年1月1日00：00：00.000 GMT)到所需时间的毫秒数，并将指定的时间值设置为当前时间对象//设定时间time.setTime(time_value_in_long);示例让我们使用CREATE语句在MySQL数据库中创建一个带有名称调度的表，如下所示：CREATETABLE...
java settime_Java日历setTime（）方法及示例
cumudi0723的博客
07-18 4191
java settime 日历类setTime()方法 (Calendar Class setTime() method) setTime() method is available in java.util package. setTime()方法在java.util包中可用。 setTime() method is used to sets time with the specified Da...
java中settime_Java Calendar setTime()用法及代码示例
weixin_32284931的博客
02-16 1928
Calendar类中的setTime(Date dt)方法用于设置此Calendar的时间值表示的Calendars时间，并以给定或通过的日期为参数。用法:public final void setTime(Date dt))参数：该方法采用Date类型的一个参数dt表示要设置的给定日期。返回值：该方法不返回任何值。以下示例程序旨在说明Calendar类的setTime()方法的用法：示例1://...
java.util.Date.setTime()方法实例
whalefall
09-13 9001
转载地址：https://www.yiibai.com/java/util/date_settime.html java.util.Date.setTime(long time) 方法设置此日期1970年1月1日00:00:00 GMT后，来显示时间的毫秒。 声明 以下是java.util.Date.setTime()方法的声明 public void setTime(long ti...
java学习笔记
csdnlxk98的博客
04-26 812
第一个Java程序Java语言的平台                JavaSE                                 JVM：保证Java语言跨平台 JavaME--Android                JRE：Java程序的运行环境         JavaEE                                 JDK：Java程序的开发环境 ...
JAVA学习笔记
NASA诺亚方舟
05-22 236
JAVA学习笔记 一 JDK安装 1.1环境变量配置 1.1.1 永久配置环境变量 打开方式：计算机-高级-环境变量 JAVA_HOME：自己建的系统变量，添加到JDK目录即可 //切记，不是用户变量 path：系统默认环境变量，添加两个bin文件，jdk\bin和jdk\jre\bin classpath：执行class文件时，指定优先搜索java类的存放路径 1.1.2 临时配...
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
java Date.setTime时间设置逆流
nuistcc的专栏
05-05 2662
       业务开发过程中需要对java.util.Date的时间进行设置，使用了void java.util.Date.setTime(long time)方法，但在测试过程中却发现millisecond超过某一定长度后出现了“逆流”，时间出现了回退现象。   现象描述        （1）我们先看一下正常情况下的例子，将当天时间增加10天   public static voi...
JavaScript的Date对象的setTime（）与setDate（）方法之间的区别
秋天未成熟的博客
04-15 9753
Date对象的setTime（）与setDate（）方法之间的区别 1、setTime（）方法 setTime（）方法以毫秒设置Date对象； dateObject.setTime(millisec)； millisec：必需，填写的毫秒数。最终向以1970-01-01为基准，添加millisec后，并重新计算显示新的日期和时间。 2、setDate（）方法 setDate()方法用于...
setTimeStamp()与setDate()区别
殷建卫
11-03 6832
原文链接：http://blog.csdn.net/t12x3456/article/details/7649629 1. java.sql.Date 与 java.util.Date java.sql.Date是从java.util.Date中继承而来 假设 dates1（java.sql.Date）要赋值给dates2(java.util.Date) 可以通过如下转换进行 dates2=
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 475
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 251
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1309
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
枚举工具类
qq_43049583的博客
08-04 466
java枚举工具类
Java学习笔记：从入门到精通
"这是一份详尽的Java学习笔记电子书，特别适合初学者。书中内容细致入微，涵盖了从基础到进阶的各种知识点，通过图片形式生动地展示了Java编程的核心概念。" 在Java学习过程中，了解对象的概念是至关重要的。粗粒度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值