Java学习（四）--数据类型

强类型语言

• 要求变量的使用要严格按照规定，所有变量都必须先定义后使用 (Java、C++等)

弱类型语言

• 与上述相反 (VB、JS等)

---

数据类型

Java 中的基本数据类型都是有符号的，没有无符号的基本数据类型。这意味着，Java 中的整数类型（byte、short、int、long）可以表示正数和负数，而不能仅表示正数。（符号位1表示负数，符号位0表示正数）。

但是，在 Java 8 开始，引入了一种新的无符号整数类型：无符号整型（unsigned int）。不过，这个类型并不是基本数据类型，而是在 Java 中通过特殊的方法进行模拟实现的。

// 将无符号整数字符串转换为 UnsignedInteger 类型
    UnsignedInteger num = UnsignedInteger.valueOf("4294967295");
    System.out.println(num);  // 输出：4294967295

    // 将 UnsignedInteger 类型转换为 BigInteger 类型
    BigInteger bigNum = num.bigIntegerValue();
    System.out.println(bigNum);  // 输出：4294967295

    // 将 BigInteger 类型转换为 UnsignedInteger 类型
    UnsignedInteger newNum = UnsignedInteger.valueOf(bigNum);
    System.out.println(newNum);  // 输出：4294967295

//由于无符号整数类型不是 Java 的基本数据类型，因此在进行无符号整数的运算和转换时，需要使用特定的类库或方法来处理。同时，使用无符号整数也需要谨慎，避免出现溢出等问题。

---

分类

（1）基本数据类型

    1）数值型

注意事项：

Java数值型有固定的范围和字段长度，不受具体OS的影响，以保证Java程序的可移植性；

1byte = 8个bit，    bit：计算机的最小存储单位；    byte：计算机中基本存储单位

浮点数在机器中存放形式： = 符号位+指数位+尾数位，因此尾数部分可能丢失，造成精度损失(小数都是近似值)；

    @Test
    public void test01() {
        double num11 = 2.7;
        double num12 = 8.1/3; 

        System.out.println(num11);//2.7
        System.out.println(num12);//接近 2.7 的一个小数，而不是 2.7

//注意：当我们对运算结果是小数的进行相等判断:应该是以两个数的差值的绝对值，在某个精度范围类判断
        if (num11 == num12) {
            System.out.println("num11 == num12 相等");//不相等
        }

        if (Math.abs(num11 - num12) < 0.000001) {
            System.out.println("差值非常小，到我的规定精度，认为相等...");//相等
        }
    }

//如果是直接查询得的小数或者直接赋值，是可以判断相等

---

   2）字符型

注意事项

1、字符编码方式：

一般计算机语言使用 ASCII 编码，用一个字节表示一个字符。ASCII 码是 Unicode 码的一个子集，用 Unicode 表示 ASCII 码时，其高字节为 0，它是其前 255 个字符。

Unicode字符通常用十六进制编码方案表示，范围在'\u0000'到'\uFFFF'之间，即从 0~65535。

\u0000到\u00FF表示ASCII/ANSI字符；

“\u”表示转义字符，它用来表示其后 4 个十六进制数字是 Unicode 码；u 告诉编译器是用两个字节（16 位）字符信息表示一个 Unicode 字符；

2、字符的使用：

//在 java 中， char 的本质是一个整数，在默认输出时，是 unicode 码对应的字符要输出对应的数字，可以(int)字符

char c1 = 97;
System.out.println(c1); // a

char c2 = 'a'; //输出'a' 对应的 数字
System.out.println((int)c2); //97


char c3 = '韩';
System.out.println((int)c3);//38889

char c4 = 38889;
System.out.println(c4);//韩


//char 类型加减运算按其Unicode编号进行运算
System.out.println('a' + 10);//107

3、null

空类型（null type）就是 null 值的类型，这种类型没有名称。因为 null 类型没有名称，因此不能声明一个 null 类型的变量或者转换到 null 类型；

空引用（null）只能被转换成引用类型，不能转换成基本类型，因此不要把一个 null 值赋给基本数据类型的变量。

4、字符型数据的存储和读取

字符型 存储到计算机，需要将字符对应的码值（整数）找出来；

