day04_基本数据类型丶字符编码丶基本数据类型转换

2024-03-26 09:27:34

数据类型概述

Java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所以它们表示的数据大小也是不一样的。

通过上面的我们知道八种基本数据类型指的是：byte、short、int、long、float、double、 boolean、char。接下来我们来看一下八种基本数据类型的详细信息，请看下表：

另一类是引用数据类型分为：类(class)丶接口(interface)丶数组(array)，以后我们在学习。我们详细学习下基本数据类型之前先了解一下计算机的计算机存储单位：计算机只能识别二进制。也就是0和1。1bit就是一个1或0。1字节 = 8bit（8比特）。常用的存储单位换算关系如下：

1KB = 1024byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB

byte b = 2; //在计算机中是这样表示的：00000010
short s = 2;// 在计算机中是这样表示的：00000000 00000010
int i = 2;//在计算机中是这样表示的：00000000 00000000 00000000 00000010

不同的进制之间可以按照一定的规则相互转换。我们可以通过其占用的字节多少算出他们取值范围。来看一下 byte 类型的取值范围，为什么最大值只能取到 127 呢：首先数字是有正负之分，在二进制位当中最左边的二进制位是符号位，0 表示正数，1 表示负数，byte 属于字节型，占用空间大小是 1 个字节，1 个字节是 8 个 bit 位，所以 byte类型最大值是左边一个 0 右边七个 1：01111111，这个二进制位实际上是 2的7方-1，也就是 127。byte 类型最小值是-128，那么，这也说明 1 个字节最多可以表示 256 种不同的情况（-128 到127，中间有一个 0，共 256 个不同的数字）。

整数类型：byte、short、int、long

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long
整数型字面量没有超出byte和short的取值范围，那么这个整数型字面量可以直接赋值给byte和short类型的变量。这种语法机制是为了方便写代码，而存在的。
bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。

代码示例

class VariableTest1 {
    public static void main(String[] args) {
        //1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
        //① byte范围：-128 ~ 127
        //
        byte b1 = 12;
        byte b2 = -128;
        //b2 = 128;//编译不通过
        System.out.println(b1);
        System.out.println(b2);
        // ② 声明long型变量，必须以"l"或"L"结尾
        // ③ 通常，定义整型变量时，使用int型。
        short s1 = 128;
        int i1 = 1234;
        long l1 = 3414234324L;
        System.out.println(l1);
    }
}

浮点类型：float、double

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。任意一个浮点型都比整数型空间大。浮点型常量有两种表示形式：

