黑马程序员——java编程那些事儿____基本数据类型对象包装类及其jdk1.5新特性

-------android培训、java培训、期待与您交流！
----------

一 基本数据类型对象包装类

1 ，为了更方便的操作每个基本数据类型，java对其提供了很多的属性和方法供我们使用。

2，基本数据类型和对象类型的对应



3，用途

**将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能操作该数据。

**常用的操作之一：用于基本数据类型与字符串之间的转换。

例如：

int -- Integer

int num = 20;

A:Integer i = new Integer(num);

B:Integer i = Integer.valueOf(num);

Integer -- int

Integer i = new Integer(20);

A:int num = i.intValue();

int -- String

int num = 20;

A:String s = String.valueOf(num);

B:String s = ""+num;

C:String s = Integer.toString(num);

String -- int

String s = "20";

A:int num = Integer.parseInt(s);

B:Integer i = new Integer(s);或者Integer i = Integer.valueOf(s);

int num = i.intValue();

基本数据类型转成字符串。

a)基本数据类型+""

b)基本数据类型.toString(基本数据类型值);

如： Integer.toString(34);//将34整数变成"34";

字符串转成基本数据类型。

静态：xxx a = Xxx.parseXxx(String);

int a = Integer.parseInt("123");

double b = Double.parseDouble("12.23");

boolean b = Boolean.parseBoolean("true");

非静态：Integer i = new Integer("123");

int num = i.intValue();

十进制转成其他进制。

toBinaryString();

toHexString();

toOctalString();

其他进制转成十进制。

parseInt(string,radix);

4,构造方法

字段摘要：

static int MAX_VALUE 值为 2^31-1 的常量，它表示 int 类型能够表示的最大值

static int MIN_VALUE 值为 -2^31 的常量，它表示 int 类型能够表示的最小值

static Class<Integer> TYPE 表示基本类型int的Class 实例

Integer(int value) 构造一个新分配的Integer对象，它表示指定的int值。

Inreger(String s) 注意：s必须是纯数字的字符串。否则会有异常NumberFormatException

5，几个常用的方法

Integer.toBinaryString();

以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。

Integer.toOctalString();

以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。

Integer.toHexString();

以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。

static int Integer.parseInt(String s) 将字符串参数作为有符号的十进制整数进行解析,字符串必须是int型范围内的数字字符串

static int Integer.parseInt(String s,int basic)

使用第二个参数指定的基数,将字符串参数解析为有符号的整数.字符串必须是int型范围内的数字字符串

short shortValue() 以short类型返回该Integer的值。

int intValue() 以int类型返回该Integer的值。

static Integer valueOf(int num) 返回一个表示指定的 int 值的 Integer 实例。

static Integer valueOf(String s) 返回保存指定的String的值的Integer对象。

static Integer valueOf(String s, int radix) 返回一个Integer对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的String中提取的值。

class IntegerDemo
{
public static void sop(String str)
{
System.out.println(str);
}

public static void main(String[] args)
{
//整数类型的最大值
sop("int max : "+Integer.MAX_VALUE);

//将一个字符串转化成整数
int num = Integer.parseInt("123");//必须传入数字格式的字符串
sop("num="+(num+4));

//十进制转换成其他进制
sop(Integer.toBinaryString(6));
sop(Integer.toHexString(60));

//其他进制转换成十进制
int x = Integer.parseInt("110",2);
sop("x="+x);

}
}

二 基本数据类型对象包装类新特性（jdk1.5以后出现的新特性自动装箱与拆箱）

**装箱：自动把一个基本数据类型的数据装箱成一个该类型数据的对象引用

Integer x = 4;//自动装箱 这句相当于Integer x = new Integer(4) 4相当于new Integer(4);

**拆箱：自动把一个基本数据类型的对象引用拆箱成一个基本数据类型的数据，再参与运算

x = x + 2;//自动拆箱 x+2中的x进行了自动拆箱，变成了int类型，和2进行加法运算,再将和进行装箱赋给x。 x+2中的x的拆箱原理为 x.intValue()

sop("x="+x);

class IntegerDemo1
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
//method();
//method_1();
method_2();
}

public static void method()
{
Integer x = new Integer("123");
Integer y = new Integer(123);
sop("x==y:"+(x==y));//false因为出现了新特性看method_1()就知道了
sop("x.equals(y):"+x.equals(y));//true
}
public static void method_1()
{
//Integer x = new Integer(4);

Integer x = 4;//自动装箱 这句相当于Integer x = new Integer(4)   4相当于new Integer(4);
x = x + 2;//x+2中的x进行了自动拆箱，变成了int类型，和2进行加法运算,再将和进行装箱赋给x。  x+2中的x的拆箱原理为 x.intValue()

sop("x="+x);
}

public static void method_2()
{
Integer m = 128;
Integer n = 128;
sop("m==n:"+(m==n));//false

Integer a = 127;
Integer b = 127;
sop("a==b:"+(a==b));//true,因为a和b指向了同一个Integer对象
//对于新特性，当数值在byte范围内（-128~127），如果该数值已经存在，
//则不会再开辟新空间
}
}

**享元模式：

Integer num1 = 12;

Integer num2 = 12;

System.out.println(num1 == num2);//打印true

Integer num5 = Integer.valueOf(12);

Integer num6 = Integer.valueOf(12);

System.out.println(num5 == num6);//打印true

nteger num3 = 129;

Integer num4 = 129;

System.out.println(num3 == num4);//打印false

为什么前面的返回true而后面的运算返回false呢？

对于基本数据类型的整数，装箱成Integer对象时，如果该数值在一个字节内,(-128~127)，

一旦装箱成Integer对象后，就把它缓存到磁里面，当下次，又把该数值封装成Integer对象时

会先看磁里面有没有该对象，有就直接拿出来用，这样就节省了内存空间。因为比较小的整数，

用的频率比较高，就没必要每个对象都分配一个内存空间。

这就是享元模式！比如26个英文字母，10个阿拉伯数字

享元模式的另一种解释：

有很小的对象，有很多属性相同，把他们变成一个对象，不同的属性变成方法的参数，称之为外部状态，相同的属性称之为内部状态。

-------android培训、java培训、期待与您交流！
----------