Java基本数据结构类型

一，数据类型（8种基本数据类型）

数据类型范围排序（从小到大）：

byte(8) < short(16) < int(32) < long(64) < float(32) < double(64)

*String类型不属于基本数据类型，主要用来存放文本类型的数据

1. String goodsName = " ⿇辣王⼦ ";
2. String num = "5"; // 这是文字"5"，不是数字5！不能直接做数学计算。

3. String[] toppings = {"巧克力豆", "坚果碎", "彩虹糖"}; // 3格调料盘

4. String forgottenOrder = null; // 贴了标签的空外卖盒

将基本数据类型转换为String的方法

在Java中，当字符串(String)与任何基本数据类型使用+操作符连接时，Java会自动将基本数据类型转换为字符串形式。这是一种隐式转换。

如：

String result3 = "" + a;  // 空字符串与int相加会自动转换为String

赋值+运算+强制类型转换+自动类型转换

赋值注意：在Java中，当给long类型的变量赋值时，如果直接赋予的整数字面量超出了int类型的范围（即 -2^31 到 2^31-1，约 -2.1×10^9 到 2.1×10^9），则必须在数字后加上 L 或 l 后缀，显式表明这是一个long类型的字面量。否则，编译器会报错。

1. 未超出 int 范围：可以不加 L/l，但建议加上以明确类型。

   long a = 100;     // 合法（100在int范围内，自动转为long）
   long b = 100L;    // 显式声明为long（推荐写法）

2. 超出 int 范围：必须加 L/l，否则编译错误。

   long c = 2147483648L;  // 合法（超出int最大值2^31-1）
   long d = 2147483648;   // 编译错误（未加L，默认被当作int处理）

强转：

当大范围类型→小范围类型时（如double→int）

自动类型转换（隐式转换）

小范围→大范围类型（无精度损失）

1.以下哪个数值不能直接赋值给long类型变量？

• A) 100

• B) 3000000000

• C) 3000000000L

• D) 3.14                                                                    //3.14是浮点数字面量，不能直接赋值给long类型。3000000000超过int范围，需要加L后缀

2.int num = 128;
byte b = (byte)num;
System.out.println(b)；
A) 128
B) 0
C) -128
D) 编译错误
答案：C，byte范围是-128~127，128强制转换后会溢出变成-128

3.byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
A) 30
B) 编译错误
C) 0
D) -26
答案：B，byte运算时会自动提升为int，需要强制转换：(byte)(a + b)

不同数据类型之间的数据不能互换

1. 整数 → 小数：

   • 就像把整数3变成小数3.0，计算机可以自动做这种转换

2. 小数 → 整数：

   • 计算机需要你明确说"我愿意丢掉小数部分"才这样做

3. 数字 ↔ 文字：数字和文字是完全不同的东西！

   • 你不能把真正的苹果和写着"苹果"的纸条混为一谈

   • 计算机需要特殊方法才能转换（比如把数字3变成文字"3"）

❌ 陷阱：

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
A) 30
B) 编译错误
C) 0
D) -26
答案：B，byte运算时会自动提升为int，需要强制转换：(byte)(a + b)

// 字符本质是数字
char ch = 'A';                   // 实际存储65
System.out.println(ch + 1);       // 输出66（ASCII码计算）

1. 整数默认是int：

   byte b = 100;    // ✅ 自动转换  
   byte b2 = 200;   // ❌ 超出byte范围

2. 浮点数默认是double：

   float f = 3.14;    // ❌ 需要加f后缀  
   float right = 3.14f; // ✅

3. boolean不能参与运算：

   if(1) {...}     // ❌ Java不能像C那样用1代替true

计算时的自动类型转换

例：byte smallBox = 10;

short mediumBox = smallBox * 2;          //short mediumBox =（short） smallBox; // 也需要强制转换！

System.out.println(mediumBox);

1. 读取smallBox值：从byte盒子取出数字10

2. 遇到乘号*：Java会启动"自动类型转换"

   • 先把byte类型的10升级为int类型

   • 数字2默认是int类型

3. 执行计算：int(10) * int(2) = int(20)

4. 把int(20)装入short盒子

   • 这里发生"缩小转换"（从4字节的int到2字节的short）

   • 因为20在short范围内(-32768~32767)，所以安全通过

     
     byte(1字节) → 计算时自动升级 → int(4字节) 
            ↓
        计算结果
            ↓
     short(2字节) ← 安全缩小装入

溢出+边界值判断

Java为了防止计算溢出，任何比int小的类型运算时都会自动升级为int

byte b = 127;  // byte的最大正值
b++;           // 加1导致溢出
System.out.println(b); // 输出-128

用钟表来类比：

• 把byte的范围(-128到127)想象成一个钟表

• 127相当于钟表上的"12点"

• 当你再加1时，指针不是走到"13点"(因为不存在)，而是循环回到起点"-128"

• int max = Integer.MAX_VALUE;
  System.out.println(max + 1);

  A) 2147483648    B) -2147483648           C) 0                  D) 编译错误

• 答案：B，整数溢出会变成最小值（补码表示）

1. 边界测试：编写代码测试每种数据类型的最大值/最小值

   System.out.println("Byte: " + Byte.MIN_VALUE + " ~ " + Byte.MAX_VALUE);

2. 精度实验：验证浮点数精度

   System.out.println(1.0 - 0.9);  // 实际输出0.09999999999999998

数据类型与（==和+=）

1.正确：
int a = 10;
a = a + 5;  // a 变成了 15    （ a += 5;  // 相当于 a = a + 5，a 也变成了 15）
System.out.println(a); // 输出 15

2.
int a = 10;
a = a + 3.5;  // 错误！因为 a 是整数，不能存小数

3.
int a = 10;
a += 3.5;  // 不报错！但 a 仍然是 13（小数部分被丢弃）

4.（正确）

public static void main(String[] args) {
    byte a = 10;  // a 是一个小盒子，只能装很小的数字（-128 ~ 127）
    a += 1;       // 往盒子里加 1{a += 1其实相当于：a = (byte)(a + 1); }
    System.out.println(a); // 输出 11
}

若换成：
byte a = 10;
a = a + 1;  // 报错！Java 会说："不行！"
原因：

a + 1 的计算结果是 int 类型（Java 默认整数计算会变成 int）。

a 是 byte 类型，不能直接存 int