Java基本数据类型、包装类、类型转换

1. Java基本数据类型、包装类

Java的基本数据类型有八种，分别为四种整数型（byte、short、int、long）、两种浮点型（float、double）、一种字符型（char）、一种布尔型（boolean）。对应包装类如下表所示：

数据类型	对应包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

包装类出现的目的？

Java是一种面向对象的编程，都默认继承Object类，而基本数据类型不具有对象属性，因此就出现了对应的包装类。
包装类的具体应用。比如说，在集合List、Set、Hash当中，只能存储Object类型，我们是不能存储基本数据类型的，只能存储对应的包装类型。

基本数据类型与包装类的区别？

• 存储位置：基本数据类型将值从常量缓存池里拿取存储于栈中，而包装类把对象存储于堆内存中，对象的引用存储于栈中。
  

• 声明方式：基本数据类型直接赋值，包装类通过new的方式（JDK1.5之后提供自动拆装箱，包装类可以直接赋值。装箱boxing：把基本数据类型转化成包装类的过程即打包装，拆箱unboxing：把包装类转换成基本数据类型的过程即拆包装）

   int i1 = 1;
   Integer i2 = new Integer(2);
   Integer i3 = 3; //装箱
   int i4 = i3; //拆箱

• 初始值：基本类型整数类型默认值为0，布尔类型为false，而包装类都为null

2. 整数类型

整数类型中默认为int类型

byte类型

// Byte byte类型 一个字节 8bit -2的7次方~2的7次方-1
        Byte b1 = -128;
        Byte b2 = 127;
        byte b3 = -128;
        byte b4 = 127;

short类型

// Short short类型 两个字节 16bit -2的15次方~2的15次方-1
        Short s1 = -32768;
        Short s2 = 32767;
        short s3 = -32768;
        short s4 = 32767;

int类型

// Integer int类型 四个字节 32bit -2的31次方~2的31次方-1
        Integer i1 = -2147483648;
        Integer i2 = 2147483647;
        int i3 = -2147483648;
        int i4 = 2147483647;

long类型

//Long long类型 八个字节 64bit -2的63次方~2的63次方-1
//Long类型在赋值时，由于整数类型默认为int类型，所以一定要加L或l来声明是Long类型
//long类型在int的范围内不用加L或l，int会自动转为long类型，编译可以通过
//而超过int的范围不加L或l 系统会自动识别为int常量 而这个数字又超过了int类型的范围 所以会编译不通过
        Long l1 = 9527; //编译报错
        Long l2 = 9527L;//编译不报错
        long l3 = 9527; //编译不报错
        long l4 = 2147483648; //超过int类型范围，编译报错
        long l5 = 2147483648L; //声明为long类型 编译不报错

3. 浮点类型

浮点类型默认为double类型

float类型

//Float float类型 四个字节 32bit 单精度 
        float f0 = 7; //int类型转化成float类型
        float f1 = 7F;
        float f2 = 7.;//编译报错，浮点默认double类型
        float f3 = 7.F;
        float f4 = 8.0; //编译报错
        float f5 = 8.0F;
        float f6 = 12.9867;//编译报错
        float f7 = 12.9867F;

double类型

 //Double double类型 八个字节 64bit 双精度 
        // 7是一个int字面量，而7D 7.和8.0是double字面量
        double d0 = 7;
        double d1 = 7D; //加D或d一般用于整数，表示double类型
        double d2 = 7.;
        double d3 = 8.0;
        double d4 = 8.D;
        double d5 = 12.9867;

关于浮点的精度问题（BigDecimal）

浮点数在进行计算时，可能会出现精度问题：

		System.out.println(0.1 + 0.1); //打印结果：0.2
        System.out.println(0.1 + 0.2); //打印结果：0.30000000000000004
        System.out.println(0.1 + 0.3); //打印结果：0.4

因此浮点数不能用于计算精确的值，比如说金融项目中涉及的金额计算
在进行精确计算时，要用BigDecimal来进行计算：

