【java基础】你真懂API包装类吗? (W字详解)

2年前 (2022) 程序员胖胖胖虎阿

349 0 0

🍈一.前言

大家好😄本人双非科班大一菜鸟，自学java中，文章如果有误的地方，欢迎各位大佬交流指正探讨，一起共同进步🌈🌈🌈

文章目录

🍈一.前言
🍉二.math
🥝三.system
🥥四.object
🍇五.冒泡排序
🍊六.array类
🍋七.基本数据类型包装类
🍌八.Date日期类
🍒九.Calendar

🍉二.math

🥇1.首先来介绍一下Api是什么?
Api指的是JDK中提供的各种功能的java类，这些类将底层的实现封装了起来，而是我们要学习这些类的使用
🥈2.math常用的方法(jdk文档）

🥉3.让我们看一下代码案例:

public class Test {
    public static void main(String[] args) {
        /* 1.math类 是没有系统公开访问 构造函数
           2.math类 无参构造函数直接私有化 无法new math类
           3.math类 提供的api访问都加上static使用该方法 通过类名称.方法名称访问
         */
      // Math math = new Math();
        //绝对值
        System.out.println(Math.abs(-33));
        System.out.println(Math.abs(66));
        System.out.println("----------------");
        // 如果不为 整数 该数+1返回 整数就返回本身
        System.out.println(Math.ceil(22.96));
        System.out.println(Math.ceil(44.21));
        System.out.println(Math.ceil(66.00));
        System.out.println("----------------");
        // 为整数 返回它的整数值 不为则返回整数， 不要小数值
        System.out.println(Math.floor(54.67));
        System.out.println(Math.floor(46.32));
        System.out.println(Math.floor(66.00));
        System.out.println("----------------");
        // 四舍五入
        System.out.println(Math.round(66.66));
        System.out.println(Math.round(35.25));
        System.out.println(Math.round(99.00));
        System.out.println("----------------");
        // 比较 最大值
        System.out.println(Math.max(43,57));
        System.out.println(Math.max(66.56,22.22));
        System.out.println("-----------------");
        //比较 最小值
        System.out.println(Math.min(44,89));
        System.out.println(Math.min(99.45,66.22));
        System.out.println("------------------");
        //次幂
        System.out.println(Math.pow(3,3));
        System.out.println(Math.pow(2,2));
        System.out.println("-----------------");
        //随机数 [0.0,1.0)
        System.out.println(Math.random());
        System.out.println((int)(Math.random()*10));//强转
        System.out.println(Math.floor(Math.random()*100));
    }
}

○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○

🥝三.system

🔒1,system是什么？
用于描述系统资源的一个类,该类不能创建对象.,属性和方法都是静态的system类包含几个有用的类字段和方法,它无法实例化 System类提供的设施包括标准输入,标准输出和错误输出流; 访问外部定义的属性和环境变量; 加载文件和库的方法; 以及用于快速复制阵列的一部分的实用方法
🔓2.system常用方法类(JDK文档)
public static void exit(int status) 终止当前运行的Java虚拟机. 该参数用作状态代码; 按照惯例，非零状态代码表示异常终止.此方法调用类Runtime的exit方法.此方法永远不会正常返回
public static long currentTimeMillis() 以毫秒为单位返回当前时间当前时间与UTC时间1970年1月1日午夜之间的差异，以毫秒为单位
🔏3.让我们看一下代码案例:

public class Test {
    public static void main(String[] args) {
        // exit(0) 终止当前运行的Java虚拟机。
       /* System.out.println("程序开始执行");
        System.exit(0); //终止当前运行的Java虚拟机。o为正常退出 非0为异常退出
        System.out.println("程序结束");*/
        //1秒=1000毫秒
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            System.out.println("xiaojiang");
        }
        long end = System.currentTimeMillis();
        System.out.println("for循环执行1000000次要" + (end - start) + "毫秒");
    }
}

○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○

🥥四.object

🔈1.object的基本概述
类Object是类层次结构的根.每个班级都有Object作为超类. 所有对象（包括数组）都实现此类的方法.所有类都直接和间接继承object类
🔉2.object方法(JDk文档)