‘a’ 存储： 'a' =>码值97 =>二进制（110 0001 ） =>存储；

'a'读取：二进制（110 0001） =>97 =>‘a’  =>显示；

---

    3）布尔型

说明：

   适用于逻辑运算， 一般用于程序流程控制；

  单独定义时候，存储空间与int一样，4字节32位；

  若定义在数组中，boolean会编译成byte类型的数组。

---

（2）引用数据类型

---

基本数据类型之间的转换

说明：

（byte、short）和char之间不会相互转换；

byte、short、char三者可以计算，计算时候先转换为int类型；（当把具体数赋给 byte 时， 会首先判断该数是否在 byte 范围内）；

Boolean不参与类型转换；

byte b = 50;
b = b * 2;    // Type mismatch: cannot convert from int to byte

//当表达式求值的时候，操作数被自动的提升为 int 型，计算结果也被提升为 int 型。
//这样表达式的结果现在是 int 型，不强制转换它就不能被赋为 byte 型

因为float和double类型的存储方式不一样，因此8个字节的long可以转成float而不会溢出；

float和double 存储是分为：符号位，指数部分，尾数部分

//强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级；

int x=(int)10*3.5+6*1.5;//编译错误：double->int

int x=(int)(10*3.5+6*1.5);//(int)44.0->44



//char类型可以保存int的常亮值，不能保存int的变量值，需要强转

char c1 = 100;

int m = 100;

char c2 = m ; //java: 不兼容的类型: 从int转换到char可能会有损失

char c3 = (char) m;

System.out.println(c3); // d

 基本数据类型与String类型的转换

说明：

s5.charAt(0)得到s5字符串的第一个字符'1'；

将 String 类型转成 基本数据类型时， 要确保String类型能够转化成有效的数据；比如 我们可以把 "123" , 转成一个整数，但是不能把 "hello" 转成一个整数。

//基本数据类型转换为 String 类型
int num = 123;
String str = Integer.toString(num);

//String 类型转换为基本数据类型
String str = "123";
int num = Integer.parseInt(str);

//基本数据类型数组转换为 String 类型
int[] nums = {1, 2, 3};
String str = Arrays.toString(nums);

//String 类型转换为基本数据类型数组
String str = "1,2,3";
String[] strArray = str.split(",");
int[] nums = new int[strArray.length];
for (int i = 0; i < strArray.length; i++) {
    nums[i] = Integer.parseInt(strArray[i]);
}


//String 类型转换为基本数据类型数据
String str="123";//输入字符串数字
int[] arr=new int[str.length()];//定义一个整型数组
for (int i = 0; i < str.length(); i++) {
	Character ch=str.charAt(i);//将字符串的每一个字符存到Character中
	arr[i]=Integer.parseInt(ch.toString());//将每一个字符转成整型数字
}
for (int i = 0; i < arr.length; i++) {
	System.out.print(arr[i]+" ");
}

//String 类型转换为基本数据类型数据
// 定义一个字符串
String str = "browser";
// 使用toCharArray()方法
char[] array = str.toCharArray();
// 遍历输出字符
for (char i : array) {
	System.out.println(i);
}

---

运算符

分类

1）算术运算符（基本运算符）

说明：

+运算符：

若运算符两边均为数值型，则进行加法运算；

若左右两边有一个为字符串，则做拼接运算；

运算顺序：从左到右。

自增运算符：

//a++的使用
int i=1;  //i->1
i=i++; 
	//规则使用临时变量:
	//(1)temp=i;
	//(2)i=i+1;
	//(3)i=temp;
System.out.println(i);//1

//<-------------------------------->

//++a的使用
int i=1;
i=++i;
	//规则使用临时变量:
	//(1)i=i+1;
	//(2)temp=i;
	//(3)i=temp;
System.out.println(i);//2

/ 除法：

System.out.println(10/4);//从数学来看是2.5,java中2；

System.out.println(10.0/4);//java是2.5；

double  d=10/4; 
System.out.println(d); //是2.0

需求：
//定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度（华氏温度为浮点数）


//注意：数学公式和 java 语言的特性

