数据类型

概述

Java 是强类型语言。

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间（字节）。

Java 中一共有 8 种基本类型（primitive type），包括 4 种整型、2 种浮点型、1 种字符类型（用于表示 Unicode 编码的代码单元）和 1 种用于表示真值的 boolean 类型。

Java 的数据类型分为两大类：基本数据类型和引用数据类型。基本数据类型又分为四类八种。

暂时无法在飞书文档外展示此内容

在这里插入图片描述

int 类型最为常用，但是如果 int 类型的范围不够时，需要使用 long 类型。byte 和 short 主要用于特定的场合，比如底层的文件处理或者存储空间有限时的大数组。

Java 的各个数据类型有固定的范围和字段长度，不受具体的操作系统的影响，以保证程序的可移植性。

Java 中没有无符号数，即 Java 中的数都是有符号的。

整数和小数取值范围大小关系：double > float > long > int > short > byte。

可以把小空间赋给大空间。

C 和 C++ 程序会针对不同的处理器选择最高效的整型，这样一来，一个在 32 位处理器上运行得很好的 C 程序在 16 位系统上运行时可能会发生整数溢出。

可以在一行声明多个变量，但是不提倡这种写法，分别声明每一个变量可以提高程序的可读性。

public class test2 {
    public static void main(String[] args) {
        int a, b;  // 可以在一行声明多个变量
        int a1;    // 分别声明每一个变量可以提高程序的可读性
        int a2;
    }
}

声明一个变量之后，必须用赋值语句显式地初始化变量。千万不要使用未初始化的变量的值。

public class test2 {
    public static void main(String[] args) {
        int a;
        System.out.println(a);  // 报错：java: 可能尚未初始化变量 a
    }
}

public class test2 {
    public static void main(String[] args) {
        int a;                      // 声明
        a = 10;                     // 初始化
        System.out.println(a);      // 10
    }
}

也可以将变量的声明和初始化放在同一行中。Java 中可以将声明放在代码中的任何地方。在 Java 中，变量的声明要尽可能靠近第一次使用这个变量的地方，这是一种很好的编程风格。

在 Java 中，并不区分变量的声明和定义。

public class test2 {
    public static void main(String[] args) {
        int a = 10;                 // 声明和初始化放在同一行
        System.out.println(a);      // 10
    }
}

从 Java 10 开始，对于局部变量，如果可以从变量的初始值推断出它的类型，就不再需要声明类型，只需要使用关键字 var 而无须指定类型。

public class test2 {
    public static void main(String[] args) {
        var a = 10;                 // 使用关键字 var 而无须指定类型
        System.out.println(a);      // 10
        {
            var b = 100;            // 使用关键字 var 而无须指定类型
            System.out.println(b);  // 100
        }
    }
}

C 和 C++ 区分变量的声明和定义。例如：

int i = 10;            // 是一个定义
extern int i;          // 是一个声明

boolean 类型

boolean 类型的值，只有 true 和 false 两种。

Java 中，integer 与 boolean 两种类型并不相容，不可以用 0 或非 0 的整数代替 false 和 true。

例如，下面的代码是错误的，不能用整数作为测试条件：

int x = 1;
while(x)
{}

只能用 boolean 值作为测试条件。

例如，下面的代码是可行的：

boolean isOK = true;
while(isOK)
{}
// 或者
int x = 1;
while(x == 1)
{}

打印 boolean 字面量：

public class ValueDemo1 {
    public static void main(String[] args) {
        // 打印布尔型字面量
        System.out.println(true);
        System.out.println(false);
    }
}

执行结果：

true
false

char 类型

单个字符用 char，多个字符用 String。

char 类型原本用于表示单个字符。不过，现在情况已经有所变化。如今，有些 Unicode 字符可以用一个 char 值描述，另外一些 Unicode 字符则需要两个 char 值。

在 Java 中，char 的本质是一个整数，在输出时，输出的是 Unicode 码对应的字符。可以直接给 char 赋一个整数，然后输出时，会输出对应的 Unicode 字符。char 类型是可以进行运算的，相当于一个整数，因为它有对应的 Unicode 码。