🔊3.代码展示:

public class Student extends Object {
    private String name;
    private int age;

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //一般情况下 对象重写了toString 输出对象中所有成员属性值(可自动生成toString)
   /* @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }*/
    @Override
    //手动重写 toString
    public String toString() {
        return "name" + ":" + name + "," + "age" + ":" + age;
    }
}
public class Demo {
    public static void main(String[] args) {
        //多态机制 父类引用指向子类对象
        //Object o = new Student();
        Student stu = new Student();
        stu.setName("xiaojiang");
        stu.setAge(21);
        System.out.println(stu);//object父类中 toString Student重写
        System.out.println(stu.toString());//toString目的就是给我们对象重写，输出对象中所有成员属性值
        //本质上就是下面的输出:
        // System.out.println(stu.getClass().getName() + "@" + Integer.toHexString(stu.hashCode()));
        //jdk源码：
        /*public void println(Object x) {
            String s = String.valueOf(x);
            synchronized (this) {
                print(s);
                newLine();
            }
        }*/
        /*public static String valueOf(Object obj) {//obj ==x
            return (obj == null) ? "null" : obj.toString();
        }*/
        /*public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }*/
        //本质上输出下面
        // System.out.println(stu.getClass().getName() + "@" + Integer.toHexString(stu.hashCode()));
    }
}

底层是如何实现的呢？
🏏1.调用String.valueOf(x);
🏒2.String.valueOf底层是如何实现的呢?
通过三元表达式判断该对象是否为null,三元表达式判断该对象是否为null,如果是null则会返回一个空字符串;如果不为null则会调用obj(父类中的).toString();
🥍 3.return (obj == null) ? “null” : obj.toString();
🏑4.obj(父类中的).toString()
getClass().getName()------获取类的完整路径地址com.Object_01.Student @分隔hashCode()转化字符串做拼接
🎾5.return getClass().getName() + “@” + Integer.toHexString(hashCode())

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("xiaojiang", 21);
        Student s2 = new Student("xiaoning", 16);
        //s1==s2 双等于就是比较两个对象 内存地址值是否相同
        System.out.println(s1 == s2);//false
        //equals 比较两个对象的值是否相同 如果相同，则返回ture 不同则返回false
        System.out.println(s1.equals(s2));//false 在没有重写Object父类 equals方法则返回false
        /*
        public boolean equals(Object obj) {
                return (this == obj);    obj指s2 this 指s1
            }*/
        System.out.println("------------------------");
        //String equals 比较两个字符串的值是否相同
        //如果相同，则返回为true 不同则返回false
        //自定义对象，需要重写equals的方法 才可以实现 如果相同就返回true 不同则返回false
        String str1 = "xiaojiang";
        String str2 = "xiaojiang";
        System.out.println(str1 == str2);//true
        System.out.println(str1.equals(str2));//true
    }
}

🏓6.Object中equsals方法
在Object父类中 equals 是比较两个对象的内存地址是否相同而不是比较两个对象的成员属性值是否相同
equals 比较两个对象值是否相同比较两个内存地址是否相同,但再加一个条件：如果自定义的对象没有,重写Object父类的话则是在比较两个对象的内存地址
○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○

🍇五.冒泡排序

⚾1.那什么是冒泡排序呢？
冒泡排序是排序当中的一种，排序是将一组数据按照规则进行排列
🥎2.冒泡排序的原理:
数据有n个进行排序总共需要比较n-1次
每一次比较完毕,下一次比较就会少一个数据参与
🏀3.让我们看一下代码案例:

