java之包装类

       Java中的基本类型功能简单，不具备对象的特性，为了使基本类型具备对象的特性，所以出现了包装类，就可以像操作对象一样操作基本类型数据。

一、基本类型对应的包装类

基本类型                  包装类型

byte  　　　　　　　 Byte

int                                 Integer

short                            Short

long                              Long

float                               Float

double                          Double

boolean                        Boolean

char                               Character

A.创建一个包装类对象：

Integer    i = new Integer(4);//创建了一个Integer对象，表示指定的int值

Integer    s = new Integer("8");//创建了一个Integer对象，表示String 参数"8"指定的int 值

包装类常用的方法如下：

      

包装类主要是两种方法，一种是本类型和其它类型之间进行转换，另一种是字符串和本类型以及基本类型之间的转换

如上图中的方法前五种是本类型和其他类型之间的转换，后三种是字符串和本类型以及基本类型之间的转换。

Double  d = new Double(5);
        byte d1 = d.byteValue();
        System.out.println(d1);

  Double  d = new Double(5);
        Byte d1 = d.byteValue();
        System.out.println(d1);

这两种都是可以的，本类型和其他类型之间的转换，可是为什么上面两个都可以呢？这便是接下来要讲的

B.基本类型与包装类型之间的转换

JDK1.5引入了自动装箱和拆箱的机制，那么什么是装箱和拆箱呢？

装箱:就是将基本类型转换成包装类，分为自动装箱和手动装箱　

int a1=4;
//        //手动装箱
//        Integer ai = new Integer(a1);
//        //自动装箱
//        Integer aj = a1;

 拆箱：就是将包装类型转换成基本类型，分为自动拆箱和手动拆箱

//手动拆箱
//        int ah = ai.intValue();
//        //自动拆箱
//        int ag = ai;

 没有什么能够阻挡它们之间的转换。

C.字符串和本类型以及基本类型之间的转换

c1.基本类型转换成字符串类型

　　　　c1a.包装类 的toString()方法

　　　　c1b.String 类的valueOf()方法

　　　　c1c.空字符串加一个基本类型变量

c2.字符串转换成基本类型

　　      c2a.包装类的parse***()静态方法

　　       c2b.包装类的valueOf()方法

            //基本类型转换成字符串类型有三种方法
            int b = 1;
            String b1 = Integer.toString(b);
            String b2 = String.valueOf(b);
            String b3 = b+"";
            System.out.println("b1:  "+b1+"b2: "+b2+"b3: "+b3);
            //字符串转换成基本类型的方法有两种
            int c1 = Integer.parseInt(b1);
            int c2 = Integer.valueOf(b2);

 因为存在自动装箱和自动拆箱，所以包装类型和基本类型一样

二、表示时间的类

　Java中的表示时间的类主要有Date和Calendar，其中Date位于java.util中，最主要是获取当前时间，默认的无参构造方法就可以获取当前时间，它可以结合SimpleDateFormat类更改输出的时间的格式；Calendar是一个抽象类，需要调用getInstance()方法获取对象，下面分别总结一下Date和Calendar类的用法。

A.Date和SimpleDateFormat共同表示时间

　　Date类直接new一个Date的对象就可以获取当前的时间

public static void main(String[] args) throws ParseException{

Date now = new Date();
        System.out.println(now);
        //创建一个SimpleDateFormat的对象，指定它的格式
        SimpleDateFormat  sdf = new SimpleDateFormat("yyyy年MM月dd日：HH：mm:ss");
        //将指定的日期格式化
        String date = sdf.format(now);
        System.out.println(date);
        //将指定的格式化后的日期解析成原来的日期格式
        Date date1 = sdf.parse(date);
        System.out.println(date1);
}

 

     第一行是Date的默认构造方法输出的当前的时间，从左到右是：星期 、月份、日期、时：分：秒  cst(表示中国标准时间)、年份。

       SimpleDateFormat类是规范date的格式，它属于java.text，是一种文本格式类。如上图，创建一个带格式的SimpleDateFormat对象,然后调用format方法可以使date以自定义的格式输出，形成了人们所习惯的风格。

      第三行是调用SimpleDateFormat类的parse()方法使得之前的date格式按照SimpleDateFormat中定义的格式解析成原来的Date的类型，注意：parse编译的时候可能会抛出异常，所以需要throws  ParseException（转换的异常），举例如下：

 String date = "2017-03-15 20:19:30";
        SimpleDateFormat  sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date1 = sdf.parse(date);
        System.out.println(date1);

 B.Calendar类表示时间

