JavaSE-13 【API工具类和包装类】

第一章 Object类

1.1 概述

java .lang .Object 类是Java语言中的根类，是所有类的父类，此类中的所有方法子类都可以使用，在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类，那么默认就是集成Object类

根据JDK文档，Object类中包含的方法有11个，如下：

本节掌握：

• public String toString():返回对象的字符串表示
• public boolean equals(Object obj) :指示其某个对象是否与此对象“相等”

方法返回值类型	方法描述
protected Object	clone() 创建并返回此对象的副本。
boolean	equals(Object obj) 指示一些其他对象是否等于此。
protected void	finalize() 当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象
类< ? >	getClass() 返回此 Object的运行时类。
int	hashCode() 返回对象的哈希码值
void	notify() 唤醒正在等待对象监视器的单个线程
void	notifyAll() 唤醒正在等待对象监视器的所有线程。
String	toString() 返回对象的字符串表示形式。
void	wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。
void	wait(long timeout) 导致当前线程等待，直到另一个线程调用 notify()方法或该对象的 notifyAll()方法，或者指定的时间已过
void	wait(long timeout, int nanos) 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法，或者某些其他线程中断当前线程，或一定量的实时时间。

1.2 toString 方法

方法摘要：

• public String toString();返回该对象的字符串表现形式

• toString方法返回该对象的字符串表示，其实该字符串就是对象的类型+@+内存地址值

• 直接打印对象的地址值没有意义，java中常以重写Object类中的toString()方法,将对象以字符串的形式输出

案例：

package com.object;

public class User {
    private String username;
    private String password;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    //直接打印对象的地址值没有意义，重写Object类中的toString()方法,将对象以字符串的形式输出
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

package com.object;

/**
 * java.lang.Object
 *      Class Object是类Object结构的根。
 *      每个班都有Object作为超类。
 *      所有对象（包括数组）都实现了这个类的方法
 */
public class Demo01_ToString {
    public static void main(String[] args) {
    /*
        User类默认继承了Object类，所以可以使用Object类的toString()方法
        String toString();返回对象的字符串表示形式。
     */
        //创建对象
        User user = new User("tom", "123456");
        //调用toString()
        System.out.println(user.toString());
        //直接打印对象的名字就是调用toString()方法
        System.out.println(user);
    }
}

集成Object类的toString方法直接调用，打印的是对象的地址值

重写Object类的toString()方法，打印的是对象的字符串形式

1.3 equals 方法

方法摘要：

• public boolean equals(Object obj);指示其他某个对象是否与此对象“相等""
• 调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否相同，其中相同有默认和自定义两种方式

默认地址值比较：

• 如果没有重写覆盖equals方法，那么Object类中默认进行了 ==运算符的地址值比较，只要不是同一个对象，结果必然是false

对象内容比较：

• 如果希望进行对象的内容比较，即判定两个对象相同，那么所有或指定的部分成员变量相同，可以重写equals方法。

/*
    Object类的额equals方法，默认比较的是两个对象的地址值，没有意义
    重写equals方法，比较两个对象的属性
*/
@Override
public boolean equals(Object o) {
   if (this == o) return true;
   if (o == null || getClass() != o.getClass()) return false;
   User user = (User) o;
   return Objects.equals(username, user.username) 
       && Objects.equals(password, user.password);
}

模板类没有重写equals方法，比较地址值，为false

模板类没有重写equals方法：比较内容值，为true

1.4 Objects类

在JDK1.7中添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的)，用于计算对象的hashcode，返回对象的字符串表示，比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题，方法如下：

public static boolean equals(Object a,Object b);判断两个对象是否相等

源码：

public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
}

案例：

• 方式1：使用String类中重写的Object的equals方法,进行null比较，就会出现空指针异常

package com.object;

import java.util.Objects;

public class Demo03_Objects {
    public static void main(String[] args) {
        String s1 = "123";
        String s2 = null;
        String s3 = "123";
        /*
            方式1：使用String中重写的Object的equals方法,进行null比较，就会出现空指针异常
         */
        System.out.println(s1.equals(s3));//true
        //null是不能调用方法的，就会抛出空指针异常，java.lang.NullPointerException
        System.out.println(s2.equals(s3));//空指针异常
    }
}