//在进行BigDecimal计算时，记得使用String类型的构造器，不推荐使用double类型的构造器（可能还是会出现精度问题）
	public static void main(String[] args) {
        Double d1 = 0.1;
        Double d2 = 0.2;
        System.out.println(d1 + d2); //打印结果：0.30000000000000004
        System.out.println(d1 - d2); //打印结果：-0.1
        System.out.println(d1 * d2); //打印结果：0.020000000000000004
        System.out.println(d1 / d2); //打印结果：0.5
        System.out.println(add(d1, d2)); //打印结果：0.3
        System.out.println(subtract(d1, d2)); //打印结果：-0.1
        System.out.println(multiply(d1, d2)); //打印结果：0.02
        System.out.println(divide(d1, d2)); //打印结果：0.5
    }

    /**
     * 加
     */
    public static Double add(Double d1,Double d2) {
        BigDecimal b1 = new BigDecimal(d1.toString());
        BigDecimal b2 = new BigDecimal(d2.toString());
        return b1.add(b2).doubleValue();
    }

    /**
     * 减
     */
    public static Double subtract(Double d1,Double d2) {
        BigDecimal b1 = new BigDecimal(d1.toString());
        BigDecimal b2 = new BigDecimal(d2.toString());
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 乘
     */
    public static Double multiply(Double d1,Double d2) {
        BigDecimal b1 = new BigDecimal(d1.toString());
        BigDecimal b2 = new BigDecimal(d2.toString());
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 除
     */
    public static Double divide(Double d1,Double d2) {
        BigDecimal b1 = new BigDecimal(d1.toString());
        BigDecimal b2 = new BigDecimal(d2.toString());
        return b1.divide(b2).doubleValue();
    }

4. 字符类型

char类型

//Character char 两个字节 16bit 只能用单个字符，用单引号括起来
        Character c1 = 'a';
        Character c2 = '字';
        char c3 = 'b';
        char c4 = '符';
        char c5 = 'ab'; //编译报错
        char c6 = '字符'; //编译报错

        //ASCII值 1对应49 A对应65 a对应97
        char c7 = 97; // int类型自动转化成char类型
        System.out.println(c7); //输出：a
        char c8 = 'a' + 1; // 输出:b 97+1=98 对应ASCII值为b
        char c9 = 'A' + '1'; //输出：r  65+49=114 对应ASCII值为r

5. 布尔类型

boolean类型

//Boolean boolean 1bit 只能取值true、false
        Boolean bl1 = true;
        boolean bl2 = false;

6. 类型转换

在java中，基本数据的赋值、计算过程等都可能出现类型转换的情况。关于类型的转换可分为自动类型转换（隐式类型装换）和强制类型转换（显式类型转换）。注：boolean类型不能与其他类型进行类型的转换。

自动类型转换（隐式类型转换）

自动类型转换即基本数据类型在操作的过程中由机器自动为我们进行转换的，不用人为的进行操作。
一般由存储范围小的到存储范围大的类型进行转换。

强制类型转换（显式类型转换）

强制类型转换即由人为的操作进行的强制性的类型转换。
一般由存储范围大的到存储范围小的类型进行转换，强制类型的转换可能会出现精度丢失的问题。

		float f = 3.14F;
        int i = (int) f;
        System.out.println(i); //输出：3

7. 常量池

java的基本数据类型的大部分包装类都实现了常量池技术，即在Byte、Short、Integer、Long整数型在范围-128~127的数据进行了缓存，Character在范围0~127的数据进行了缓存，Boolean对true，false进行缓存，而Float、Double则没有实现数据缓存。

    public static void main(String[] args) {
        int i1 = 127;
        int i2 = 127;
        int i3 = 128;
        int i4 = 128;
        Integer i5 = 127;
        Integer i6 = 127;
        Integer i7 = 128;
        Integer i8 = 128;
        // == 比较对于基本数据类型来说比的是数值，而对于类来说比的是引用地址
        System.out.println(i1 == i2); //true
        System.out.println(i3 == i4); //true
        System.out.println(i5 == i6); //true
        System.out.println(i7 == i8); //false
        System.out.println(i1==i5); //true
        System.out.println(i3==i7); //true
        System.out.println(i7.equals(i8)); //true   equals比较的是数值
    }

当包装类超过缓存的数据范围，则会创建新的对象，所以i7、i8的引用地址不同，返回false。

---

如有不对之处 敬请指正