　　Calendar类是一个由abstract修饰的类，下面是它的源码

public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar> 

       说明不能通过new 的方法获取一个实例，由此，Java中提供了一个getInstance的方法，获取一个Calendar子类的实例对象，getInstance的源码如下：

public static Calendar getInstance()
    {
        return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
    }

     由源码可以看出来这个getInstance方法中有当地的时区，创建出来的是一个符合当地的实例，所以Calendar.getInstance是子类对象，并且可以根据createCalendar方法创建出来的是符合当地时区的日期子类判断是Calendar的子类对象。

    private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

 Calendar类为了方便对日期的操作，还提供了Calendar.YEAR,Calendar.MONTH等，可以通过get 方法获取当前的年或者月,还提供了setTime()，getTime()，getTimeinMillis()方法等，

Calendar  c = Calendar.getInstance();
        System.out.println(c);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DAY_OF_MONTH);
        int hour = c.get(Calendar.HOUR);
        int minute = c.get(Calendar.MINUTE);
        int second = c.get(Calendar.SECOND);
        SimpleDateFormat  sfd = new SimpleDateFormat("yyyy年MM月dd日：HH时mm分ss秒");
        //把Calendar类型转换成Date类型
        Date date = c.getTime();
        //把Date类型转换成Calendar类型
        c.setTime(date);
        //Date类型是标准的时间
        String dates = sfd.format(date);
        System.out.println(dates);
        //而由上面的get 到的都是一般的十二进制的数，不是标准的时间输出
        System.out.println(year+"年"+month+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");
        Long time = c.getTimeInMillis();
        System.out.println("毫秒数："+time);

java.util.GregorianCalendar[time=1489589906237,areFieldsSet=true,areAllFieldsSet=true,
lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],
firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2017,MONTH=2,WEEK_OF_YEAR=11,WEEK_OF_MONTH=3,DAY_OF_MONTH=15,DAY_OF_YEAR=74,DAY_OF_WEEK=4,
DAY_OF_WEEK_IN_MONTH=3,AM_PM=1,HOUR=10,HOUR_OF_DAY=22,MINUTE=58,SECOND=26,MILLISECOND=237,ZONE_OFFSET=28800000,DST_OFFSET=0]
2017年03月15日：22时58分26秒
2017年3月15日10时58分26秒
毫秒数：1489589906237

       由上面的代码可以看出来当Calendar的实例创建出来的时候就已经被初始化了，包含YEAR、MONTH等字段，所以通过get方法可以获取这些字段，获取了之后便根据自己的喜好输出，这样的结果是更加的便利操作.

getTime()方法是将Calendar转换成Date类型的

setTime(Date date)方法是将Date转换成Calendar类型的，返回值为void

getTimeInMillis()是获取距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量，毫秒数

小节:Date类是获取当前时间的类，默认构造方法即为生成一个拥有当前时间的对象，但是由于Date中的一些方法不当，所以现在很少使用Date类，建议使用Calendar类。

三、Math类

Math位于java.lang包下，其中包含了很多的基本运算方法，所有的方法否是静态的，可以直接使用Math.方法名()

double a4 = 12.08;
        int a5 = (int)a4;
        long a6 = Math.round(a4);
        double a7 = Math.floor(a4);
        double a8 = Math.ceil(a4);
        double a9 = Math.min(a4,a5);
        System.out.println("原数是： "+a4+"	直接转换的是："+a5+
                "	四舍五入是："+a6+"	小于参数最大整数是："+a7+"大于参数最小整数："+a8+"两数之间的最小值："+a9);
 

 结果：

原数是： 12.08	直接转换的是：12	四舍五入是：12	
小于参数最大整数是：12.0大于参数最小整数：13.0
两数之间的最小值：12.0

今天简单总结了一下所熟知的类，以后遇到复杂的了，就可以继续添加。