double huaShi = 1234.6;
double sheShi = 5.0 / 9 * (huaShi - 100);
System.out.println("华氏温度" + huaShi
+ " 对应的摄氏温度=" + sheShi);
}

%求余数：

-10%3 => -10-(-10)/3*3=-10+9=-1

10%-3=10-10/(-3)*(-3)=10-9=1

System.out.println(-10%3);//-1
System.out.println(10%-3);//1
System.out.println(-10%-3);//-1

---

2）逻辑运算符

说明：

逻辑运算符的操作数，必须是布尔值，运算结果也是一个布尔值。

短路与（&&）和短路或（||）采用最优化的计算方式，效率高；因此实际编程时，优先考虑使用短路与和短路或；

---

3）赋值运算符

说明：

只是一种简写，一般用于变量自身的变化，将某个运算后的值，赋给指定的变量。

运算顺序从右往左；

赋值运算符的左边 只能是变量，右边 可以是变量、表达式、常量值；

复合赋值运算符会进行类型转换；

int a = 1;
int b = 2;
a += b; // 相当于 a = a + b
System.out.println(a); //3

a += b + 3; // 相当于 a = a + b + 3
System.out.println(a); //8

a -= b; // 相当于 a = a - b
System.out.println(a); //6

a *= b; // 相当于 a=a*b
System.out.println(a); //12

a /= b; // 相当于 a=a/b
System.out.println(a); //6

a %= b; // 相当于 a=a%b
System.out.println(a); //0

//复合赋值运算符会进行类型转换
byte b = 3;

b += 2; // 等价 b = (byte)(b + 2);
b++; // b = (byte)(b+1);

---

4）比较运算符（关系运算符）

说明：

1、关系的解释

关系运算符中“关系”二字的含义是指一个数据与另一个数据之间的关系；这种关系只有成立与不成立两种可能情况，使用逻辑值来表示，即关系成立时表达式的结果为 true，否则表达式的结果为 false；

2、== 等于：

若运算两边是数值类型
    不管数据类型是否一样，只要值相等就返回true；
若两边是引用类型
    只有当两个引用变量的类型具有父子关系时才可以比较；
    只要两个引用指向的是同一个对象就会返回 true

3、Java 也支持两个 boolean 类型的值进行比较；

---

5）位运算符

说明：

Java 定义的位运算（bitwise operators）直接对整数类型的位进行操作，其中整数类型包括 long，int，short，char 和 byte；

位运算符主要用来对操作数二进制的位进行运算；表示按每个二进制位（bit）进行计算，其操作数和运算结果都是整型值；

使用 & 0xff 提取 RGBA 颜色坐标
假设我们有一个整数 x，以 32 位存储，表示 RGBA 系统中的一种颜色，这意味着它的每个参数（R、G、B 和 A）有 8 位：
R = 16 (00010000 in binary)
G = 57  (00111001 in binary)
B = 168 (10101000 in binary)
A = 7 (00000111 in binary)

因此，二进制中的 x 将表示为 00010000 00111001 10101000 00000111——相当于十进制的 272214023。现在，我们有十进制的 x 值，我们想要提取每个参数的值。

int rgba = 272214023;

int r = rgba >> 24 & 0xff;
assertEquals(16, r);

int g = rgba >> 16 & 0xff;
assertEquals(57, g);

int b = rgba >> 8 & 0xff;
assertEquals(168, b);

int a = rgba & 0xff;
assertEquals(7, a);

& 0xff 操作为我们提供了一种从数字中提取最低 8 位的简单方法。

实际上可以使用它来提取我们需要的任何8位，因为我们可以向右移动我们希望成为最低位的任何8位，然后，我们可以通过应用& 0xff操作来提取它们。

---

6）条件运算符（三元运算符）

说明：

经常用于取代某个类型的 if-then-else 语句；

表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)；
 

优先级

所谓优先级就是表达式运算中的运算顺序；

( ) >算术运算符 >关系运算符>逻辑运算符>三元运算符>赋值运算符；

说明：

以上所有运算符都是针对基本数据类型；

特殊的运算符：
        +
            低位溢出,符号位不变,并用符号位补溢出的高位
        ==
            可以用于引用数据类型的“地址”的比较
        =
            可以用于引用数据类型变量的赋值