• 方式2：使用Objrcts中的equals方法：对两个对象进行比较，防止空指针异常

package com.object;

import java.util.Objects;

public class Demo03_Objects {
    public static void main(String[] args) {
        String s1 = "123";
        String s2 = null;
        String s3 = "123";
        /*
            方式2：使用Objrcts中的equals方法：对两个对象进行比较，防止空指针异常
            public static boolean equals(Object a, Object b) {
                return (a == b) || (a != null && a.equals(b));
            }
         */
        System.out.println(Objects.equals(s2, s3));//true
    }
}

第二章 日期时间类

2.1 Date类

• 1 概述

java.util.Date类，表示特定的瞬间，精确到毫秒

Date类中的构造方法：可以把毫秒值转化为日期对象：

• 1、public Date()分配Date对象，并初始化此对象，以表示分配它的时间(精确到毫秒)

• 2、public Date(long date)分配Date对象，并初始化此对象，以表示自从标准时间(时间原点)以来的指定毫秒数

• （时间原点）：1970年1月1日0时0分0秒

• （中国属于东八区）标注时间：1970年1月1日8时0分0秒

  • 使用无参构造，可以自动设置当前系统时间的毫秒时刻，即当前时间
  • 使用指定long类型的构造方法，可以自定义毫秒时刻，即从标准时间开始的时间

• 3、Date类常用的成员方法

  • long getTime() 把日期转换为毫秒
  • 返回自1970年1月1日00:00:00以来，此Date对象表示的毫秒数
  • 相当于System.currentTimeMillis();

• 2 案例

package com.date;

import java.util.Date;

public class Demo02_DateConstructor {
    public static void main(String[] args) {
        f1();
        f2();
        f3();
    }

    /*
        Date类的成员方法：
            long getTime();把日期转换为毫秒
            返回自1970年1月1日00:00:00以来，此Date对象表示的毫秒数
            相当于System.currentTimeMillis();
     */
    public static void f3() {
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);//1673704299503
        long l = System.currentTimeMillis();
        System.out.println(l);//1673704299503
    }

    /*
        Date类的有参数构造方法
            Date(long date)
            参数：long类型的毫秒值，将毫秒值转化为date日期
     */
    public static void f2() {
        Date date = new Date(3000);
        System.out.println(date);//Thu Jan 01 08:00:03 CST 1970
    }

    /*
        Date类的无参构造方法
            作用：用于获取当前系统的日期时间
     */
    public static void f1() {
        Date date = new Date();
        System.out.println(date);//Sat Jan 14 21:49:27 CST 2023

    }
}

2.2 DateFormat类

• 1 概念

java.text.DateFormat 这个类是完成日期和文本之间的转换，特就是在Date对象和String对象之间转换。

• 格式化：按照指定的格式，将Date转换为String对象

• 解析：按照指定格式，将String对象转换为Date对象

• 2 构造方法

由于DateFormat类为抽象类，不能直接使用构造方法，所以需要其子类java.text.SimpleDateFormat

这个类需要一个格式来指定格式化或解析的标准，构造方法是：

• public SimpleDateFormate(String pattern);
• 作用：用给定的模式个默认语言环境的日期格式符号构造SimpleDateFormat
• 参数是一个字符串，代表日期时间的指定格式

标识字母(区分大小写)	含义
y	年
M	月
d	天
H	时
m	分
s	秒
S	毫秒

• 3 常用日期和时间模式

package com.date;

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

public class Demo03_SimpleDateFormat {
    /*
      java.text.DateFormat 是日期/时间格式化子类的抽象类
        作用：格式化：将日期转化为字符串，解析：将字符串解析成日期
        成员方法：
            1、String format(Date date); 按照指定模式，将Date日期格式化为符合日期的字符长
            2、Date parse(String sourse); 将符合模式的字符串，转化为Date日期
        DateFormat是一个抽象类，无法直接创建对象使用，可以使用DateFormat类的子类SimpleDateFormat
      java.text.SimpleDateFormat 是DateFormat的子类
        构造方法：
            public SimpleDateFormat(String pattern)
            用给定的模式构造
        参数：String pattern ：传递指定的模式
        模式：区分大小写：
            yyyy：年
            MM：月
            dd：日
            HH：时
            mm：分
            ss：秒
        yyyy-MM-dd HH:mm:ss
        yyyy年MM月dd日 HH时mm分ss秒
     */
    public static void main(String[] args) throws ParseException {
        //格式化方法。将Date日期转换成字符串
        m1();
        //解析方法，将字符串解析成Date日期
        m2();
    }

