java中的数据类型以及包装类

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：

1. byte 数据类型是8位、有符号的，以二进制补码表示的整数；
2. 最小值是 -128（-2^7）；
3. 最大值是 127（2^7-1）；
4. 默认值是 0；
5. byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
6. 例子：byte a = 100，byte b = -50。

short：

1. short 数据类型是 16 位、有符号的以二进制补码表示的整数
2. 最小值是 -32768（-2^15）；
3. 最大值是 32767（2^15 - 1）；
4. Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
5. 默认值是 0；
6. 例子：short s = 1000，short r = -20000。

int：

1. int 数据类型是32位、有符号的以二进制补码表示的整数；
2. 最小值是 -2,147,483,648（-2^31）；
3. 最大值是 2,147,483,647（2^31 - 1）；
4. 一般地整型变量默认为 int 类型；
5. 默认值是 0 ；
6. 例子：int a = 100000, int b = -200000。

long：

1. long 数据类型是 64 位、有符号的以二进制补码表示的整数；
2. 最小值是 -9,223,372,036,854,775,808（-2^63）；
3. 最大值是 9,223,372,036,854,775,807（2^63 -1）；
4. 这种类型主要使用在需要比较大整数的系统上；
5. 默认值是 0L；
6. 例子： long a = 100000L，Long b = -200000L。

"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

1. float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
2. float 在储存大型浮点数组的时候可节省内存空间；
3. 默认值是 0.0f；
4. 浮点数不能用来表示精确的值，如货币；
5. 例子：float f1 = 234.5f。

double：

1. double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
2. 浮点数的默认类型为double类型；
3. double类型同样不能表示精确的值，如货币；
4. 默认值是 0.0d；
5. 例子：double d1 = 123.4。

boolean：

1. boolean数据类型表示一位的信息；
2. 只有两个取值：true 和 false；
3. 这种类型只作为一种标志来记录 true/false 情况；
4. 默认值是 false；
5. 例子：boolean one = true。

char：

1. char类型是一个单一的 16 位 Unicode 字符；
2. 最小值是 \u0000（即为0）；
3. 最大值是 \uffff（即为65,535）；
4. char 数据类型可以储存任何字符；
5. 例子：char letter = 'A';。

官方提供的是这八种，看到这里有人会问String呢？Boolean呢？

我们打开idea

可以看到String是一个类，属于引用数据类型。同理Boolean我们可以看一下。

自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级。

低  ------------------------------------>  高byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

1. 1. 不能对boolean类型进行类型转换。
2. 2. 不能把对象类型转换成不相关类的对象。
3. 3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
4. 4. 转换过程中可能导致溢出或损失精度，例如：

int i =128;    byte b = (byte)i;

因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

1. 5. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

(int)23.7 == 23;        (int)-45.89f == -45

自动类型转换

必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

实例

public class ZiDongLeiZhuan{         public static void main(String[] args){             char c1='a';//定义一个char类型             int i1 = c1;//char自动类型转换为int             System.out.println("char自动类型转换为int后的值等于"+i1);             char c2 = 'A';//定义一个char类型             int i2 = c2+1;//char 类型和 int 类型计算             System.out.println("char类型和int计算后的值等于"+i2);         }}

运行结果为:

char自动类型转换为int后的值等于97char类型和int计算后的值等于66

解析：c1 的值为字符 a ,查 ASCII 码表可知对应的 int 类型值为 97， A 对应值为 65，所以 i2=65+1=66。

强制类型转换

1. 1. 条件是转换的数据类型必须是兼容的。
2. 2. 格式：(type)value type是要强制类型转换后的数据类型 实例：
3. 实例

public class QiangZhiZhuanHuan{     public static void main(String[] args){         int i1 = 123;         byte b = (byte)i1;//强制类型转换为byte         System.out.println("int强制类型转换为byte后的值等于"+b);     }}

运行结果：

int强制类型转换为byte后的值等于123

隐含强制类型转换

1. 1. 整数的默认类型是 int。
2. 2. 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。

包装类

为什么有了基本的数据类型我们还需要包装类呢？首先java是一门面向对象的语言，其次有了包装类我们可以快速的实现数据类型之间的转化。

我们看一看int的包装类，Integer。

根据文档里边所提及的我们就可以快速的将String类型转化为int类型，看到官方的文档是不是更清楚了包装类的作用。

我们试着运行下，下边的代码：

Integer i = new Integer(100);

Integer j = new Integer(100);

System.out.print(i == j);

输出结果是false

为什么呢因为Integer是一个类我们这两行代码用的new关键字，然后ij就变成了两个对象，因为其内存地址不同，所以比较结果就是false。

再看看下边的代码：

Integer i = new Integer(100);

int j = 100；

System.out.print(i == j); //true

为什么这里又是true呢，Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）

再来：

Integer i = new Integer(100);

Integer j = 100;

System.out.print(i == j); //false

非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）

再观察下边的代码：

Integer i = 100;

Integer j = 100;

System.out.print(i == j); //true

Integer i = 128;

Integer j = 128;

System.out.print(i == j); //false

这里过根据我们前边讲的不应该都是输出true吗，为什么最后一个是false，讲到这里我们就需要知道，如下的一个规则：对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false。、

关于Integer的常用api介绍：

1、Integer.parseInt(s);

 String a = "100";

   int b = Integer.parseInt(a);

    System.out.println(b);

}

结果：100

2、Integer.valueOf(s);

这个用法和上边的是一样的，这里我们要了解下为什么会有这两个方法，他们之间的区别是什么。

Integer.parseInt(s);方法得到的结果可以直接用==来做比较，因为得到的是int类型，而Integer.valueOf(s);该方法得到的结果是一个对象，在比较的时候我们选择equals();方法