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

数据类型

数据类型作用就是决定程序运行阶段给该变量分配多大的内存空间。 这就是数据类型的主要作用。那么 java 中的数据类型都包括哪些呢？实际上 Java 中的数据类型就包括两大类，一类是基本数据类型，另一类是引用数据类型，例如：类 抽象类 接口 枚举 …. …

其中，基本数据类型又包括 4 类 8 种：

• 第 1 类：整数型（不带小数的数字）：byte,short,int,long
• 第 2 类：浮点型（带小数的数字）：float,double
• 第 3 类：字符型（文字，单个字符）：char
• 第 4 类：布尔型（真和假）：boolean

如下图所示：     

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

• Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
• java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
• java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long       

代码示例

public class Demo {
    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 s = 128;
        int i = 1234;
        long l = 3414234324L;
        

    }
}

整数型数据在 java 中有 4 种表示方式，分别是十进制、八进制、十六进制、二进制。不同进制之间可以按照一定的规则相互转换。要注意的是二进制写法是在 Java7 中引入的，对于 Java7 之前的版本不支持该语法。默认为十进制，以 0 开始表示八进制，以 0x 开始表示十六进制，以 0b 开始表示二进制。进制的换算，如下图所示

代码示例

/*
计算机中不同进制的使用说明

对于整数，有四种表示方式：
> 二进制(binary)：0,1 ，满2进1.以0b或0B开头。
> 十进制(decimal)：0-9 ，满10进1。
> 八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
> 十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
    如：0x21AF +1= 0X21B0

*/
class BinaryTest {
    public static void main(String[] args) {
        
        int num1 = 0b110;
        int num2 = 110;
        int num3 = 0127;
        int num4 = 0x110A;
        // 最后输出都是以十进制表示
        System.out.println("num1 = " + num1);
        System.out.println("num2 = " + num2);
        System.out.println("num3 = " + num3);
        System.out.println("num4 = " + num4);

    }
}

浮点类型：float、double

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作 系统的影响。浮点型数据实际上在内存中存储的时候大部分情况下都是存储了数据的近似值，为什么呢？这是因为在现实世界中存在无穷的数据，例如：3.333333333333333333..，数据是无穷的，但是内存是有限的，所以只能存储近似值，float 单精度占 4 个字节，double 双精度占 8 个字节，相对来说 double 精度要高一些。由于浮点型数据存储的是近似值，不能精确表示一个值。所以一般判断两个浮点型数据是否相等的操作很少。.浮点数：底层存储方式与 整数不同 ,分为符号位丶指数位 丶尾数位。浮点型常量有两种表示形式：

• 十进制数形式：如：5.12 
• 科学计数法形式:如：5100E-2

float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。 double:双精度，精度是float的两倍。通常采用此类型。 Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。          

​

​浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。 

代码示例

public class Demo {
    public static void main(String[] args) {
        //2. 浮点型：float(4字节)  double(8字节)
        //① 浮点型，表示带小数点的数值，默认情况下，定义浮点型变量时，使用double型。
        //② float表示数值的范围比long还大
        double d = 5100E2;//科学计数法
        System.out.println(d);//510000.0
        //③ 定义float类型变量时，变量要以"f"或"F"结尾
        float f = 12.3F;
        System.out.println(f);//12.3
    }
}

字符类型：char

• 字符型 char 在 Java 语言中占用 2 个字节，char 类型的字面量必须使用半角的单引号括起来，取值范围为[0-65535]，char 和 short 都占用 2 个字节，但是 char 可以取到更大的正整数， 因为 char 类型没有负数。
• Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字 母，一个汉字，或其他书面语的一个字符。char类型是可以进行运算的。因为它都对应有Unicode码。我们可以根据对应的Unicode码运算

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

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

代码示例

public class Demo {
    public static void main(String[] args) {
        //3. 字符型：char (1字符=2字节)
        //① 定义char型变量，通常使用一对'',内部只能写一个字符
        char c1 = 'a';
        //编译不通过
        //c1 = 'AB';
        char c2 = '1';
        // 1.声明一个字符
        char c3 = '中';
        char c4 = 'ス';
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        //2.转义字符
        char c5 = '
';//换行符
        c5 = '	';//制表符
        System.out.print("hello" + c5);
        System.out.println("world");
        // 3.直接使用 Unicode 值来表示字符型常量
        char c6 = 'u0043';
        System.out.println(c6);// c
        // 字符可以计算，因为有对应的Unicode值
        System.out.println(c6 + 1);//68

    }
}

布尔类型：boolean