char 类型的字面量值要用单引号括起来。例如：‘A’ 是编码值为 65 的字符常量。它与 “A” 不同，“A” 是包含一个字符的字符串。char 类型的值可以表示为十六进制值，其范围从 \u0000 ~\uFFFFF。例如 \u2122 表示商标符号（ $^{TM}$ ），\u03C0 表示希腊字母 $\pi$ 。

字符在计算机中的存储：在根据码表，找到这个字符的编码，再将编码转为二进制，在计算机中存储这个二进制。读取字符时，要由二进制根据编码转换为字符。

编码转换的网址

字面量

字符型字面量要用单引号括起来，内容有且只能有一个，即内容不能为空。字符串类型的字面量用双引号括起来，内容可以为空。比如：""。

转义字符

转义字符是字符型常量。
\t：制表符，在打印的时候，将前面的字符串的长度补齐到 8，或者 8 的倍数，最少补 1 个空格，最多补 8 个空格。
\n：换行符。
\r：回车。
\\：一个 \。
\\\\：两个 \，即 \\。
\"：一个 "。
\'：一个 '。

程序示例：

public class test3 {
    public static void main(String[] args) {
        System.out.println("************************");
        System.out.println("abc" + '\t' + "def");
        // System.out.println("abc" + "\t" + "def");    // \t 也可以用双引号括起来
        System.out.println("12345678" + "\t" + "abc");  // 输出: 12345678        abc, 因为最少要补 1 个空格,最多补 8 个空格
    }
}

执行结果：

************************
abc     def
12345678        abc

程序示例：

public class ChangeChar {
    public static void main(String[] args) {
        // \t：制表位
        System.out.println("天津\t上海\t北京");
        // \n：换行符
        System.out.println("天津\n上海\n北京");
        // \\：一个\
        System.out.println("Hello\\ok");
        System.out.println("C:\\Windows\\apppatch");
        // \ 会把后面那个字母当成是一个转义符的一个组合，
        // 如果组合起来之后是一个合法的转义符，就正常编译，否则报错:非法转义符
        // 反正就一定会当成是一个转义符，然后去判断是否是合法的转义符
        // 输出两个 \\：
        System.out.println("C:\\\\Windows\\\\apppatch");
        // \"：一个"
        System.out.println("他说:\"你好。\"");  // 输出：他说:"你好。"
        // \'：一个'
        // \r：一个回车
        System.out.println("好的可以\r你好");  // 输出：你好可以
        System.out.println("好的可以\r\n你好");
    }
}

执行结果：

天津        上海        北京
天津
上海
北京
Hello\ok
C:\Windows\apppatch
C:\\Windows\\apppatch
他说:"你好。"
你好
好的可以
你好

可以在加引号的字符字面量或字符串中使用这些转义序列。

例如，'\u2122' 或 "Hello\n"。转义序列 \u 还可以在加引号字符常量或字符串之外使用（而其他所有转义序列不可以）。例如：

public static void main(String\u005B\u005D args)

就是完全合法的，\u005B 和 \u005D 分别是 [ 和 ] 的编码。

Unicode 转义序列会在解析代码之前处理。

例如，“\u0022+\u0022” 当中，\u0022 会在解析之前转换为 "，这会得到 ""+""，也就是一个空串。

更隐秘地，一定要当心注释中的 \u。以下注释

// \u000A is a newline

会产生一个语法错误，因为读程序时 \u000A 会替换为一个换行符。

下面这个注释

// look inside c:\users

也会产生一个语法错误，因为 \u 后面并没有跟着 4 位十六进制数。

字符编码

ASCII 码表

用一个字节表示，一共 128 个字符。扩展的 ASCII 码表一共 256 个字符。

Unicode 码表

Unicode 编码表的编码大小固定，使用两个字节来表示字符，字母和汉字统一都是占用两个字节，这样浪费空间。Unicode 的好处是使用一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。

Unicode的缺点：一个英文字母和一个汉字都占用 2 个字节，这对于存储空间来说是浪费的。

2 的 16 次方是 65536，所以最多可以表示 65536 个字符。

编码 0-127 的字符与 ASCII 的编码一样。比如 ‘a’ 在 ASCII 码是 0x61，在 Unicode 码是 0x0061，都对应 97。因此 Unicode 码兼容 ASCII 码。

UTF-8 码表

UTF-8 是 Unicode 是一种改进，是在互联网上广泛使用的码表。UTF-8 是一种变长的编码方式，可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度，字母使用 1 个字节，汉字使用 3 个字节。