public class StringTest06 {
    public static void main(String[] args) {
        int[] arr = {55, 32, 66, 83, 22};
        arrayToString(arr);
        System.out.println("排序前:"+arrayToString(arr));
      /*  //第一次交换后
        for(int i=0;i<arr.length-1-0;i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第一次比较后:"+arrayToString(arr));
        //第一次比较后:[32, 55, 66, 22, 83]
        //第二次交换后
        for(int i=0;i<arr.length-1-1;i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第二次比较后:"+arrayToString(arr));
        //第二次比较后:[32, 55, 66, 83, 22]
        //第三次交换后
        for(int i=0;i<arr.length-1-2;i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第三次比较后:"+arrayToString(arr));
        //第三次比较后:[32, 55, 66, 83, 22]
        //第四次交换后
        for(int i=0;i<arr.length-1-3;i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第四次比较后:"+arrayToString(arr));
        //第四次比较后:[32, 55, 66, 83, 22]
       */
        //代码优化一下
       /* for (int x = 0; x < 4; x++) {
            for (int i = 0; i < arr.length - 1 - x; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        System.out.println("排序后:" + arrayToString(arr));
        //排序后:[22, 32, 55, 66, 83]
        */
        for(int x =0;x<arr.length;x++) {
            for (int i = 0; i < arr.length - 1 - x; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        System.out.println("排序后:"+arrayToString(arr));
        //排序后:[22, 32, 55, 66, 83]
    }

    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○
【java基础】你真懂API包装类吗? (W字详解)

🍊六.array类

📃1.array类基本的概述
该类包含用于操作数组的各种方法(如排序和搜索).该类还包含一个静态工厂,可以将数组视为列表
这个类中的方法都抛出一个NullpointerException,如果指定的数组引用为null，除非另有说明
📜2.让我们看一下常见的方法:

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        // public static String toString(int[] a) 返回指定数组的内容的字符串形式
        //public static void sort(int[] a) 按照数字顺序排列的数组
        int[] arrs = {33, 22, 56, 12, 99};
        System.out.println(arrs);//输出内存地址
        System.out.println("------------");
        //数组转化成字符串
        String str = Arrays.toString(arrs);
        System.out.println(str);
        System.out.println("---------------");
        //排序 冒泡排序
        Arrays.sort(arrs);//底层是封装好了的 将数组中的元素排序
        System.out.println("排序的结果为:" + Arrays.toString(arrs));
        System.out.println("----------------");
        //从大到小
        System.out.println("输出结果从大到小为:");
        for (int i = arrs.length - 1; i >= 0; i--) {
            System.out.println(arrs[i]);
        }
        System.out.println("-------------------");
        //sort方法  若数组为int类型 则排序从小到大 若char类型数组  存放字母 则按照字母顺序排序
        char[] ch = {'h', 'g', 'a', 't'};
        Arrays.sort(ch);
        System.out.println("排序的结果为:" + Arrays.toString(ch));
    }
}

📑3.工具类的设计

public class Demo {
    /*工具类设计思想：
                   1.构造方法 使用private关键字修饰 外部无法new
                   2.public static 关键字修饰 工具类中的方法 直接通过类名称访问
     */
    //元素从大到小
    public static void sort(int[] arrs) {
        // Arrays
        Arrays.sort(arrs);//从小到大
        System.out.println("输出结果从大到小:");
        for (int i = arrs.length - 1; i >= 0; i--) {
            System.out.println(arrs[i]);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        //定义一个数组
       int[] arrs ={32,21,78,6,99};
       Demo.sort(arrs);
    }
}

○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○
【java基础】你真懂API包装类吗? (W字详解)

🍋七.基本数据类型包装类

🌳1.基本数据类型包装类的概述
基本数据类型一共有4类8种,整型,浮点型,字符,布尔,这些都是非常简单的数据类型.只能存储数值
基本数据类型不能包含一些数据的操作方法,没有办法描述这些数据内容,java为了解决这个问题,就为每一种基本数据设计了一种对应的包装类,提供了一些基本数据的操作方法及一些描述
常用的操作之一:用于基本数据类型和字符串之间的转换
🌲2.基本数据类型对应包装类：
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

🌴3.让我们看一下代码示例

public class Test {
    public static void main(String[] args) {
        //int 最大值 最小值
        System.out.println("int的最大值:" + Integer.MAX_VALUE);//2147483647
        System.out.println("int的最小值:" + Integer.MIN_VALUE);//-2147483648
        //  int i = 3147483647; 数据超出了范围
        //Integer是包装类  主要包装了 基本数据类型int
        //包装类 对原始基本数据类型的包装 目的是用于基本数据类型与字符串之间的转化
        long l =30;
    }
}

🌵4.Integer

🏁(1)Integer基本概述
Integer类在对象中包装基本类型int的值.Integer类型的对象包含单个字段,其类型为int.Integer类的对象中,维护一个私有的成员变量, 是一个int类型的属性(成员变量),用来存储Integer类型存储的int数据;该类提供了几种将int转换为String和String转换为int,以及处理int时有用的其他常量和方法
🏳‍🌈(2)让我们看一下代码案例:

public class Test {
    public static void main(String[] args) {
        //jdk9 开始 不推荐 new Integer(); 已过时
        Integer i = new Integer(2);
        Integer j = new Integer("2");
        System.out.println(i);
        System.out.println(j);
        System.out.println("-----------");
        Integer h = Integer.valueOf(2);//通过有参构造传递字符串 字符串类型转化成Integer 前提 该字符串确定 数字
        Integer g = Integer.valueOf("2");
       // Integer s = Integer.valueOf("2fffff");//不能将字符串强行转化 NumberFormatException: For input string: "2fffff"
        System.out.println(h);
        System.out.println(g);
    }
}

🏴（3）将int类型转换成字符串类型

public class Test03 {
    public static void main(String[] args) {
        //将int类型 转换成字符串类型
        int i = 20;
        //第一种方式 通过空字符
        String s = "" + i;
        System.out.println(s);
        //第二种方式 String.valueOf()
        //可将  boolean int double long float Object 转化成字符串类型
        String s2 = String.valueOf(i);
        System.out.println(s2);
        boolean flag = true;
        String s3 = String.valueOf(flag);
        System.out.println(s3);
    }
}

🏴‍☠️(4)Integer的方法

a.成员方法
doubleValue() Integer转double
floatValue() Integer转float
intValue() Integer转int
longValue() Integer转long
b.静态方法
parseInt(String s) 把字符串安装十进制解析
parseInt(String s, int radix) 按照radix指定的进制转为十进制的数据显示
toBinaryString(int i) 把i转为二进制字符串
toHexString(int i) 把i转为十六进制字符串
toOctalString(int i) 把i转为八进制字符串
toString() 把Integer转字符串
valueOf(int i ) 把int数据转为Integer对象
valueOf(String s) 把String转为Integer对象
🚩(5)看下面的案例;

public class Test {
    public static void main(String[] args) {
        //将String类型转换成int
        //String中存放数字
        String str = "12345";
        //第一种方式 Integer.valueOf();
        Integer i1 = Integer.valueOf(str);
        // Integer i1 = new Integer(str);
        System.out.println(i1);
        System.out.println("-----------");
        //第二种方式
        //intValue 不为静态方法 通过new对象 对象实例.intValue();
        // 就是调用intValue方法 获取Integer 包装int基本数据类型 返回int类型
        int i2 = i1.intValue();//通过new对象调用
        System.out.println(i2);
        System.out.println("-----------");
        //第三种方式 在企业开发中常用 Integer.parseInt();
        int i3 = Integer.parseInt(str);
        System.out.println(i3);
    }
}

public class Test {
    public static void main(String[] args) {
        String str = "54321";
        //字符串类型 转换成long类型
        Long l = Long.valueOf(str);
        long l2 = l.longValue();
        System.out.println(l2);
        System.out.println("---------");
        Long l3 = Long.parseLong(str);
        System.out.println(l3);
        System.out.println("---------");
        String  flag = "true";
        boolean b =Boolean.parseBoolean(flag);
        System.out.println(b);
    }
}

🚝(6)字符串中数据排序

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        //字符串排序
        String str = "15,2,56,74,6";
        String[] strA = str.split(",");//分割字符串
        //将字符串数组转化成int数组
        int[] intB = new int[strA.length];
        //遍历字符串
        for (int i = 0; i < intB.length; i++) {
            //将字符串转化成int数组 赋值给int[] intA
             intB[i] = Integer.parseInt(strA[i]);
        }
        //对int[] intB 进行排序
        Arrays.sort(intB);
        for (int i = 0; i < intB.length; i++) {
            System.out.print(intB[i]);
            if (i != intB.length - 1) {
                System.out.print(","); //控制台输出2,6,15,56,74
            }
        }
    }
}