• boolean 类型用来判断逻辑条件，一般用于程序流程控制。
• boolean类型数据只允许取值true和false，无null。
• 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。

代码示例

public class Demo {
    public static void main(String[] args) {
        //4.布尔型：boolean
        //① 只能取两个值之一：true 、 false
        //② 常常在条件判断、循环结构中使用
        boolean b = true;
        System.out.println(b);//true
        boolean isMarried = false;
        if (isMarried) {
            System.out.println("你就不能参加"单身"party了！\n很遗憾");
        } else {
            System.out.println("你可以多谈谈女朋友！");//你可以多谈谈女朋友！
        }
    }
}

字符编码

实际上，起初的时候计算机只支持数字，因为计算机最初就是为了科学计算，随着计算机 的发展，为了让计算机起到更大的作用，因此我们需要让计算机支持现实世界当中的文字，一 些标准制定的协会就制定了字符编码（字符集），字符编码其实就是一张对照表，在这个对照 表上描述了某个文字与二进制之间的对应关系。

编码和解码，它们都是什么;我们拿字符'a'来解释一下：'a'是 97，97 对应的二进制是 01100001，那么从'a'到二进制 01100001 的转换过程称为编码，从二进制 01100001 到'a'的转换过程称为解码。大家一定要注意：编码和解码要采用同一种字符编码方式（要采用同一个对照表），不然会出现乱码。这也是乱码出现的本质原因。

随着计算机的不断发展，为了让计算机支持更多国家的语言，国际标准组织又制定了 ISO-8859-1 字符集，又被称为 latin-1，向上兼容 ASCII 码，仍不支持中文，主要支持西欧语言。 再后来，计算机慢慢的开始支持简体中文、繁体中文、日本语、朝鲜语等，其中支持简体中文 的字符集包括：GB2312 、GBK 、GB18030，它们的容量大小不同，其中 GB2312 < GBK < GB18030。支持繁体中文的是大五码 Big5 等。后来，在上世纪 90 年代初，国际组织制定了一 种字符编码方式，叫做 Unicode 编码，这种编码方式统一了全球所有国家的文字，具体的实现 包括：UTF-8，UTF-16，UTF-32 等。

Java 为了国际化，为了支持所有国家的语言，所以 Java 采用的编码方式为 Unicode 编码。 例如字符'中'对应的 Unicode 码是'u4e2d'。在实际开发中几乎所有的团队都会使用 Unicode 编 码方式，因为这种方式更通用，兼容性更好。

ASCII 码

• 在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有 0 和 1 两种状态， 因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节（byte）。一个字节一 共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从 0000000 到 11111111。
•  ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的 关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如 空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这 128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前 面的1位统一规定为0。
• 缺点：不能表示所有字符。 相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表 (ג) 了字母Gimel

Unicode 编码

• 乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因 此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读， 就会出现乱码。
• Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一 无二的编码，使用 Unicode 没有乱码的问题。
• Unicode 的缺点：Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码 应该如何存储：无法区别 Unicode 和 ASCII：计算机无法区分三个字节表示一个符号 还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果 unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有 二到三个字节是0，这对于存储空间来说是极大的浪费。

UTF-8

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

基本数据类型转换

Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。

自动类型转换

容量小的类型自动转换为容量大的数据类型。数据类型按容 量大小排序如下图所示：             

​

​

​代码示例

public class Demo1Conversion {
    /*
        隐式转换: 将数据类型中, 取值范围小的数据, 给取值范围大的类型赋值, 可以直接赋值
    */
    public static void main(String[] args) {
        int a = 10;            // int 4个字节
        double b = a;        // double 8个字节
        System.out.println(b); //10.0
    }
}

强制类型转换

• 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使 用时要加上强制转换符：()，但可能造成精度降低或溢出,格外要注意。
• 转换格式：数据类型 变量名 = （数据类型）被转数据值；
• 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。
• 浮点类型转为 整数类型 会 丢失小数

代码示例

/*
强制类型转换
    1. 特点：代码需要进行特殊的格式处理，不能自动完成。
    2. 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;

注意事项：
    1. 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
    2. byte/short/char这三种类型都可以发生数学运算，例如加法“+”.
    3. byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。
    4. boolean类型不能发生数据类型转换
*/
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
    }
}

 小练习

package demo01;
//需求：给定任意浮点数 输出去保留两位小数 考虑四舍五入的结果
public class Test2 {
    public static void main(String[] args) {
        //任意小数
        double d = 3.1452324;
        double temp = d * 100 + 0.5;
        double result = (int) temp / 100.0;
        System.out.println(result);
    }
}

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

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