GBK 码表

可以表示汉字，而且范围广，字母使用 1 个字节，汉字 2 个字节。

GB2312 码表

可以表示汉字，GB2312 可以表示的汉字个数少于 GBK。

Big5 码表

可以表示繁体中文，多用于台湾、香港。

byte 类型

short 类型

int 类型

后缀

Java 程序中的整形常量都默认为 int 类型，如果要申明 long 类型必须加后缀 l 或 L。

程序示例：

public class test3 {
    public static void main(String[] aStrings) {
        long a = 10l;               // 加后缀 l
        long b = 10L;               // 加后缀 L
        // int c = 10L;             // 报错：java: 不兼容的类型: 从 long 转换到 int 可能会有损失
        System.out.println(a);      // 10
        System.out.println(b);      // 10
        // System.out.println(c);
    }
}

程序示例：

public class test3 {
    public static void main(String[] args) {
        long a = 999999999;         // 正常输出
        // long b = 9999999999;     // 报错：java: 整数太大
        long b = 9999999999L;       // 加了后缀 L 后才能正常输出
        System.out.println(a);
        System.out.println(b);
        long c = 10L;               // 就算一个整数在 int 范围内，也可以通过后缀 L 让它变成 long 类型
        System.out.println(c);
    }
}

整数的进制

十进制整数不加前缀；
二进制整数加前缀 0b 或 0B；
八进制整数加前缀 0；
十六进制整数加前缀 0x 或 0x。

程序示例：

public static void main(String[] args) {
    System.out.println(10);         // 10
    System.out.println(010);        // 8
    System.out.println(0b10);       // 2
    System.out.println(0x10);       // 16
}

long 类型

float 类型

6~7 位有效数字。

double 类型

15 位有效数字。

double 表示这种数值的精度是 float 类型的两倍，所以有人称之为双精度 double precision。

浮点数值不适用于无法接受舍入误差的金融计算。例如：

public class test2 {
    public static void main(String[] args) {
        System.out.println(2.0 - 1.1);      // 0.8999999999999999
    }
}

这种舍入误差的主要原因是浮点数值采用二进制表示，而在二进制系统中无法准确地表示分数 1/10。这就好像十进制无法精确地表示分数 1/3 一样。如果需要精确的数值计算，不允许有舍入误差，则应该使用 BigDecimal 类。

字面量

浮点数字面量有两种写法：

十进制，如 5.12，512.0f，.512（小数点不能省略）等。
e 计数法，如 5.12e2，5.12E-2 等。
p 计数法，这是是用十六进制表示浮点型字面量，用 p 表示指数，尾数采用十六进制，指数采用十进制，指数的基数是 2 而不是 10。

后缀

Java 的浮点数字面量默认为 double 类型，如果要将一个浮点型字面量视为 float 类型，必须加后缀 f 或 F。

程序示例：

public static void main(String[] aStrings) {
    double a = 11.1;
    // float b = 11.1;             // java: 不兼容的类型: 从 double 转换到 float 可能会有损失
    float c = 11.1F;
    System.out.println(a);          // 11.1
    // System.out.println(b);
    System.out.println(c);          // 11.1
}

在一个数值字面量后面加 d 或 D 可以将其视为 double 类型，一般都不需要这么做，但是不会报错。

程序示例：

public static void main(String[] args) {
    double d1 = 3.3d;           // 加后缀 d 将 float 类型数值变为 double 类型
    double d2 = 3D;             // 加后缀 D 将 int 类型数值变为 double 类型
    System.out.println(d1);     // 3.3
    System.out.println(d2);     // 3.0
}

浮点型常量不能赋值给整型，程序示例：

public static void main(String[] args) {
    int a = 1.1;  // 报错：java: 不兼容的类型: 从 double 转换到 int 可能会有损失
    System.out.println(a);
}

特殊的浮点值

所有的浮点数的计算都遵循 IEEE 754 规范。

有 3 个特殊的浮点数值表示溢出和出错情况：

正无穷大
负无穷大
NaN（不是一个数）

一个正整数除以 0 的结果为正无穷大。计算 0/0 或者负数的平方根结果为 NaN。