🚅(7)自动装箱和拆箱(JDK1.5之后)

自动装箱和拆箱的基本概述
A.装箱和拆箱:
装箱: 将基本数据类型,封装成包装类型对象,这个过程就是装箱,使用包装类构造方法即可
拆箱:从包装类型对象中,将包装类型转为基本数据类型的过程就是拆箱,使用***Value()
B自动装箱和拆箱
自动装箱: 可以直接使用基本数据类型数据给包装类型对象赋值
自动拆箱: 可以直接使用包装类型的对象,给基本数据类型变量赋值. 包装类型对象可以直接参与运算
C.让我们看一下代码案例

public class Test {
    public static void main(String[] args) {
        //装箱:自动将基本数据类型转换为包装器类型 基本数据类型>>>包装类型
        //拆箱:自动将包装器类型转换为基本数据类型  包装类型>>>基本数据类型
        /*底层 走 Integer i =6;
           装箱 Integer.valueOf(基本数据类型6)
         */
        Integer i = 6;//把6基本数据类型赋值给i包装类 装箱 基本数据类型>>>包装类型
        /* 拆箱 int j =i;
         Integer.intvalue()方法获取Integer 基本数据类型value
         */
        int j = i;//包装类型i赋值给j 基本数据类型 拆箱 包装类型>>>基本数据类型
        Integer h = 0;
        h += 1;
        /* h + =1;h = h+1;
            h（Integer valueOf())+1;自动拆箱 0+1;
            h+1的值赋值给h = 0+1;
            h+1 自动拆箱 0+1;
            h+1的结果赋值给h =0+1; 自动装箱
         */
    }
}

