java中基本数据类型和包装类详解
基本数据类型
分类
Java的数据类型分为两大类：
- 基本数据类型
- 引用类型。
基本数据类型分为四大类型：布尔型、整数型、浮点型、字符型。
- 布尔型：boolean
- 整数型：byte，short，int，long
- 浮点型：float，double
- 字符型：char
引用类型：
- 数据
- 类
- 接口
对比
byte占1个字节，8位
short占2个字节，16位
int占4个字节，32位
long占8个字节，64位
float占4个字节，32位
double占8个字节，64位
char占2个字节，16位
boolean占1个字节，8位
自动类型转换、强制类型转换
- java是强类型语言，所以要进行有些运算的时候，需要用到类型转换
- 低-----------------------------------------》高
byte，short，char–》int–》long–》float–》double - 运算中，不同类型的数据先转化为同一类型，然后进行运算
- 自动类型转换：将取值范围小的类型转换为取值范围大的类型。
- 强制类型转换：将取值范围大的类型强制转换成取值范围小的类型 。
基本数据类型对应的包装类
- Boolean-》boolean
- Byte-》byte
- Short-》short
- Integer-integer
- Long-》long
- Float-》float
- Double-》double
- Charter-》char
基本数据类型和包装类型的区别
- 包装类是对象，拥有方法和字段，对象的调用都是通过引用对象的地址；基本类型不是
- 包装类型是引用的传递；基本类型是值的传递
- 声明方式不同：
基本数据类型不需要new关键字；
包装类型需要new在堆内存中进行new来分配内存空间 - 存储位置不同：
基本数据类型直接将值保存在值栈中；
包装类型是把对象放在堆中，然后通过对象的引用来调用他们 - 初始值不同：
int的初始值为 0 、 boolean的初始值为false
包装类型的初始值为null - 使用方式不同：
基本数据类型直接赋值使用就好；
包装类型是在集合如 coolectionMap时使用
包装类的特征
- 功能丰富：包装类本质上是一个对象，对象就包含属性和方法，比如hashCode、getClass、max、min等。
- 可定义泛型类型参数
包装类可以定义泛型，而基本类型不行。
比如使用Integer定义泛型，代码：List如果使用int定义就会报错list = new ArrayList<>(); - 序列化：因为包装类都实现了Serializable接口，所以包装类天然支持序列化和反序列化。
- 类型转换
包装类提供了类型转换的方法，可以很方便的实现类型之间的转换，比如Integer类型转换代码：
String age = "20";
int ageInt = Integer.parseInt(age) + 2;
//输出结果：22
System.out.println(ageInt);
- 高频区间的数据缓存
各包装类高频区域的取值范围：
Boolean：使用静态 final 定义，就会返回静态值
Byte：缓存区 -128~127
Short：缓存区 -128~127
Character：缓存区 0~127
Long：缓存区 -128~127
Integer：缓存区 -128~127
Float 和 Double 不会有缓存，其他包装类都有缓存。
Integer 是唯一一个可以修改缓存范围的包装类，在 VM optons 加入参数：
包装类下的==和equals
java详细的==和equals区别
- 由于包装类高频区间数据缓存的特征，在缓存区内的包装类对象，在第一次创建对象之后，就开辟了内存空间，下次再次出现的时候直接获取使用，超过缓存区间的数据才需要重新创建堆来保存。所以在缓存区内的包装类使用
==的时候返回的是true，超过缓存区间使用的==才返回false。 - 包装类都重写了Object类中的equals方法，重写后的equals是对包装类的对象进行判断，如果是同种类型的才继续判断他们的值是否一样，一样返回true，否则返回false。
测试代码如下：
package test;
public class print1 {
public static void main(String[] args) {
System.out.println("================Byte=============");
byte by=1;
byte by2=1;
Byte b=10;
Byte b2=10;
System.out.println((b==b2));//true
System.out.println((b.equals(b2)));//true
System.out.println(by==by2);
System.out.println("================Short=============");
Short s=10;
Short s2=10;
Short s3=133;
Short s4=133;
System.out.println((s==s2)+","+(s3==s4));//true,false
System.out.println(s.equals(s2) + "," + s3.equals(s4));//true,true
System.out.println("================Integer=============");
Integer age = 10;
Integer age2 = 10;
Integer age3 = 133;
Integer age4 = 133;
Integer age5 = new Integer(10);
System.out.println((age == age2) + "," + (age3 == age4));//true,false
System.out.println(age.equals(age2) + "," + age3.equals(age4));//true,true
System.out.println(age == age5);//false：new每次都创建一个对象，但是Integer不new的时候在缓存范围内都是一个对象
System.out.println(age5.equals(age));//true
System.out.println("================Long=============");
Long l = 10L;
Long l2 = 10L;
Long l3 = 133L;
Long l4 = 133L;
System.out.println((l == l2) + "," + (l3 == l4));//true,false
System.out.println(l.equals(l2) + "," + l3.equals(l4));//true,true
System.out.println("================Float=============");
Float f = 10f;
Float f2 = 10f;
Float f3 = 133f;
Float f4 = 133f;
System.out.println((f == f2) + "," + (f3 == f4));//false,false
System.out.println(f.equals(f2) + "," + f3.equals(f4));//true,true
System.out.println("================Double=============");
Double num = 10d;
Double num2 = 10d;
Double num3 = 133d;
Double num4 = 133d;
System.out.println((num == num2) + "," + (num3 == num4));//false,false
System.out.println(num.equals(num2) + "," + num3.equals(num4));//true,true
System.out.println("=================Byte,Short,Integer,Long,相同值之间的对比=============");
System.out.println(b.equals(age));//false;Byte的equals方法首先判断是否为Byte类型，如果不是就返回false，是的话再比较值相同的话就true
System.out.println(age.equals(age4));//false；Byte的equals方法首先判断是否为Byte类型，不是所以返回的是false
System.out.println(s4.equals(age4));//false
System.out.println(age.equals(l));//false
System.out.println("=================float和double");
float fl=0.1f;
double db=1.0/10;
System.out.println(fl);//0.1
System.out.println(db);//0.1
// 最好完全避免使用浮点数进行比较，因为会精度丢失，如果想要进行计算然后比较就可以使用BigDecimal 数据工具类进行比较。
System.out.println(fl==db);//false
float dl1=231212121212f;
float dl2=dl1+1;
System.out.println(dl1);//2.31212122E11
System.out.println(dl2);//2.31212122E11
System.out.println(dl1==dl2);//true
}
}
/*
执行结果：
================Byte=============
true
true
true
================Short=============
true,false
true,true
================Integer=============
true,false
true,true
================Long=============
true,false
true,true
================Float=============
false,false
true,true
================Double=============
false,false
true,true
=================Byte,Short,Integer,Long,相同值之间的对比=============
false
false
false
false
=================float和double
0.1
0.1
false
2.31212122E11
2.31212122E11
true
*/
Byte类下的equals方法源码：
其它的包装类的equals方法跟这个差不多，都是先比较是否为同一类型，不是就再继续比较值。
public boolean equals(Object obj) {
if (obj instanceof Byte) {
return value == ((Byte)obj).byteValue();
}
return false;
}
面试题
- int的最大值加1会发送什么结果？
System.out.println(Integer.MIN_VALUE-1==Integer.MAX_VALUE);//true
System.out.println(Integer.MAX_VALUE+1==Integer.MIN_VALUE);//true
- 以下程序执行的结果是？
Integer i1 = new Integer(10);
Integer i2 = new Integer(10);
Integer i3 = Integer.valueOf(10);
Integer i4 = Integer.valueOf(10);
System.out.println(i1 == i2);//false
System.out.println(i2 == i3);//false
System.out.println(i3 == i4);//true
new Integer(123) 与 Integer.valueOf(123) 的区别在于：
- new Integer(123) 每次都会新建一个对象；
- Integer.valueOf(123) 会使用缓存池中的对象，多次调用会 取得同一个对象的引用。
valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。源码如下：
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
编译器会在自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。
Integer m = 123;
Integer n = 123;
System.out.println(m == n); // true
面试题之基本数据类型和包装类
参考1
参考2