java基础数据类型包装类

*/

.hljs {
display: block;
overflow-x: auto;
padding: 0.5em;
color: #333;
background: #f8f8f8;
}

.hljs-comment,
.hljs-template_comment,
.diff .hljs-header,
.hljs-javadoc {
color: #998;
font-style: italic;
}

.hljs-keyword,
.css .rule .hljs-keyword,
.hljs-winutils,
.javascript .hljs-title,
.nginx .hljs-title,
.hljs-subst,
.hljs-request,
.hljs-status {
color: #333;
font-weight: bold;
}

.hljs-number,
.hljs-hexcolor,
.ruby .hljs-constant {
color: #099;
}

.hljs-string,
.hljs-tag .hljs-value,
.hljs-phpdoc,
.tex .hljs-formula {
color: #d14;
}

.hljs-title,
.hljs-id,
.coffeescript .hljs-params,
.scss .hljs-preprocessor {
color: #900;
font-weight: bold;
}

.javascript .hljs-title,
.lisp .hljs-title,
.clojure .hljs-title,
.hljs-subst {
font-weight: normal;
}

.hljs-class .hljs-title,
.haskell .hljs-type,
.vhdl .hljs-literal,
.tex .hljs-command {
color: #458;
font-weight: bold;
}

.hljs-tag,
.hljs-tag .hljs-title,
.hljs-rules .hljs-property,
.django .hljs-tag .hljs-keyword {
color: #000080;
font-weight: normal;
}

.hljs-attribute,
.hljs-variable,
.lisp .hljs-body {
color: #008080;
}

.hljs-regexp {
color: #009926;
}

.hljs-symbol,
.ruby .hljs-symbol .hljs-string,
.lisp .hljs-keyword,
.tex .hljs-special,
.hljs-prompt {
color: #990073;
}

.hljs-built_in,
.lisp .hljs-title,
.clojure .hljs-built_in {
color: #0086b3;
}

.hljs-preprocessor,
.hljs-pragma,
.hljs-pi,
.hljs-doctype,
.hljs-shebang,
.hljs-cdata {
color: #999;
font-weight: bold;
}

.hljs-deletion {
background: #fdd;
}

.hljs-addition {
background: #dfd;
}

.diff .hljs-change {
background: #0086b3;
}

.hljs-chunk {
color: #aaa;
}

#container {
padding: 15px;
}
pre {
border: 1px solid #ccc;
border-radius: 4px;
display: block;
background-color: #f8f8f8;
}
pre code {
white-space: pre-wrap;
}
.hljs,
code {
font-family: Monaco, Menlo, Consolas, 'Courier New', monospace;
}
:not(pre) > code {
padding: 2px 4px;
font-size: 90%;
color: #c7254e;
background-color: #f9f2f4;
white-space: nowrap;
border-radius: 4px;
}
-->

基础数据类型包装类

当一个程序要求交互式输入一个int类型的年龄时，从文本框中输入的结果肯定是String类型的。要在程序中进行相关操作，它必须先转换为int类型。因此可以使用数据类型的转换或强制转换，但这种转换方式太过简单，功能太少，因此java中提供了数据类型包装类的概念。

数据类型包装类是指可以将数据转换成对象(包装)，还可以从数据对象中取得数据(解包装)。相当于对数据包了一层皮，里面的内容不变，但既然是对象，就有了很多数据操作的方法。包装的过程是将栈空间的数据复制到堆空间的对象中，这个对象中的内容就是所需要的数据。

byte对应的包装类为Byte；
short --> Short；
int --> Integer；
long --> Long；
float --> Float；
double --> Double；
boolean --> Boolean；
char --> Character；

这些数据类型包装类的功能大多都相似，提供的各种方法也大多相似。其中最重要功能之一是：数据类型和String类型之间互相转换。★★★★★

以Integer包装类为例：

基本功能：

1. 它有几个字段属性：MAX_VALUE、MIN_VALUE，这两个分别表示int类型的数据最大值和最小范围值。

   System.out.println(Integer.MAX_VALUE);
   

