3.1常用类（java学习笔记）包装类及日期类

一、包装类

java是一门面向对象的语言，秉承一切皆对象的思想。

可java中有一些基本数据类型并不是对象，有时可能需要将它们变为对象。

这时就需要用到我们的包装类了。

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

通过对应的包装类可以让基本属性拥有对象的特性，之后可以使用相关的操作。

public class TestInteger {
public static void main(String[] args) {
int i = 10;
Integer I = new Integer(i);//转化为Integer类型，也称装箱。
int temp = I.intValue(); //将I转化为基本数据类型，也称拆箱。
String str_i = Integer.toString(i);//将数字变字符串
int i_i = Integer.parseInt(str_i);//将字符串变数字
 System.out.println(str_i);
System.out.println(temp);
System.out.println(i_i);
System.out.println(I.MAX_VALUE);//输出int能表示的最大值。
 }
}

运行结果：
10
10
10
2147483647

自动装箱与自动拆箱

通过上面代码我们可以看出，都是手动装箱与拆箱的。

jdk检查到两边类型符合时，会自动装箱与拆箱无需手动拆箱。

public class TestInteger {
public static void main(String[] args) {
Integer I = 3; //自动装箱 Integer I = new Integer(30;
int i = I; //自动拆箱 int i = I.intValue();
 System.out.println(I);
System.out.println(i);
System.out.println(I.MAX_VALUE);//输出int能表示的最大值。
 }
}

运行结果：
3
3
2147483647

我们来看下下面这段代码：

public class TestInteger {
public static void main(String[] args) {
Integer I1 = ;
Integer I2 = ;
Integer I3 = ;
Integer I4 = ;
Integer I5 = new Integer(127);
System.out.println(I1 == I2);//此处对象比较，比较的是地址值。
System.out.println(I3 == I4);
System.out.println(I1 == I5);//此处为false
System.out.println(System.identityHashCode(I1));//这里打印的hashCode，并不是对象存储的地址。
System.out.println(System.identityHashCode(I2));//即使是不同对象，也可能有相同的hashCode，
System.out.println(System.identityHashCode(I3));//此处只是想描述它们的地址是不同的，但我也不清楚如何获得对象内存地址
System.out.println(System.identityHashCode(I4));//如果有哪位仁兄知道烦请告知，不胜感谢！
System.out.println(I1.equals(I2));//此处比较的是数值，//这里用hashCode当做地址只是为了便于理解，但hashCode不是对象内存地址。
System.out.println(I3.equals(I4));
}
}

运行结果：
true
false
false
366712642
366712642
1829164700
2018699554
true
true

我们可以看到I1 == I2，和 I3 == I4一个为false一个为true。

对此大家可能有疑问，这明显不科学。我们来看I1，I2，I3，I4的地址。

代码中打印的是hashCode并不是地址，这样只是为了便于理解，就姑且把hashCode看做对象地址。

会发现I1和I2地址相同，I3,和I4地址不同，对象比较是比较地址所以才会造成这种结果。

我们看下JDK源码中的注释

代表[-128,127]之间的值会被缓存，如果值在这个范围内就直接引用已经创建好了的。

我们来看JDK源码中的一部分，high = 127，low = -128；

他会将[-128,127]每一个都提前创建好一个对象。当自动装箱时，会检查是否在这个的范围内，

如果是则直接引用已经创建好了的，如果不是则创建新的对象。

但要注意一点，用new Integer(10)创建无论是否在范围内都会新建一个对象，所以 I1 == I5 为false。

二、Date

1.Date简介

Date是时间的核心类，主要用于表示时间。其中表示时间的是一个long型的数值faseTime，单位是ms。

其中有一个基准，为1970-1-1 00:00:00为基准。

当fastTime为1000时代表过了1秒，既1970-1-1 00:00:01。

需要表示1970-1-1 00:01:00 既fastTime = 1000 * 60;

下面用代码举例说明：

import java.util.Date;
public class TestDate {
public static void main(String[] args) {
Date date_now = new Date();
Date date_test = new Date(60000);//此处是60s即一分钟，60000的单位是ms
System.out.println(date_now);
System.out.println(date_test);
}
}

