Java 数据类型总结

Posted 2021-02-17 miantiao312

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类型，因此编译失 败。