public class test {
    public static void main(String[] args) {
        System.out.println(Double.POSITIVE_INFINITY);  // Infinity
        System.out.println(Double.NEGATIVE_INFINITY);  // -Infinity
        System.out.println(Double.NaN);                // NaN
        System.out.println(Float.POSITIVE_INFINITY);   // Infinity
        System.out.println(Float.NEGATIVE_INFINITY);   // -Infinity
        System.out.println(Float.NaN);                 // NaN
        // System.out.println(10 / 0);  // 报错：Exception in thread "main" java.lang.ArithmeticException: / by zero
    }
}

不能如下检测一个特定结果是否等于 Double.NaN：

if (x == Double.NaN)    // is never true

所有 NaN 的值都认为是不相同的。不过，可以使用 Double.isNaN 方法来判断：

if (Double.isNaN(x))    // check whether x is "not a number"

类型转换

自动类型转换

自动类型转换是把精度小的类型自动转换为精度大的数据类型。

自动类型转换也叫隐式转换、自动类型提升。

总的原则：当 Java 程序在进行赋值或者算术运算时，精度小的类型自动转换为精度大的数据类型。

数据类型按精度（即容量）大小排序为：
char $\rightarrow$ int $\rightarrow$ long $\rightarrow$ float $\rightarrow$ double
byte $\rightarrow$ short $\rightarrow$ int $\rightarrow$ long $\rightarrow$ float $\rightarrow$ double

暂时无法在飞书文档外展示此内容

图中有 6 个实线箭头，表示无信息丢失的转换；另外有 3 个虚线箭头，表示可能有精度损失的转换。例如，123456789 是一个大整数，它包含的位数多于 float 类型所能表示的位数。将这个整数转换为 float 类型时，数量级是正确的，但是会损失一些精度。

程序示例：

public class ConvertDemo {
    public static void main(String[] args) {
        int n = 123456789;
        float f = n;
        System.out.println(f);  // 1.23456792E8
    }
}

其他细化的规则：

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。

当把精度（即容量）大的数据类型赋值给精度（即容量）小的数据类型时，就会报错，反之就会进行自动类型转换。

(byte, short) 和 char 之间不会相互自动转换。

byte，short，char 它们三者可以计算，在计算时首先转换为 int 类型（不论是否有 int 参与）。

boolean 不参与自动转换。

当用一个二元运算符连接两个值时，先要将两个操作数转换为同一种类型，然后再进行计算。

如果两个操作数中有一个是 double 类型，另一个操作数就会转换为 double 类型；

否则，如果其中一个操作数是 float 类型，另一个操作数将会转换为 float类型；

否则，如果其中一个操作数是 long 类型，另一个操作数将会转换为 long 类型；

否则，两个操作数都将被转换为 int 类型。

程序示例：

int n1 = 10;
// 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
// float f1 = n1 + 1.1; // Type mismatch: cannot convert from double to float
float f1 = n1 + 1.1F;
System.out.println(f1); // 11.1

程序示例：

// 当把精度（即容量）大的数据类型赋值给精度（即容量）小的数据类型时，就会报错，反之就会进行自动类型转换。
// int a = 1.1; // Type mismatch: cannot convert from double to int
// System.out.println(a);
// 把一个常数（必须是整数类型）赋值给 byte 时，先看这个常数是否在 byte 范围内（-128~127），
// 如果在范围内，则可以赋值
byte b1 = 10;
System.out.println(b1); // 10
// byte b3 = 1.1;
// System.out.println(b3); // Type mismatch: cannot convert from double to byte
// 把一个变量赋值给 byte 时，要求变量必须也是 byte 类型
// int a1 = 10;
// byte b2 = a1; // Type mismatch: cannot convert from int to byte
// System.out.println(b2);

程序示例：

// byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型（不论是否有 int 参与）。
byte b6 = 10;
char c1 = 2;
// byte b7 = b6 + c1; // Type mismatch: cannot convert from int to byte
// System.out.println(b7);
int n2 = b6 + c1;
System.out.println(n2); // 12

程序示例：

// byte，short，char 他们三者可以计算，在计算时首先转换为int类型（不论是否有 int 参与）。
byte b8 = 10;
byte b9 = 10;
byte b10 = b8 + b9; // Type mismatch: cannot convert from int to byte

隐式类型转换就是在补码前面加零：