运行结果：
Sat Aug 18 21:54:02 CST 2018
Thu Jan 01 08:01:00 CST 1970

我们没有向Date()中添加参数时，会默认传递一个当前时间。

如果传递了时间就按传递的参数来表示时间。

可我们在date_test中设置是60000应该是1分钟，显示的应该是1970-1-1 00:01:00，可最后运行显示的是

1970-1-1 08:01:00，这是因为我们采用的是中国标准（CST）时间，而作为基准的是GMT时间，中间有八个小时的时差。

输出改成date_test.toGMTString()就可以输出GMT时间。1970-1-1 00:01:00

2.Date常用方法

1.getTime()

返回表示当前时间的long型数。

public class TestDate {
public static void main(String[] args) {
Date date_now = new Date();
Date date_test = new Date(60000);
System.out.println(date_now);
System.out.println(date_now.getTime());//获得代表当前时间的long型数值
System.out.println(date_test);
System.out.println(date_test.getTime());//获得代表1970-1-1 00:01:00（GMT）时间的long型数组。
}
}

运行结果：
Sun Aug 19 11:16:14 CST 2018
1534648574913
Thu Jan 01 08:01:00 CST 1970
60000

2.setTime()

我们看下JDK源码中也很容易理解，就是设置一个值。

public class TestDate {
public static void main(String[] args) {
Date date_test = new Date(60000);
date_test.setTime(0);//设置为基准时刻（GMT）
System.out.println(date_test);
System.out.println(date_test.getTime());//获得代表当前时间的long型数值。
}
}

运行结果：
Thu Jan 01 08:00:00 CST 1970
0

3.after（）和before（）

after测试此日期是否在指定日期之后，是返回true，否返回false。

我们看下源码中的：

return getMillisOf(this) > getMillisOf(when);

获取此日期对象的毫秒值 > 获取指定日期对象的毫秒值。

其实质就是比较日期的long型数值。

同样before（）也类似；

测试此日期是否在指定时间之前，是返回true，否返回false。

public class TestDate {
public static void main(String[] args) {
Date date_test = new Date(0);
Date date_now = new Date();
System.out.println(date_now.after(date_test));//当前日期是否在1970年基准时刻之后
System.out.println(date_now.before(date_test));//当前日期是否在1970年基准时刻之前
}
}

运行结果：
true
false

4.toString()

首先显然这个重写了Object类中的toString（）方法。

我们看源码中注释部分的格式是否似曾相识？

我们来看这个：Thu Jan 01 08:00:00 CST 1970

我们会发现输出时间时就是按照这种格式输出的。

public class TestDate {
public static void main(String[] args) {
Date date_test = new Date(0);
System.out.println(date_test);
System.out.println(date_test.toString());//按指定格式输出时间
}
}

运行结果：
Thu Jan 01 08:00:00 CST 1970
Thu Jan 01 08:00:00 CST 1970

我们会发现调用或者不调用tiString（）输出的格式都是一样的，说明输出时默认调用了toString()按照指定的格式打出时间。

三、DateFormat和SimpleDateFormat

从类名的翻译来看就可以大概看出这两个类是做什么的。

日期格式，简单日期格式。可以看出这两个类与日期格式有关

它们可以帮助我们按指定日期格式转换。

由于DateFormat是抽象类无法直接创建对象，所以我们需要通过它的子类SimpleDateFormat创建对象。

1.format(Date);

format可以将日期转化为指定格式的字符串。

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestSimpleDateFormat {
public static void main(String[] args) {
Date date = new Date();
DateFormat China_time = new SimpleDateFormat("yyyy-MM-dd hh-mm-ss");//创建一个时间格式"yyyy-MM-dd hh-mm-ss"
String date_str = China_time.format(date);//将当前时间转换为指定格式的字符串
 System.out.println(date_str);
}
}

运行结果：
2018-08-19 03-47-47
//即yyyy-MM-dd hh-mm-ss(年月日时分秒)

可以看到最后是按照我们指定的格式输出。 我们可以自行定义格式比如（ss -mm-hh dd-MM-yy）秒分时日月年，并且年份显示两位（会自动显示后两位）。