    public static void m2() throws ParseException {
        //创建格式化对象,传递格式化模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //调用parse解析字符串为Date日期，参数必须和格式化模式匹配，否则会报解析异常
        Date parse = sdf.parse("2023-01-26 22:42:41");
        //输出打印
        System.out.println(parse);
    }

    //使用DateFormat中的方法format。将日期格式化为文本
    public static void m1() {
        //创建格式化对象并传递格式化模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //将date日期转化为指定模式
        String formatStr = sdf.format(new Date());
        //输出打印
        System.out.println(formatStr);
    }
}

• 4 DateFormat类案例

计算一个人出生到现在的天数

package com.date;

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

/**
 * 案例：计算一个人出生多少天
 * 步骤：
 *  1、使用Scanner中的next获取出生日期
 *  2、使用DateFormat中的parse方法，把字符串的出生日期转换成Date格式的出生日期
 *  3、把Date格式的出生日期转换成毫秒值
 *  4、获取当前的日期，转换为毫秒值
 *  5、使用当前日期的毫秒值减去出生日期的毫秒值
 *  6、将毫秒差值转换成天
 */
public class Demo04 {
    public static void main(String[] args) throws ParseException {
        //1.友好提示输入规定格式的出生日期
        System.out.println("请输入您的出生日期，格式YYYY-MM-dd");
        String birthdayStr = new Scanner(System.in).nextLine();
        //2、使用DateFormat中的parse方法，把字符串的出生日期转换成Date格式的出生日期
        Date birthdayDate = new SimpleDateFormat("yyyy-MM-dd").parse(birthdayStr);
        //3、把Date格式的出生日期转换成毫秒值
        long birthdayDateTime = birthdayDate.getTime();
        //4、获取当前的日期，转换为毫秒值
        long currentTime = new Date().getTime();
        //5、使用当前日期的毫秒值减去出生日期的毫秒值
        long time = currentTime-birthdayDateTime;
        //6、将毫秒差值转换成天
        System.out.println("截止今天，您已经出生"+time/1000/60/60/24+"天！！！");
    }
}

2.3 Calendar类

= 1 概念

• java.util.Calendar是日历类，该类将所有可能用到的时间信息封装成静态成员变量，方便获取

• 日历类其实就是方便获取各个时间成员属性的

• 2 类的介绍

• Calendar类为抽象类。Calendar类是使用静态方法创建对象，返回子类对象，如下

  • public static Calendar getInstance() 使用默认时区和语言换将获得一个日历

package com.calendar;

import java.util.Calendar;

/**
 * Calendar日历类
 *  1.是一个抽象类，封装很多操作日历字段的方法
 *  2、Calendar无法直接创建对象，需要使用静态方法创建子类对象
 *  3、Calendar提供了一种类方法getInstance ，用于获取此类型的一般有用的对象
 */
public class Demo01Calendar {
    public static void main(String[] args) {
        //1、获取Calendar类的对象
        Calendar calendar = Calendar.getInstance();
        //2、打印输出
        System.out.println(calendar);
    }
}

• 3 常用方法

• 根据API文档，常用方法如下

• 1、public int get(int field);返回给定日历字段的值

• 2、public void set(int field,int value);将给定的日历字段设置为给定的值

• 3、public abstract void add(int field,int amount); 根据日历的规则，为给定的日历字段添加或减去指定的时间量

• 4、public Date getTime();返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象

Calendar中常用的日历字段：