public static void main(String[] args) {
    byte a = 10;    // 0000 1010
    int b = a;      // 0000 0000 0000 0000 0000 0000 0000 1010
    System.out.println(b);
}

整型字面量在范围内时可以降级赋值，用后缀 L 或 l 指定的常量除外。但是用变量赋值时即便值在范围内也不可以降级赋值。浮点型不论是字面量还是变量都不允许降级赋值。

程序示例：

public static void main(String[] args) {
    short a = 100;  // 没问题，是字面量降级赋值，int → short，在范围内
    System.out.println(a);
}

程序示例：

public static void main(String[] args) {
    int a = 100L;  // 报错：java: 不兼容的类型: 从 long 转换到 int 可能会有损失
    System.out.println(a);
}

程序示例：

public static void main(String[] args) {
    float a = 100;               // 没问题，可以将 int  赋值给 float，同样，也可以将 int 赋值给 double
    System.out.println(a);       // 100.0
}

程序示例：

public static void main(String[] args) {
    float a = 100.;               // 加了一点，变成了 double 类型，报错：java: 不兼容的类型: 从 double 转换到 float 可能会有损失
    System.out.println(a);        // 100.0
}

强制类型转换

强制类型转换是自动类型转换的逆过程，是将精度大的类型转换为精度小的数据类型。

使用强制类型转换时要加上强制转换符 ()，但可能造成精度降低或溢出，因此要格外要注意。

程序示例：

public static void main(String[] args) {
    int i1 = (int) 1.9;
    System.out.println(i1); // 打印 1，非四舍五入，直接丢弃小数点后的内容，造成精度损失
    // byte b1 = (byte) 2000;
    // System.out.println(b1); // b1 cannot be resolved to a variable
    int n1 = 2000;
    byte b2 = (byte) n1;
    System.out.println(b2); // -48，数据溢出
}

当需要精度高的数据类型转换为精度低的数据类型时，就要用到强制类型转换。

强制类型转换只针对最近的操作数有效，可以使用小括号修改优先级。

byte，char 和 short 可以接收处于范围内的 int 类型的整数，但是不能接收 int 类型的变量，如果需要，则需要进行强制类型转换。

程序示例：

// 强制类型转换只针对最近的操作数有效，可以使用小括号修改优先级。
public class Test {
    public static void main(String[] args) {
        // int x = (int) 10 * 3.5 + 6 * 1.5; // Type mismatch: cannot convert from double to int
        // System.out.println(x);
        int y = (int) (10 * 3.5 + 6 * 1.5);
        System.out.println(y);       // 44
    }
}

程序示例：

public class Test {
    public static void main(String[] args) {
        byte b1 = 1, b2 = 2;
        byte b3 = b1 + b2;           // 报错：java: 不兼容的类型: 从 int 转换到 byte 可能会有损失
        byte b3 = (byte) (b1 + b2);  // 正确
    }
}

程序示例：

public class Test {
    public static void main(String[] args) {
        int a = 97;
        char c = (char) a;
        char b = 97;
        System.out.println(c);   // a
        System.out.println(b);   // a，加不加强制类型转换都是一样的，因为 97 在 0-65535 之间，可以接收
        char d = a;              // 报错，用变量赋值需要强转
    }
}

强制类型转换就是删除补码前面多出来的位：

public static void main(String[] args) {
    int a = 300;            // 0000 0000 0000 0000 0000 0001 0010 1100
    byte b = (byte) a;      // 0010 1100
    System.out.println(b);  // 44
}

public static void main(String[] args) {
    int a = 200;            // 0000 0000 0000 0000 0000 0000 1100 1000
    byte b = (byte) a;      // 1100 1000
    System.out.println(b);  // -56
}

不要在 boolean 类型与任何数值类型之间进行强制类型转换，这样可以防止发生一些常见的错误，只有极少数的情况下需要将一个 boolean 值转换为一个数，此时可以使用条件表达式 b ? 1 : 0。

数字字面量加下划线

可以为数字字面量加下划线，这样可以提高可读性，编译器会去除这些下划线。以多少个数字为一组进行分割是随意的。

程序示例：

public class Underscore {
    public static void main(String[] args) {
        long a = 1_000_000_000_000_000L;
        int b = 0B1111_0000_1111_0000;
        System.out.println(a);      // 1000000000000000
        System.out.println(b);      // 61680
    }
}