我们来看这一句 DateFormat China_time = new SimpleDateFormat("yyyy-MM-dd hh-mm-ss");其中有一个向上转型。如果子类中重写了父类的方法，那么调用的是子类的，反之调用的是父类的。（此处子类中有同名的方法但返回值不同故不构成重写，调用的是父类（DateFormat）中的方法。

2.parse（）

将字符串转换为指定格式的日期对象，输入的字符串格式要和指定的格式相同。

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

public class TestSimpleDateFormat {
    public static void main(String[] args) {
        Date date = new Date();
        DateFormat China_time = new SimpleDateFormat("yyyy-MM-dd hh-mm-ss");//创建一个时间格式"yyyy-MM-dd hh-mm-ss"
        String date_str = "2018-8-19 16-18-00";//字符串格式必须和设定格式相同，不然会解析错误
        try {
            date = China_time.parse(date_str);//将当前字符串按指定格式转换为时间。
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(date);
    }
}

运行结果：
Sun Aug 19 16:18:00 CST 2018

下面有一张表代表了各个字母的含义：

四、Calendar与GregorianCalendar

Calendar类是一个抽象类提供了时间的展示及计算功能，同样需要通过其子类来创建。

1.get（int filed）

filed为指定属性，指定什么就会根据方法的功能得到对应的数据。

例如指定field为Cnlendar.year就代表获得当前日历对象的年份。

import java.util.Calendar;
import java.util.GregorianCalendar;

public class TestCalendar {
    public static void main(String[] args) {
        Calendar now = new GregorianCalendar();//构造器没有参数时默认传递当前时间
        Calendar c = new GregorianCalendar(2008,8,8); //构造器有很多重载的方法可以设置年月日时分秒等...

        int year = c.get(Calendar.YEAR);  //获得该对象年份的值
        int month = c.get(Calendar.MONTH);//获得该对象月份的值
        int day = c.get(Calendar.DAY_OF_MONTH); //获得该对象在这个月中天数的值。

        int year_now = now.get(Calendar.YEAR);
        int month_now = now.get(Calendar.MONTH);
        int day_now = now.get(Calendar.DAY_OF_MONTH);

        System.out.println(year + "-" + month + "-" + day);//输出设置时间年月日的值
        System.out.println(year_now + "-" + month_now + "-" + day_now);//输出当前时间年月日的值。
    }
}

运行结果：
2008-8-8
2018-7-19
//我这里当前时间时2018-8-19 

看到上述大家可能会有疑问，获取当前月的值8月应该是8呀，为什么打印出来的确是7。

首先8月只是我们国内的说法，并不是通用的。国外没有八月，只有August。

JDK源码中0代表January即一月，11代表12月。所以但实际上代表八月的数值常量是7.

我们设置的8其实不是八月，我们设置的是数值8，数值8代表的是九月。

我们看下面一个例子。

import java.util.Calendar;
import java.util.GregorianCalendar;

public class TestCalendar {
    public static void main(String[] args) {
        Calendar c = new GregorianCalendar(2008,Calendar.AUGUST,8);//此处设置的是8月August

        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int day = c.get(Calendar.DAY_OF_MONTH);

        System.out.println(year + "-" + month + "-" + day);
    }
}

运行结果：
2008-7-8//最后运行是7.说明代表八月的常量是7

同样星期天的常量值是1，星期一是2，。。。星期六是7

2.getTime(),getTimeMillis()

getTimeMillis()是返回当前日历对象的时间值，返回的是一个long型的毫秒值。

getTime() 是返回一个时间类的对象，而且其中调用了getMillis(),并将其设置为时间。

import java.util.Calendar;
import java.util.GregorianCalendar;

public class TestCalendar {
    public static void main(String[] args) {
        Calendar c = new GregorianCalendar(2008,Calendar.AUGUST,8);//设置时间为2008-8-8 

        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int day = c.get(Calendar.DAY_OF_MONTH);

        System.out.println(c.getTimeInMillis());//获取代表当前日历对象的时间值
        System.out.println(c.getTime()); //将日历对象时间设置为Date类对象的时间，并返回一个Date对象。简单说就是将Calendar类对象转换为Date类对象。
        System.out.println(year + "-" + month + "-" + day);
    }
}

运行结果：
1218124800000
Fri Aug 08 00:00:00 CST 2008
2008-7-8

3.add(field，amount)；

日期计算，这是很强大的一个方法。可以进行日期的计算，如加减一（年、月、日）。

field指定操作的属性是年还是月还是日......，后面代表加减的数值。

import java.util.Calendar;
import java.util.GregorianCalendar;

public class TestCalendar {
    public static void main(String[] args) {
        Calendar c = new GregorianCalendar(2008,Calendar.AUGUST,8);//2008-8-8
        System.out.println(c.getTime());
        c.add(Calendar.YEAR, 1);//加一年
        c.add(Calendar.MONTH,1);//加一月
        c.add(Calendar.DAY_OF_MONTH, 2);//加两天
        c.add(Calendar.DATE, -1); //减一天，DATE和DAY_OF_MONTH是一样的，它们的常量值都是5；
        System.out.println(c.getTime());//最后加了一年一月一天。

    }
}

运行结果：
Fri Aug 08 00:00:00 CST 2008
Wed Sep 09 00:00:00 CST 2009

下面有一个小小例子，刚好可以巩固下前面学的几个时间类。

简易日历，输入年月日，输出对应的月份的日历。

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Scanner;

public class TestDate {
    public static void main(String[] args) {
        Date date = new Date();             //创建一个时间对象，用于存放输入时间。
        Scanner input = new Scanner(System.in);   //创建一个输入
        System.out.println("请按提示格式输入日期：例：（2000-1-1）");
        String inputDateString = input.nextLine();  //输入时间的字符串格式必须与后面指定格式相同。
        DateFormat chinaTimeFormat = new SimpleDateFormat("yyyy-MM-dd");//注意此处格式
        try {
             date = chinaTimeFormat.parse(inputDateString);//将输入的字符串转换成时间对象
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        Calendar cn_InputDate = new GregorianCalendar();//创建两个日历对象。
        Calendar cn_PrinfDate = new GregorianCalendar();//一个用于存储输入日期，一个用于打印。
        cn_InputDate.setTime(date);//将输入的时间设置到用于存放日期的日历类。
        System.out.println("日\t一\t二\t三\t四\t五\t六");
        cn_PrinfDate.set(cn_InputDate.get(Calendar.YEAR), cn_InputDate.get(Calendar.MONTH), 1);//打印总是从1号开始，所以将输入的日期设置为1。
        for(int i = 1; i < cn_PrinfDate.get(Calendar.DAY_OF_WEEK); i++){ //需要打印的空格数。即1号从星期几开始。
            System.out.print("\t");//一个\t代表一个制表位八个空格。
        }
        for(int i = 1; i <= getMaxDaysOfMonth(cn_InputDate.get(Calendar.YEAR),cn_InputDate.get(Calendar.MONTH));i++){//日期从1号开始打印
            if(i == cn_InputDate.get(Calendar.DAY_OF_MONTH)){//如果当前要打印的i和输入日期中的day相同就加个*
                    System.out.printf(i + "*\t"); //\t的作用可参考：https://blog.csdn.net/hju22/article/details/79773252
            }else{
                System.out.printf(i + "\t");
            }
            if(cn_PrinfDate.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY){//如果周六打印完就换行。
                System.out.println();
            }
            cn_PrinfDate.add(Calendar.DAY_OF_MONTH, 1);//每打印一天，日期增加一天。
        }
        }

        private static int getMaxDaysOfMonth(int year, int month){ //获取当前月份最大天数的函数。主要是判断闰年与否
        int M[] = {31,28,31,30,31,30,31,31,30,31,30,31};
        int M2[] = {31,29,31,30,31,30,31,31,30,31,30,31};
        if(((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)){
            return M2[month];//是闰年采用闰年的天数，反之采用非闰年天数。
        }else
        {
            return M[month];//由于刚好get(Calendar.MONTH)获取到月份的数值是从0开始和数组的的下标对应。
        }
    }
}