字段值	含义
YEAR	年
MONTH	月
DATE	日
HOUR	时
MINITE	分
SECOND	秒
MILLISECOND	毫秒
WEEK_OF_YEAR	本年第几周
WEEK_OF_MONTH	本月第几周
DAY_OF_YEAR	本年第几天
DAY_OF_MONTH	本月第几天
DAY_OF_WEEK	本周第几天
HOUR_OF_DAY	本日第几小时
AM	从午夜到中午之前的一天中的一段时间
PM	从中午到午夜之前的一天中的一段时间
SUNDAY	周日
MONDAY	周一
TUESDAY	周二
WEDNESDAY	周三
THURSDAY	周四
FRIDAY	周五
SATURDAY	周六
JANUARY	一月
FEBRUARY	二月
MARCH	三月
APRIL	四月
MAY	五月
JUNE	六月
JULY	七月
AUGUST	八月
SEPTEMBER	九月
OCTOBER	十月
NOVEMBER	十一月
DECEMBER	十二月

package com.calendar;

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

/**
 * Calendar类的常用成员方法
 *      1、public int get(int field);
 *          返回给定日历字段的值
 *      2、public void set(int field,int value);
 *          将给定的日历字段设置为给定的值
 *      3、public abstract void add(int field,int amount);
 *          根据日历的规则，为给定的日历字段添加或减去指定的时间量
 *      4、public Date getTime();
 *          返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象
 *      成员方法的参数：年，月，日，时，分，秒，月中某一天
 */
public class Demo02_CalendarMethods {
    public static void main(String[] args) {
        m1();
        m2();
        m3();
        m4();
    }
    /*
     *      4、public Date getTime();
     *          返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象
     */
    private static void m4() {
        //创建Caledar类的对象
        Calendar calendar = Calendar.getInstance();
        //调用getTime方法，返回时间值
        Date time = calendar.getTime();
        //输出打印
        System.out.println(time);
        //将其转化成毫秒值
        long time1 = time.getTime();
        System.out.println(time1);
    }

    /*
     *      3、public abstract void add(int field,int amount);
     *          根据日历的规则，为给定的日历字段添加或减去指定的时间量
     *          int field 指定的日期字段
     *          int amount 增加或者减少的值
     */
    private static void m3() {
        //创建Calendar类的对象
        Calendar calendar = Calendar.getInstance();
        //设置当前年份增加值
        calendar.add(Calendar.YEAR,20);
        //获取设置后的年份值
        int i = calendar.get(Calendar.YEAR);
        //设置当前月份减少值
        calendar.add(Calendar.MARCH,-7);
        //获取设置后的月份值
        int i1 = calendar.get(Calendar.MARCH);
        System.out.println(i);
        System.out.println(i1);
    }

    /*
     *      2、public void set(int field,int value);
     *          将给定的日历字段设置为给定的值
     */
    private static void m2() {
        //创建日历类Calendar的对象
        Calendar calendar = Calendar.getInstance();
        //设置年份的值
        calendar.set(Calendar.YEAR,2099);
        //设置月份的值
        calendar.set(Calendar.MARCH,11);
        //获取年份的值
        int i = calendar.get(Calendar.YEAR);
        //获取月份的值
        int i1 = calendar.get(Calendar.MARCH);
        System.out.println(i);
        System.out.println(i1);
    }

    /*
     *      1、public int get(int field);
     *          返回给定日历字段的值
     */
    private static void m1() {
        //获取Calendar类的对象
        Calendar calendar = Calendar.getInstance();
        //传递指定参数值
        int i = calendar.get(Calendar.YEAR);
        int i1 = calendar.get(Calendar.MARCH);
        int i2 = calendar.get(Calendar.DATE);
        int i3 = calendar.get(Calendar.DAY_OF_MONTH);
        int i4 = calendar.get(Calendar.DAY_OF_WEEK);
        //打印输出当前值
        System.out.println(i);//2023
        System.out.println(i1+1);//西方月份0-11  中国1-12
        System.out.println(i2);//28号
        System.out.println(i3);//28号
        System.out.println(i4);//7周
    }
}

• 4 注意事项：

1、在Calendar中月份的表示是从0-11，0-11表示1-12月

2、日期是有大小关系的，时间靠后，时间越大

第三章 System类

3.1 类介绍

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息，常用方法如下

• public static long currentTimeMillis()返回以毫秒为单位的当前时间

• public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

  ​ 将数组中的指定的数据拷贝到另一个数组中

3.2 currentTimeMillis方法

currentTimeMillis方法就是获取当前系统时间与1970年1月1日 00:00之间的时间毫秒值

案例：循环遍历计时

package com.system;

