Java数据类型总结

Java 中提供了八种数据类型：6 个数字类型（四个整数型，两个浮点型）、字符类型、布尔型。

依次分别是：byte、int、short、long、float、double、char、boolean。

• byte 类型数据占 1 个字节，8 位，最高位表示符号，则表示范围是：-2^7~2^7-1
• int 类型数据占 4 个字节，共 32 位，最高位表示符号，则表示范围是：-2^31~2^31-1
• short 类型数据占 2 个字节，共 16 位，最高位表示符号，则表示范围是：-2^15~2^15-1
• long 类型数据占 8 个字节，共 64 位，最高位表示符号，则范围是：-2^63~2^63-1
• float 数据类型占 4 个字节，共 32 位，范围是：10^-38~10^38 和 -10^38~-10^-38
• double 数据类型占 8 个字节，共 64 位，范围是：10^-308~10^308 和 -10^308~-10^-308
• char 数据类型占 2 个字节，但最高位不用来表示符号。用它能表示 Unicode 集里的 0~2^16-1(0~65535) 位置的字符

  char 数据类型应用有以下方式：

  如：char a='A'; char a=97(不能用 short 类型, 因为最高位表示符号，故表示数值的只有 15 位);

具体的可以参考下图：

2、数据类型转换时出现的问题

2.1、自动转换

一个 int 类型变量和一个 byte 类型变量进行相加，运算的结果是：变量的类型将是 int 类型。

这就是出现了数据类型的自动类型转换现象。

数据类型自动转换：将取值范围小的类型自动转换为取值范围大的类型。

同样道理，当一个 int 类型变量和一个 double 变量运算时，int 类型将会自动提升为 double 类型进行运算。

代码示例：

public class DataDemo {public static void main(String[] args) {
        int a = 1;
        byte b = 2;
//      byte c = a + b;
//      int 类型和 byte 类型运算，结果是 int 类型
        int c = a + b;
        System.out.println(c);
    }
}

转换原理图解：

转换规则：

范围小的类型向范围大的类型提升：byte、short、char 运算时候直接提升为 int。

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double。

2.2、强制类型转换

将 1.5 赋值到 int 类型变量：产生编译失败，无法赋值。

要修改为：

int i = (int)1.5; // 但是这样会导致 1.5 变成 1。

doubled=(int)2.5; // double 类型数据强制转成 int 类型，直接去掉小数点。

double 类型内存 8 个字节，int 类型内存 4 个字节。1.5 是 double 类型，取值范围大于 int。

强制类型转换：将 取值范围大的类型强制转换成取值范围小的类型。

比较而言，自动转换是 Java 自动执行的，而强制转换需要我们自己手动执行。

同样道理，当一个 short 类型与 1 相加，我们知道会类型提升，但是还想给结果赋值给 short 类型变量，就需要强制转换。

代码示例 A：

public class DataDemo2 {public static void main(String[] args) {

        /**
         *  int a=1.5; 编译失败，无法赋值
         */
        int i = (int)1.5;
        double d=2.5;
        //int 类型和 double 类型运算，结果是 double 类型
        //int 类型会提升为 double 类型
        double e = d + i;
        System.out.println(e);
    }
}

示例代码 B：

public class DataDemo3 {public static void main(String[] args) {
        short s = 1;

        /**
         *  s = s + 1 会出现编译失败
         *
         *  原因：*      s 和 1 做运算的时候，1 是 int 类型，s 会被提升为 int 类型
         *      s+1 后的结果是 int 类型，将结果在赋值会 short 类型时发生错误
         *      short 内存 2 个字节，int 类型 4 个字节
         *      必须将 int 强制转成 short 才能完成赋值
         */
        s= (short) (s+1);
        System.out.println(s);
    }
}

强制转换原理图解：

浮点转成整数，直接取消小数点，可能造成数据损失精度。

int 强制转成 short 砍掉 2 个字节，可能造成数据丢失。

2.3、+= 符号扩展

示例代码 A:

public class DataDemo4 {public static void main(String[] args) {
        short s = 1;
        s += 1;
        System.out.println(s);
    }
}

分析：

s += 1 逻辑上看作是 s = s + 1 计算结果被提升为 int 类型，再向 short 类型赋值时发生错误，因为不能将 取值范围大的类型赋值到取值范围小的类型。但是，s=s+ 1 进行两次运算，+= 是一个运算符，只运算 一次，并带有强制转换的特点，也就是说 s += 1 就是 s = (short)(s + 1)，因此程序没有问题编译通过，运行结果是 2.

示例代码 B：

public class DataDemo5 {public static void main(String[] args) {
        byte b1=1;
        byte b2=2;
        byte b3=1+2;
        //byte b4 = b1 + b2;  编译失败
        System.out.println(b3);
    }
}

分析：

b3 = 1 + 2，1 和 2 是常量，为固定不变的数据，在编译的时候（编译器 javac），已经确定了 1+2 的 结果并没有超过 byte 类型的取值范围，可以赋值给变量 b3，因此 b3=1 + 2 是正确的。

反之，b4 = b2 + b3，b2 和 b3 是变量，变量的值是可能变化的，在编译的时候，编译器 javac 不确定 b2+b3 的结果是什么，因此会将结果以 int 类型进行处理，所以 int 类型不能赋值给 byte 类型，因此编译失 败。