数 据 类 型

概述

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 位系统上运行时可能会发生整数溢出。

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

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

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

java 复制代码
public class test2 {
    public static void main(String[] args) {
        int a;
        System.out.println(a);  // 报错:java: 可能尚未初始化变量 a
    }
}
java 复制代码
public class test2 {
    public static void main(String[] args) {
        int a;                      // 声明
        a = 10;                     // 初始化
        System.out.println(a);      // 10
    }
}

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

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

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

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

java 复制代码
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++ 区分变量的声明和定义。例如:

c 复制代码
int i = 10;            // 是一个定义
extern int i;          // 是一个声明

boolean 类型

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

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

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

java 复制代码
int x = 1;
while(x)
{}

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

例如,下面的代码是可行的:

java 复制代码
boolean isOK = true;
while(isOK)
{}
// 或者
int x = 1;
while(x == 1)
{}

打印 boolean 字面量:

java 复制代码
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 表示商标符号( T M ^{TM} TM),\u03C0 表示希腊字母 π \pi π。

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

编码转换的网址

字面量

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

转义字符

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

程序示例:

java 复制代码
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 个空格
    }
}

执行结果:

java 复制代码
************************
abc     def
12345678        abc

程序示例:

java 复制代码
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 还可以在加引号字符常量或字符串之外使用(而其他所有转义序列不可以)。例如:

java 复制代码
public static void main(String\u005B\u005D args)

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

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

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

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

java 复制代码
// \u000A is a newline

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

下面这个注释

java 复制代码
// 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 类型必须加后缀 lL

程序示例:

java 复制代码
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);
    }
}

程序示例:

java 复制代码
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。

程序示例:

java 复制代码
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。

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

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

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

字面量

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

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

后缀

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

程序示例:

java 复制代码
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 类型,一般都不需要这么做,但是不会报错。

程序示例:

java 复制代码
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
}

浮点型常量不能赋值给整型,程序示例:

java 复制代码
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。

java 复制代码
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

java 复制代码
if (x == Double.NaN)    // is never true

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

java 复制代码
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 类型时,数量级是正确的,但是会损失一些精度。

程序示例:

java 复制代码
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 类型。

程序示例:

java 复制代码
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

程序示例:

java 复制代码
// 当把精度(即容量)大的数据类型赋值给精度(即容量)小的数据类型时,就会报错,反之就会进行自动类型转换。
// 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);

程序示例:

java 复制代码
// 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

程序示例:

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

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

java 复制代码
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 指定的常量除外。但是用变量赋值时即便值在范围内也不可以降级赋值。浮点型不论是字面量还是变量都不允许降级赋值。

程序示例:

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

程序示例:

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

程序示例:

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

程序示例:

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

强制类型转换

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

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

程序示例:

java 复制代码
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 类型的变量,如果需要,则需要进行强制类型转换。

程序示例:

java 复制代码
// 强制类型转换只针对最近的操作数有效,可以使用小括号修改优先级。
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
    }
}

程序示例:

java 复制代码
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);  // 正确
    }
}

程序示例:

java 复制代码
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;              // 报错,用变量赋值需要强转
    }
}

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

java 复制代码
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
}
java 复制代码
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

数字字面量加下划线

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

程序示例:

java 复制代码
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
    }
}
相关推荐
守护者17011 分钟前
JAVA学习-练习试用Java实现“使用Arrays.toString方法将数组转换为字符串并打印出来”
java·学习
源码哥_博纳软云12 分钟前
JAVA同城服务场馆门店预约系统支持H5小程序APP源码
java·开发语言·微信小程序·小程序·微信公众平台
禾高网络14 分钟前
租赁小程序成品|租赁系统搭建核心功能
java·人工智能·小程序
学会沉淀。20 分钟前
Docker学习
java·开发语言·学习
如若12321 分钟前
对文件内的文件名生成目录,方便查阅
java·前端·python
初晴~1 小时前
【Redis分布式锁】高并发场景下秒杀业务的实现思路(集群模式)
java·数据库·redis·分布式·后端·spring·
黑胡子大叔的小屋2 小时前
基于springboot的海洋知识服务平台的设计与实现
java·spring boot·毕业设计
ThisIsClark2 小时前
【后端面试总结】深入解析进程和线程的区别
java·jvm·面试
雷神乐乐3 小时前
Spring学习(一)——Sping-XML
java·学习·spring
小林coding3 小时前
阿里云 Java 后端一面,什么难度?
java·后端·mysql·spring·阿里云