十进制数形式：如：5.12 512.0f .512 (必须有小数点）
科学计数法形式:如：5.12e2 512E2 100E-2

float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。 double:双精度，精度是float的两倍。通常采用此类型。不过对于财务系统来说，涉及到钱的问题，double 的精度也是远远不够的，后期使用Java 基础库中的 BigDecimal 类，该类可表示超大精度的数据。比较适合财务系统的开发。不过，BigDecimal 则不属于基本数据类型的范畴了。

Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。

代码示例

class VariableTest1 {
    public static void main(String[] args) {
        // 浮点型：float(4字节) \ double(8字节)
        // 浮点型，表示带小数点的数值
        // float表示数值的范围比long还大
        double d1 = 123.3;
        System.out.println(d1 + 1);
        // 定义float类型变量时，变量要以"f"或"F"结尾
        float f1 = 12.3F;
        System.out.println(f1);
        // 通常，定义浮点型变量时，使用double型。
    }
}

字符类型：char

char 型数据用来表示通常意义上“字符”(2字节)
Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
当一个整数赋值给char类型变量的时候，会自动转换成char字符型，最终的结果是一个字符。

代码示例

/*
    字符型：
        char
        1、char占用2个字节。
        2、char的取值范围：[0-65535]
        3、char采用unicode编码方式。
        4、char类型的字面量使用单引号括起来。
        5、char可以存储一个汉字。
*/
public class CharTest01{
    public static void main(String[] args){
        // char可以存储1个汉字吗？
        // 可以的，汉字占用2个字节，java中的char类型占用2个字节，正好。
        char c1 = '中';
        System.out.println(c1);
 
        char c2 = 'a';
        System.out.println(c2);
 
        // 0如果加上单引号的话，0就不是数字0了，就是文字0，它是1个字符。
        char c3 = '0';
        System.out.println(c3);
 
        // 错误: 不兼容的类型: String无法转换为char
        //char c4 = "a";
 
        // 错误: 未结束的字符文字
        //char c5 = 'ab';
 
        // 错误: 未结束的字符文字
        //char c6 = '1.08';
 
    }
}

字符型变量的三种表现形式：

字符常量是用单引号括起来的单个字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; // '\n'表示换行符
直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。

class VariableTest1 {
    public static void main(String[] args) {
        // 普通的't'字符
        char c1 = 't';
        System.out.println(c1);
 
        //char x = 'ab';。
        // 以下代码 \t 实际上是1个字符，不属于字符串
        // 两个字符合在一起表示一个字符，其中 \t 表示“制表符tab”
        char c2 = '\t'; //相当于键盘上的tab键
        
        // \的出现会将紧挨着的后面的字符进行转义。\碰到t表示tab键。
        System.out.println("abc\tdef");
        System.out.print("abc");
        //char c3 = 'n'; // 普通的n字符
        char c3 = '\n'; // 换行符
        //System.out.print(c3);
        System.out.println(c3);
        System.out.println("def");
 
        // 假设现在想在控制台输出一个 ' 字符怎么办？
        // 错误: 空字符文字
        //System.out.println(''');
        // \' 表示一个普通不能再普通的单引号字符。（\'联合起来表示一个普通的 '）
        System.out.println('\'');
 
        // 假设现在想在控制台输出一个 \ 字符怎么办？
        //错误: 未结束的字符文字
        //System.out.println('\');
        // 在java中两个反斜杠代表了一个“普通的反斜杠字符”
        System.out.println('\\');
 
        // 双引号括起来的是字符串
        System.out.println("test");
        // 希望输出的结果是："test"
        // 错误: 需要')'
        //System.out.println(""test"");
        System.out.println("“test”"); //内部的双引号我用中文的行吗？可以。
 
        System.out.println("");
        // 编译报错。
        //System.out.println(""");
        //System.out.println("\"");
        System.out.println("\"test\"");
 
        // 这个可以输出吗？
        // 这个不需要专门进行转义。
        // 这个 ' 在这里只是一个普通的字符，不具备特殊含义。
        System.out.println("'");
 
        //以下都有问题
        //System.out.println(''');
        //System.out.println(""");
 
        // 可以的。
        System.out.println("'这样呢'");
 
        // 编译报错，因为：4e2d 是一个字符串
        // 错误: 未结束的字符文字
        //char x = '4e2d';
 
        // 反斜杠u表示后面的是一个字符的unicode编码。
        // unicode编码是十六进制的。
        char x = '\u4e2d';
        System.out.println(x); // '中'
    }
}

注意：

char类型是可以进行运算的。因为它都对应有Unicode码。
当一个整数没有超出byte short char的取值范围的时候，这个整数可以直接赋值给byte short char类型的变量。
字符型 char 在 Java 语言中占用 2 个字节， char 类型的字面量必须使用半角的单引号括起来，取值范围为[0-65535] ， char 和 short 都占用 2 个字节，但是 char 可以取到更大的正整数，因为 char 类型没有负数。

/*
    1、整数能否直接赋值给char
    2、char x = 97;
        这个java语句是允许的，并且输出的结果是'a'
        经过这个测试得出两个结论：
            第一个结论：当一个整数赋值给char类型变量的时候，会自动转换成char字符型，
            最终的结果是一个字符。

            第二个结论：当一个整数没有超出byte short char的取值范围的时候，
            这个整数可以直接赋值给byte short char类型的变量。
*/
public class CharDemo{
    public static void main(String[] args){
    
        char c1 = 'a';
        System.out.println(c1);

        // 这里会做类型转换吗？
        // 97是int类型（这是java中规定，默认当做int处理）
        // c2是char类型
        //char c2 = (char)97; // 不需要这样做。
        char c2 = 97;
        System.out.println(c2); // 'a'

        // char类型取值范围：[0~65535]
        char c3 = 65535; // 实际上最终是一个“看不懂”的字符。
        System.out.println(c3);

        //错误: 不兼容的类型: 从int转换到char可能会有损失
        //char c4 = 65536;

        // 怎么解决以上问题？强转
        char c4 = (char)65536;
        
    }
}

布尔类型：boolean

boolean类型数据只允许取值true和false，无null。不可以使用0或非 0 的整数替代false和true，这点和C语言不同。Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的 boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false 用0表示。—《java虚拟机规范 8版》 boolean 类型用来判断逻辑条件，一般用于程序流程控制：

if条件控制语句
while循环控制语句
do-while循环控制语句
for循环控制语句

代码示例

/*
    1、在java语言中boolean类型只有两个值，没有其他值：
        true和false。
        不像C或者C++，C语言中1和0也可以表示布尔类型。
    2、boolean类型在实际开发中使用在哪里呢？
        使用在逻辑判断当中，通常放到条件的位置上（充当条件）
*/
public class VariableTest1{
    public static void main(String[] args){
        //错误: 不兼容的类型: int无法转换为boolean
        //boolean xingBie = 1;
 
        // 需求规定：如果为true则表示男，为false则表示女。
        //boolean sex = true;
        boolean sex = false;
        int a = 10;
        int b = 20;
        System.out.println(a < b); // true
        System.out.println(a > b); // false
 
        //boolean flag = a < b;
        boolean flag = (a < b); // 运算符是有优先级的，不确定可以加小括号。加了小括号就一定是先执行的。
        System.out.println(flag); // true
 
        // 例如：如果这个布尔型值是true，则表示男性，为false则表示女性。
        if(sex){
            System.out.println("男");
        }else{
            System.out.println("女");
        }
 
    }
}

字符编码

对于以上的八种基本数据类型来说，其中七种类型 byte,short,int,long,float,double,boolean 计算机表示起来是很容易的，因为这七种类型底层直接就是数字，十进制的数字和二进制之间有固定的转换规则，所以计算机可直接表示和处理。但是大家别忘了，除了以上的七种数据类型之外，还有一种类型叫做字符型 char，这个对于计算机来说表示起来就不是那么容易了，因为字符毕竟是现实世界当中的文字，而文字每个国家又是不同的，计算机是如何表示文字的呢？我们需要让计算机支持现实世界当中的文字，一些标准制定的协会就制定了字符编码（字符集），字符编码其实就是一张对照表，在这个对照表上描述了某个文字与二进制之间的对应关系。

ASCII码：

上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这 128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。

缺点：

不能表示所有字符。
相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表 (ג) 了字母

乱码的存在和原因

世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。

Unicode：

一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。
Java 为了国际化，为了支持所有国家的语言，所以 Java 采用的编码方式为 Unicode 编码。

 缺点：

Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别 Unicode 和 ASCII：计算机无法区分三个字节表示一个符号还是分别表示三个符号。
另外，我们知道，英文字母只用一个字节表示就够了，如果 unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，这对于存储空间来说是极大的浪费。

UTF-8

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

UTF-8的编码规则：

对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于 ASCII码）。
对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为1，第一个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。

其中还有很多字符集例如：GB2312 、GBK 、GB18030 就不一一介绍了。

基本数据类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
boolean类型不能与其它数据类型运算。
当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。

代码示例

/*
当数据类型不一样时，将会发生数据类型转换。
自动类型转换（隐式）
    1. 特点：代码不需要进行特殊处理，自动完成。
    2. 规则：数据范围从小到大。
强制类型转换（显式）
*/
public class Demo01DataType {
    public static void main(String[] args) {
        System.out.println(1024); // 这就是一个整数，默认就是int类型
        System.out.println(3.14); // 这就是一个浮点数，默认就是double类型
        
        // 左边是long类型，右边是默认的int类型，左右不一样
        // 一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
        // int --> long，符合了数据范围从小到大的要求
        // 这一行代码发生了自动类型转换。
        long num1 = 100;
        System.out.println(num1); // 100
        
        // 左边是double类型，右边是float类型，左右不一样
        // float --> double，符合从小到大的规则
        // 也发生了自动类型转换
        double num2 = 2.5F;
        System.out.println(num2); // 2.5
        
        // 左边是float类型，右边是long类型，左右不一样
        // long --> float，范围是float更大一些，符合从小到大的规则
        // 也发生了自动类型转换
        float num3 = 30L;
        System.out.println(num3); // 30.0
    }
}

强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出。
通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。如： String a = “43”; int i = Integer.parseInt(a);
boolean类型不可以转换为其它的数据类型。

代码示例

/*
强制类型转换
    1. 特点：代码需要进行特殊的格式处理，不能自动完成。
    2. 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
*/
public class Demo02DataType {
    public static void main(String[] args) {
        // 左边是int类型，右边是long类型，不一样
        // long --> int，不是从小到大
        // 不能发生自动类型转换！
        // 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
        int num = (int) 100L;
        System.out.println(num);
        
        // long强制转换成为int类型
        int num2 = (int) 6000000000L;
        System.out.println(num2); // 1705032704
        
        // double --> int，强制类型转换
        int num3 = (int) 3.99;
        System.out.println(num3); // 3，这并不是四舍五入，所有的小数位都会被舍弃掉
        
        char zifu1 = 'A'; // 这是一个字符型变量，里面是大写字母A
        System.out.println(zifu1 + 1); // 66，也就是大写字母A被当做65进行处理
        // 计算机的底层会用一个数字（二进制）来代表字符A，就是65
        // 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
        
        byte num4 = 40; // 注意！右侧的数值大小不能超过左侧的类型范围
        byte num5 = 50;
        // byte + byte --> int + int --> int
        int result1 = num4 + num5;
        System.out.println(result1); // 90
        
        short num6 = 60;
        // byte + short --> int + int --> int
        // int强制转换为short：注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
        short result2 = (short) (num4 + num6);
        System.out.println(result2); // 100
    }
}

基本数据类型之间是存在固定的转换规则的，现总结出以下 6 条规则，无论是哪个程序，将这 6 个规则套用进去，问题迎刃而解：

八种基本数据类型中，除 boolean 类型不能转换，剩下七种类型之间都可以进行转换；
如果整数型字面量没有超出 byte,short,char 的取值范围，可以直接将其赋值给 byte,short,char 类型的变量；
小容量向大容量转换称为自动类型转换，容量从小到大的排序为：byte < short(char) < int < long < float < double，其中 short 和 char 都占用两个字节，但是 char 可以表示更大的正整数；
大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用；
byte,short,char 类型混合运算时，先各自转换成 int 类型再做运算；
多种数据类型混合运算，各自先转换成容量最大的那一种再做运算；

码农公寓

数据类型概述

整数类型：byte、short、int、long

浮点类型：float、double

字符类型：char

布尔类型：boolean

字符编码

基本数据类型转换

相关文章