public class Demo2_CurrentMillis {
    public static void main(String[] args) {
        //计算开始时间
        long start = System.currentTimeMillis();
        for (int i = 0; i <10000 ; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        long time = end-start;
        System.out.println("循环遍历总计耗时："+time+"毫秒");
    }
}

3.3 arraycopy方法

将指定源数组中的数组从指定位置复制到目标数组的指定位置

public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)

package com.system;

import java.util.Arrays;

/**
 * 将指定源数组中的数组从指定位置复制到目标数组的指定位置
 *      public static void arraycopy(Object src,
 *                                      int srcPos,
 *                                      Object dest,
 *                                      int destPos,
 *                                      int length)
 *      src - 源数组。
 *      srcPos - 源数组中的起始位置。
 *      dest - 目标数组。
 *      destPos - 目的地数据中的起始位置。
 *      length - 要复制的数组元素的数量。
 */
public class Demo03_Arraycopy {
    public static void main(String[] args) {
        int[] src = {1,2,3,4,5,6};
        int[] dest = {11,22,33,44,55,66};
        //执行复制之前的deat数组
        System.out.println(Arrays.toString(dest));
        //执行赋值操作
        System.arraycopy(src,0,dest,0,3);
        //执行复制之后的deat数组
        System.out.println(Arrays.toString(dest));
    }
}

第四章 包装类

4.1 概述

java提供了两种类型。基本数据类型和引用数据类型。使用基本数据类型在于效率，然而很多情况，会创建对象使用，因为对象可以完成更多的功能，以下是基本类型和包装类型的对照表

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

4.2 装箱与拆箱

基本数据类型和对应的包装类型之间，来回转换的过程称之为装箱和拆箱

• 装箱：从基本类型转换为对应的包装类型对象
• 拆箱：从包装类型转换为对应的基本数据类型

范例：

package com.packingclass;

/**
 * 装箱：
 *      概念：把基本类型数据，包装成包装类，
 *      构造方法：
 *          Integer(int value) 构造一个新分配的 Integer对象，该对象表示指定的 int值。
 *          Integer(String s) 构造一个新分配 Integer对象，表示 int由指示值 String参数
 *      静态方法：
 *          static Integer valueOf(int i)
 *              返回一个 Integer指定的 int值的 Integer实例
 *          static Integer valueOf(String s)
 *              返回一个 Integer对象，保存指定的值为 String
 * 拆箱：
 *      概念：从包装类中取出基本数据类型的值
 *      int intValue()  将 Integer的值作为 int
 */
public class Demo02_Integer{
    public static void main(String[] args) {
        //装箱
        //构造方法创建Integer独享
        Integer integer1 = new Integer(22);
        Integer integer2 = new Integer("22");
        //静态方法
        Integer integer3 = Integer.valueOf(33);
        Integer integer4 = Integer.valueOf("33");
        System.out.println(integer1);
        System.out.println(integer2);
        System.out.println(integer3);
        System.out.println(integer4);
        //拆箱
        System.out.println(integer1.intValue());
        System.out.println(integer2.intValue());
        System.out.println(integer3.intValue());
        System.out.println(integer4.intValue());
    }
}

4.3 自动装箱与自动拆箱

业务中由于需要经常性的进行基本数据类型和包装类型之间的转换操作，所以从Java5开始，基本类型和包装类型之间的装箱和拆箱操作，可以自动完成

4.4 基本数据类型与字符串之间的转换

基本数据类型转为String类型

• 1、基本类型的值
• 2、String类的toString方法
• 3、String的静态方法valueOf

String转换成对应的基本类型

• 除Character以外，其余所有包装类都有parseXxx静态方法可以将字符串参数转换为对应的基本类型

• public static byte parseByte(String s); 将字符串参数转换为对应的byte类型

• public static short parseShort(String s); 将字符串参数转换为对应的short类型

• public static int parseInt(String s); 将字符串参数转换为对应的int类型

• public static long parseLong(String s); 将字符串参数转换为对应的long类型

• public static float parseFloat(String s); 将字符串参数转换为对应的float类型

• public static double parseDouble(String s); 将字符串参数转换为对应的double类型

• public static boolean parseBoolean(String s); 将字符串参数转换为对应的boolean类型