其他

进制

（1）介绍

说明：

1）反码、补码说明：

反码的作用就相当于数学中的负数，有了负数，才可以实现减法与加法运算统一成加法运算；

问题：
将减法运算按加法运算处理，负数需要用反码表示，那么用 8 位二进制反码表示的正数范围：+0 —— +127；负数范围：-127 —— -0。但是，其中有两个特殊的编码会出现：

[0_0000000]=+0 （反码）

[1_1111111]=-0 （反码）

+0 和 -0 代表的都是 0。这样一来，“0” 这个数字在计算机中的编码就不是唯一；

解决：
把 0 当成正数，也即 +0，这样 0 的编码就变成：0_0000000。那 8 位二进制表示的正数范围仍然是：+0 —— +127。

负数整体向后“挪动1位”，反码 +1，{1_1111111}编码就不再表示 -0，而变成了 -1。

顺着推，最小的编码{1_0000000}就是 -128，8 位二进制表示的负数范围从：-127 —— -0 变成：-128 —— -1，就能成功解决问题。

这种操作好像是在反码上打了“补丁”，进行了一下修正,所以称之为补码；

2）为什么使用补码

与加法器相比，设计减法器硬件更为复杂，增加了计算的时间，在使用加法器实现减法器的功能的过程中使用了补码。

即采用补码可以简化计算机硬件电路设计的复杂度；

简化硬件电路的代价就是有符号数在存储和读取时都要进行转化，即原码、反码、补码。

3）计算机的底层使用补码的方式存储数据；

（2）进制转换

二进制转十进制

规则：从最低位（右边）开始，将每个位上的数提取出来，乘以2的（位数-1）次方，然后求和。

八进制转十进制

规则：从最低位（右边）开始，将每个位上的数提取出来，乘以8的（位数-1）次方，然后求和。

十六进制转十进制

规则：从最低位（右边）开始，将每个位上的数提取出来，乘以16的（位数-1）次方，然后求和。

十进制转换成八进制

规则：将该数不断除以 8，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的八进制。

十进制转换成二进制

规则：将该数不断除以2，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的二进制。

十进制转换成十六进制

规则：将该数不断除以16，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的十六进制。

（3）Java中进制

// 二进制
int bin = 0b1100010;
// 八进制
int oct = 0142;
// 十六进制
int hex = 0x62;
// 十进制
int dec = 98;

// 前缀是数字0，不是字母O
// 英文字母 b x 是不区分大小写的
// 在指定进制中使用规定的数码
// 底层存储都是二进制的形式

// Java默认使用十进制，输出显示都是十进制的形式
System.out.println("2:" + bin);//98
System.out.println("8:" + oct);//98
System.out.println("16:" + hex);//98
System.out.println("10:" + dec);//98

（4）Java中进制转换

二进制数据一般输入的格式是0x45, 0x3a, 0xc3, 这种数据格式看起来是16进制的字符串，但是实际上在存储的时候每个都对应一个字节，比如0x45的二进制字节就是0100 0101，对应的16进制字符串就是0x45。实际编程过程中，经常遇到这两种格式的相互转化。

打印输出

N 进制 -> 十进制

Integer.parseInt(String str, int N)

十进制数

// int 类型，打印成二进制数据
int iValue01 = 13;
String binaryString = Integer.toBinaryString(iValue01);
System.out.println(binaryString);//1101

// int 类型，打印成16进制
int ivalue02 = 13;
String hexString01 = Integer.toHexString(ivalue02);
System.out.println("binaryString = " + hexString01);//d

// 同样的 byte类型的数据打印成二进制
byte ivalue03 = (byte)24;
String binaryString02 = Integer.toBinaryString(ivalue03);
System.out.println("binaryString02 = " + binaryString02);//11000

// byte 类型的数据打印成16进制
byte ivalue04 = (byte)24;
String hexString = Integer.toHexString(ivalue04);
System.out.println("binaryString = " + hexString);//18


//N进制字符转转换为十进制数
String str = "21104";
            int N = 5;
            System.out.println(str + " 的十进制是:" + Integer.parseInt(str, N));

---

ASCII表