public class Test03 {
    public static void main(String[] args) {
        Integer i = 10;
        double d = 3.84;
        Float f = 3.84f;
        double result = d + i + f;
        // 显示小数点后两位
        System.out.printf("%.2f", result);
    }

    private static void test() {
        // 装箱
        Integer i = new Integer(10);

        // 拆箱
        int i2 = i.intValue();

        // 自动装箱
        Integer i3 = 10;
        Boolean b = true;
        Double d = 3.14;

        // 自动拆箱
        int i4 = i3;
        System.out.println(i4);

        double d2 = d;
        System.out.println(d2);


        int sum = i4 + i3;
        System.out.println(sum);
    }
}

○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○
【java基础】你真懂API包装类吗? (W字详解)

🍌八.Date日期类

🚋1.Date日期类的基本概述

🚆2.让我们看一下案例

import java.util.Date;

public class Test01 {
    public static void main(String[] args) {
        //1s = 1000mm
        Date date1 = new Date();
        System.out.println(date1);
        System.out.println("----------");
        //构造方法
        long time = 1000*60*60;//一个小时 时间
        //格林时间 00：00+1小时 转化成cst时间+8小时
        Date date2 = new Date(time);
        Date date3 = new Date(0);
        System.out.println(date2);
        System.out.println(date3);
        //getTime
        Date date = new Date();
        System.out.println(date.getTime());
        //setTime
        long time = 1000*60*60;
        date.setTime(time*2);
        System.out.println(date);
    }
}

🚉3.SimpleDateFormat

public class Test {
    public static void main(String[] args) {
        //时间格式化
        Date date = new Date();
        System.out.println(date);
       // SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
      //  SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年mm月dd日HH时mm分ss秒");
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println(format);
        //将simpleDateFormat  将date日期转化成字符串----自定义转化的格式
    }
}

public class Test {
    public static void main(String[] args) throws ParseException {
    //字符串类型转化成date类型
        String strdate ="2022-11-20 22:11:50";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
    //将 String字符串日期转化成 date类型
        Date date = simpleDateFormat.parse(strdate);
        System.out.println(date);
    }
}

🚟4.工具日期类
工具类