2. 提供了将int数据转换成二进制、八进制、十六进制的方法，返回值为String类型：

   System.out.println(Integer.toBinaryString(20));
   

3. 将String类型数据转换为Int类型的方法parseInt()，显然返回值为Int类型：

   System.out.println("123"+2);
   System.out.println(Integer.parseInt("123")+2);
   System.out.println(Integer.parseInt("a123")+2); //Exception:NumberFormatException
   

   还有个重载的方法，用于将其他进制的值转换为十进制：

   System.out.println(Integer.parseInt("110",2));
   

   其它数据类型包装类也同样有String转对应类型的解析方法：parseByte()、parseDouble()等，但character没有，因为它本身就是字符。

4. int类型转String类型：

   System.out.println(Integer.toString(110)+2);
   System.out.println(String.valueOf(110)+2);
   System.out.println(110+""+2);
   

5. 将int数值装进integer对象中，可以通过构造方法或valueOf()方法实现。构造方法和valueOf()都重载了两种参数的写法，一个是int参数，一个是String参数：

   int i = new Integer(4);
   int ii = new Integer("4");
   int iii = Integer.valueOf(4);
   int iii = Integer.valueOf("4");
   

6. xxxValue()方法取出对象中的值，并转换为数值类型。因为操作的是对象，因此该类方法是非静态方法，需要以对象名调用来返回该对象中包装的值：

   int i = new Integer(4);
   int num = i.intValue();   //对象调用，并返回为int类型
   Long num = i.LongValue(); //取出对象i中的值，并转换为Long类型
   

7. 判断Integer对象是否相等。Integer重写了equals()方法，只要对象中的值相同，对象就相等：

   int x = new Integer(3);
   int y = new Integer(3);
   System.out.println(x==y);        //false
   System.out.println(x.equals(y)); //true
   

自动装箱、自动拆箱特性：

要操作一个数值，需要定义一个int类型的变量:int i = 4;，要使用Integer类的一些通用方法，需要定义一个Integer类的对象Integer i = new Integer(4);。要对int变量执行方法，需要先将其封装为Integer类对象，或者反过来，要加减乘除Integer对象，需要将其转换为int数据类型，之间的来回转换极为麻烦。

从jdk 1.5开始，支持自动装箱、拆箱的功能。

Integer i = 4;

定义一个引用类型变量i，引用类型只能指向对象，所以4自动转换为对象，所以等号右边这等价于使用了Integer.valueOf(4)。Integer.valueOf()重写的方法中实际上是调用了new Integer()。所以下面的几种写法是等价的：

Integer i = 4;
Integer i = new Integer(4);
Integer i = Integer.valueOf(4);

自动拆箱则相反，是指自动取出对象中的值。

Integer i = 4;
i = i + 5;

其中"i+5"是数值运算，i首先从对象转换为数值，得到9。而等号左边的i是对象引用，所以还要再将9自动装箱为对象。所以等价于下面的代码：

i = Integer.valueOf(i.intValue()+5);

由此可见，自动装箱、拆箱的特性，极大地增强了可读性。

但自动装箱的过程有一点小细节：当数值在byte范围内(-128-127)时，自动装箱时不会新创建对象。意思是当有一个Integer x对象中的值为3时，它小于127，如果还有一个Integer y，它的值也是3，那么x和y指向同一个对象。

Integer x = new Integer(3);
Integer y = new Integer(3);
System.out.println(x==y);        //false
System.out.println(x.equals(y)); //true
Integer a = 3;
Integer b = 3;
System.out.println(a==b);        //true
System.out.println(a.equals(b)); //true
Integer c = 128;
Integer d = 128;
System.out.println(c==d);        //false
System.out.println(c.equals(d)); //true

转载请注明出处：http://www.cnblogs.com/f-ck-need-u/p/7783126.html

注：若您觉得这篇文章还不错请点击右下角推荐，您的支持能激发作者更大的写作热情，非常感谢！