一、包装类

1、8种包装类

• java为8种基本的数据类型准备了8种包装类型。8种包装类型属于引用数据类型，父类是Object。

• 需求：调用doSome方法的时候需要传入一个数字进去，但是数字属于基本数据类型，而doSome方法的参数类型是Object，可见doSome方法无法接受基本数据类型，则此时可以传递一个数字对应的包装类进去。

• 思路：把数字经过构造方法包装成为对象。

public class Test01 {
    public static void main(String[] args) {
        MyInt myInt=new MyInt(100);
        doSome(myInt);
    }
    public static void doSome(Object obj){
        System.out.println(obj);
    }
}
1
2
3
4
5
6
7
8
9

public class MyInt extends Object{
    int value;
    public MyInt(){

    }
    public  MyInt(int value){
        this.value=value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 上面的代码是自己写的，但是实际开发当中不需要我们自己写，可以直接调用。

• 八种包装类中其中6个都是数字对应的包装类，他们的父类都是Number。
• Number是一个抽象类，无法实例化。
• 将引用数据类型转换成为基本数据类型（拆箱）
• 将基本数据类型转换成引用数据类型 ( 装箱 )

        //将基本数据类型转换成引用数据类型(装箱)
        //将数字100转换成Integer包装类型
        Integer i=new Integer(100);
        //将引用数据类型转换成为基本数据类型（拆箱）
        float f=i.floatValue();
        System.out.println(f);
1
2
3
4
5
6

通过访问包装类的常量来获取最大值和最小值：

public class Test02 {
    public static void main(String[] args) {
        System.out.println("int最大值"+Integer.MAX_VALUE);
        System.out.println("int最小值"+Integer.MIN_VALUE);
    }
}
1
2
3
4
5
6

• 如果不是int类型则不能包装成Integer对象，否则会出现异常：

       Integer a1=new Integer("宏伟");//出现异常
1

2、自动装箱和拆箱

• 在JDK1.5之后支持自动拆箱和自动装箱。下面以int为例：

public class Test03 {
    public static void main(String[] args) {
        //自动装箱：
        Integer x=100;
        //自动拆箱：
        int y=x;
    }
}
1
2
3
4
5
6
7
8

• 自动装箱：int类型自动转换成为Integer类型。
• 自动拆箱：Integer类型自动转换成int类型。

        Integer z=100;
        System.out.println(z+1);
1
2

上面代码当中的z是一个引用，z是一个变量，还是保存一个对象的内存地址。

        Integer a=100;
        Integer b=100;
        System.out.println(a==b);
1
2
3

上面的代码结果是true，因为有自动拆箱机制。

        Integer c=new Integer(100);
        Integer d=new Integer(100);
        System.out.println(c==d);
1
2
3

上面的代码结果是false，因为比较的是内存地址，而两个对象的内存地址不同。

上面图片出现的结果不同的原因在于：

java当中为了提供程序的执行效率，将-128到+127之间的所有包装对象提前创建好，放到一个方法区的“整数型常量池当中”，目的是只要用这个区间的数据就不需要新创建对象，直接从常量池当中取出来。

true的原因就是两个的内存地址是一样的。

3、Integer常用方法

1、intValue

手动装箱和手动拆箱：

        //手动装箱
        Integer t=new Integer(1000);
        //手动拆箱
        int t1=t.intValue();
        System.out.println(t1);
1
2
3
4
5

2、parseInt

        int retValue=Integer.parseInt("123");
        System.out.println(retValue+1);
1
2

3、valueOf

【1】static Integer valueOf(int i)：静态的：将int转成Integer

【2】static Integer valueOf(String s)：静态的：将String转成Integer

二、java对日期的处理

1、获取系统当前时间

1、获取系统当前时间(精确到毫秒)，直接调用无参的构造方法：

需要导入：import java.util.Date;

        //获取系统当前时间(精确到毫秒)
        //直接调用无参的构造方法
        Date nowTime=new Date();
        System.out.println(nowTime);
1
2
3
4

从上面的结果知道， java.util.Date类的toString方法已经被重写了，输出的不是对象的内存地址，而是一个日期字符串。

2、将日期类型按照指定类型进行转换：

• SimpleDateFormat是java.text包下的，专门负责日期的格式化

SimpleDateFormat的构造方法：

参数：

• 注：除了上面的这些字符不能随意写之外，其他的符号格式可以随意组织。

2、Date转换成String

import java.util.Date;
public class Time {
    public static void main(String[] args) {
        //获取系统当前时间(精确到毫秒)
        //直接调用无参的构造方法
        Date nowTime=new Date();
        System.out.println(nowTime);

        //日期格式化
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        SimpleDateFormat sdf1=new SimpleDateFormat("yy/MM/dd HH:mm:ss");
        String nowTime11=sdf.format(nowTime);
        System.out.println(nowTime11);
        String nowTime22=sdf1.format(nowTime);
        System.out.println(nowTime22);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3、String转换成Date

需求：将一个日期字符串String转换成Date类型

import java.text.*;
import java.util.Date;
public class Test04 {
    public static void main(String[] args) throws Exception {
        //        将一个日期字符串String转换成Date类型
        String time="2022-07-04 09:33:00 272";
        SimpleDateFormat sdf3=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        Date dateTime=sdf3.parse(time);
        System.out.println(dateTime);
    }
}
1
2
3
4
5
6
7
8
9
10
11

4、获取毫秒数

• 获取自1970年1月1日00:00:00到当前系统时间的总毫秒数：

public class Test05 {
    public static void main(String[] args) {
        long nowTimeMillion=System.currentTimeMillis();
        System.out.println(nowTimeMillion);
    }
}
1
2
3
4
5
6

这个的作用：统计一个方法的耗时：

public class Test04 {
    public static void main(String[] args) throws Exception {
        //统计一个方法的耗时
        //在调用目标方法之前记录一个毫秒数
        long begin=System.currentTimeMillis();
        print();
        //在执行完目标方法之后记录一个毫秒数
        long end=System.currentTimeMillis();
        System.out.println("print方法耗费时长："+(end-begin)+"毫秒");
    }

    public static void print(){
        for(int i=0;i<1000000000;i++){
            ;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17