public class DateUtils {//日期工具类
    private static final String FORMAT_1="yyyy-mm-dd HH:mm:ss";
    /*1.无参构造方法私有化
      2.date转化成string字符串类型
      3.将string类型字符串 类型转化Date日期
     */
    //无参构造方法私有化
    private DateUtils() {

    }
    public static  String getCuDateUtils() {
        return dateToString(new Date(),FORMAT_1);
    }
    //date转化成string字符串类型
    public static String dateToString(Date date, String FORMAT_1) {
        SimpleDateFormat SimpleDateFormat = new SimpleDateFormat(FORMAT_1);
        return SimpleDateFormat.format(date);
    }
    //将string类型字符串 类型转化Date日期
    public static Date strintgToDate(String date,String format) throws ParseException {
        SimpleDateFormat SimpleDateFormat2 = new SimpleDateFormat(FORMAT_1);
        return SimpleDateFormat2.parse(date);
    }
}

测试类

public class Test01 {
    public static void main(String[] args) throws ParseException {
        String s1 = DateUtils.dateToString(new Date(),"yyyy-mm-dd HH:mm:ss");
        System.out.println(s1);
        Date date = DateUtils.strintgToDate(s1, "yyyy-mm-dd HH:mm:ss");
        System.out.println(date);
        //
        String s2 = DateUtils.dateToString(new Date(),"yyyy");
        System.out.println(s2);
        String s3 = DateUtils.dateToString(new Date(),"yyyy-mm-dd HH:mm");
        System.out.println(s3);
        System.out.println("-------------------");
        /*String cuDateUtils = DateUtils.getCuDateUtils();
        System.out.println(cuDateUtils);*/
        System.out.println(DateUtils.getCuDateUtils());
    }
}

○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○ ○(￣﹏￣)○
【java基础】你真懂API包装类吗? (W字详解)

🍒九.Calendar

🌍1.Calendar基本概述
A.表示是一个精确的时间瞬间, 是一个日历对象,里面包含的字段值.都是和时间相关的值
如:YEAR, DAY_OF_MONTH, HOURE等
B.Calendar是一个抽象类,不能创建对象(实例化)
Calendar有个方法.getInstance()就可以返回一个日历对象
C.常用方法:
get(intfield) 获取某个字段下的值
set() 设置某个字段下的值
add()方法可以为某个字段添加值
getTimeMillis() 获取日历对象对应的毫秒数
🌎2.让我们看一下案例

import java.util.Calendar;

public class Test {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();//多态机制
        System.out.println(c);
        //获取日期 年月日 小时分秒
        int year = c.get(Calendar.YEAR);
        //获取月份 从0开始 需要+1
        int month = c.get(Calendar.MONTH);
        int date = c.get(Calendar.DATE);
        int hour = c.get(Calendar.HOUR);
        int minute = c.get(Calendar.MINUTE);
        int second = c.get(Calendar.SECOND);
        System.out.println(year + "年" + (month + 1) + "月" + date +"日" + hour + ":" + minute + ":" + second);
        Calendar c = Calendar.getInstance();//多态机制
        System.out.println(c);
        //添加或修改日期
       // c.add(Calendar.YEAR,13);//加年份
        /*c.add(Calendar.YEAR,-21);
        c.add(Calendar.MONTH,-1);
        c.add(Calendar.DATE,-3);*/
        //直接设置时间
        c.set(2001,2,18);
        //获取日期 年月日 小时分秒
        int year = c.get(Calendar.YEAR);
        //获取月份 从0开始 需要+1
        int month = c.get(Calendar.MONTH);
        int date = c.get(Calendar.DATE);
        int hour = c.get(Calendar.HOUR);
        int minute = c.get(Calendar.MINUTE);
        int second = c.get(Calendar.SECOND);
        System.out.println(year + "年" + (month + 1) + "月" + date +"日" + hour + ":" + minute + ":" + second);
    }
}

🌏3.二月天案例

public class Test03 {
    public static void main(String[] args) {
        System.out.println("请输入年份:");
        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();
        Calendar c = Calendar.getInstance();
        c.set(year, 2,1);
        c.add(Calendar.DATE, -1);
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年在2月份有" + date + "天");
        System.out.println(year==29?"润年":"平年");
    }
}