😊 @ 作者：一恍过去

💖 @ 主页： https://blog.csdn.net/zhuocailing3390

🎊 @ 社区： Java技术栈交流

🎉 @ 主题： Java开发基础系列(二):数据类型

⏱️ @ 创作时间： 2023年07月09日

1、八大数据基本类型
2、八大数据包装类型
3、数据的拆箱与装箱
4、String字符串
- 4.1 字符串截取
- 4.2 字符串连接
- 4.3 不可变性
- 4.4 字符串常量池
- 4.5 字符串比较
- 4.6 字符串常用API
5、大数值类型
6、数组对象
- 6.1 数据创建即使用
- 6.2 数据常用API

1、八大数据基本类型

基本数据类型

Java有八种基本数据类型：byte、short、int、long、float、double、boolean、char；

其中有4中整型(byte、short、int、long)，2种浮点型(float、double)，1种字符类型(char)，1种布尔类型(boolean)

表现符号

long(长整数)、float(单精度浮动数)、double(双精度浮动数)这三类数据类型在定义数据时，可以使用特定的后缀进行表示，比如：

1、直接定义整数表示int类型，如果要定义长整数，需要使用`L或者l`作为后缀
int i = 10; //不带任何符合默认为int类型
int er = 10L; //  错误的数据类型定义

long j = 10L;

==================================================================================

2、直接定义浮点数表示double类型，如果要定义float后缀double，需要使用`F或者f`与`D或者d`作为后缀
double k1 = 10D;
double k2 = 3.14159D;
double k3 = 3.14; //不带任何符合默认为double类型

float f = 10f;

float f2 = 10.10; // 错误的定义，没有后缀名默认为double类型
float f3 = 20.20D; // 错误的数据类型定义

类型对比表

基本类型	名称	标准符号	包装类型	内存占用	取值范围
byte	位	-	Byte	1	-128 ~ 127
short	短整数	-	Short	2	-32 768 ~ 32 767
int	整数	-	Integer	8	-2 147 483 648 ~ 2 147 483 647
long	长整数	L或者l	Long	8	-9 223 372 036 854 775 808 ~ 9 223 372 036 854 775 807
float	单精度浮动数	F或者f	Float	4	1.4E-45~ 3.4028235E38
double	双精度浮动数	D或者d	Double	8	4.9E-324~ 1.7976931348623157E308
boolean	布尔类型	-	Boolean	1	true、false
char	字符	-	Character	1	‘\u0000’~ ‘\uFFFF’

在这里插入图片描述

2、八大数据包装类型

数据包装类型

Java为八种基本数据类型提供了八种对应的包装类型：Byte、Short、Integer、Long、Float、Double、Boolean、Character

包装类型目的

Java中的八种基本数据类型不是面向对象的，包装类型相当于将基本类型包装起来，使其具有对象的性质，可以和对象一样使用属性和方法，丰富了基本类型的操作。

包装与基本类型的区别

类型不同： 包装类型属于对象，基本类型不是对象;
创建的不同： 基本类型可以直接进行赋值，而封装类型需new关键字;
```
int a1 = 10;
Integer a2 = new Integer(10);
```
初始值的不同： 基本类型在初始化时必须设置默认的值，包装类型在初始化时可以设置值为null;
```
int a1 = 0;
Integer a2 = null;
```

使用的不同： 在配合集合使用时，只能使用包装类型;

List<Integer> list = new ArrayList<>();

List<int> list2 = new ArrayList<>(); // 错误的定义

API的不同： 包装类型属性对象，可以使用对象的属性和方法;

// TODO 操作的API较多，下列进行简单的列举
Integer.MAX_VALUE、Double.MAX_VALUE、Long.MAX_VALUE .... // 获取最大值
Integer.MIN_VALUE、Double.MIN_VALUE、Long.MIN_VALUE.... // 获取最小值
Integer.valueOf(String s)// 数据转换
Integer.compare(int x, int y)// 数据比较

存储的不同： 基本类型的变量值保存在堆栈中，包装类型通过引用指向实例，变量值保存在堆中。

3、数据的拆箱与装箱

数据的拆箱与装箱就是基本数据类型与包装数据类型之间的转换
拆箱： 就是把基本数据对应的包装类型转化为基本数据类型的动作就叫拆箱。
装箱： 就是基本数据类型，在编译器的处理下自动转化为包装类型的动作就叫做装箱。

拆箱的实现：

1、把包装数据类型的值作为参数传递给基本数据类型的接收方法；

public static void main(String[] args) {
   Integer a =10;// 基本数据类型
   test(a);
}
// 通过方法的传参的方式，包装类型转换为了基本类型
public static void test(int a){

}

===============================================

2、包装数据类型的值赋给对应的基本数据类型；

public static void main(String[] args) {
   Integer a1 = 10; //包装数据类型
   int a2 =a1;// 基本数据类型
}

装箱的实现：

1、把基本数据类型的值作为参数传递给包装数据类型的接收方法；

public static void main(String[] args) {
   int a =10;// 基本数据类型
   test(a);
}
// 通过方法的传参的方式，基本类型转换为了包装类型
public static void test(Integer a){

}

===============================================

2、基本数据类型的值赋给对应的包装数据类型；

public static void main(String[] args) {
   int a1 =10;// 基本数据类型
   Integer a2 = a1; //包装数据类型
}

在这里插入图片描述

4、String字符串

字符串(String)是一种基本的数据类型，用来存储和操作一系列字符的数据。Java中的字符串在java.lang包中定义，并且可以在没有导入任何额外的包的情况下使用。可以直接使用双引号完成字符串的定义，比如：

String str = "Hello, World!";

4.1 字符串截取

字符串截取，是操作字符串常用的方法，通过substring()方法，截取指定长度的字符串。
语法如下：

// beginIndex 开始截取的位置，索引值从0开始，即第一个字符的下标为0
// endIndex   结束截取的位置，但是不包含该位置的字符串
// endIndex - beginIndex = 截取后字符的长度
String substring(int beginIndex, int endIndex);

实例：

// 初始化字符串 str
String str = "hello world";

// 截取活动 `llo wor`
// 第一步(beginIndex 计算)：计算出第一`l`字符的下标值为：2(下标从0开始算)
// 第二步(endIndex 计算)：计算出最后一个`r`字符的下标值为：8(下标从0开始算，空格也算一个字符，)
// 第三步：使用截取方法，由于endIndex是指截取的位置(但是不包含在内)，所以在计算结束位置的下标后，还需要`+1`
String newStr = str.substring(2, 9);// 9 = 8+1
System.out.println(newStr); // 输出结果："llo wor"

4.2 字符串连接

1、Java中可以直接使用+运算符将两个字符串连接在一起，比如：

String a = "hello ";
String b = "world";
String c = a + b;
System.out.println(c); // 输出结果为"hello world"

2、字符串与其他类型的数据进行拼接时都会自动转换为字符串进行拼接，比如：

String a = "hello ";
int b = 123;
String c = a + b;
System.out.println(c); // 输出结果为"hello 123"

3、利用字符串拼接把数值强制转换为字符串，比如：

int a = 123;
String c = a + ""; // 数字前(后)加上空白字符串("")，就会转换为一个字符串
System.out.println(c); // 输出结果为"123"

4、需要注意是两个数值字符串相加得到的是连接后字符串，而不是相加后的具体数值，比如：

String a = "1";
String b = "1";
String c = a + b;
System.out.println(c); // 输出结果为"11"，而不是"2"

4.3 不可变性

Java没有为String提供修改字符串的方法，所以Java中的字符串是不可变的。这意味着一旦创建了字符串，就不能更改它。需要注意的是：如果你尝试改变字符串，Java实际上会创建一个新的字符串。

// 定义字符串对象 str
String str = "hello";

// 将str修改为"hello World"，此时虽然都使用的`str`这个对象，其实对象的地址值已经发生了变化，产生了一个新的对象
str = "hello World";

4.4 字符串常量池

为了提高性能和减少内存消耗，Java实现了一个称为字符串常量池的机制，相同的字符串值会共享使用同一个地址值。有两个相同的字符串字面值，它们实际上会指向内存中的同一个对象。

// 定义a对象
String a = "hello";

// 定义b对象
String b = "hello";

虽然分别定义了a、b两个对象，由于两个字符串的值都是"hello"，所以对象的地址值是相同的；

4.5 字符串比较

通过s.equals(o)方法来比较两个字符串是否相等，比较结果返回true或者false，比较时可以使用字符串对象或者字符串面值，比如：

String a = "hello";
String b = "he";
// 进行比较
"hell".equals(a); // 结果:false
"hello".equals(a); // 结果:true
b.equals(a); // 结果:false
b.equals("he"); // 结果:true
"hell".equals("hello"); // 结果:false

可以通过equalsIgnoreCase，在比较时不区分大小写，比如：

String a = "Hello";
String b = "hEllO";
b.equalsIgnoreCase(a); // 结果:true

TIP：
在进行字符串对象间比较时，当对象可能会出现null值时，那么该对象最好写在equals()方法内，否则可能会出现“空指针异常”；
String a = null;
a.equals("hello"); // 会出现报错
"hello".equals(a); // 结果:false

在进行字符串比较时，最好使用equals而不是==；因为equals比较的是对象的数值，而==比较的是对象的地址值。虽然存在着字符串常量池，使得通常情况下字符串面值一样时地址值也一样。但是如果通过+或substring()方式得到的新的字符串，即使字符串面值一样，地址值也不一样，所以在通过==比较字符串面值时得到的结果就是false，会导致输出结果与预期结果不一致的情况；

String str = "hello";
String s1 = "he";
String s2 = "llo";
String s3 = s1 + s2; // 使用字符串拼接
String s4 = "hello123".substring(0, 5); // 使用字符串截取

s3==s4; // 结果：false
s3.equals(s4); // 结果：true
str==s4; // 结果：false
str==s3; // 结果：false
str.equals(s4); // 结果：true
str.equals(s3); // 结果：true

4.6 字符串常用API

Java中的String类提供了一系列的方法(API)用于处理和操作字符串，以下是一些常用的字符串方法：

1. length(): 返回字符串的长度

String str = "Hello";
int len = str.length();  // 长度为：5

2. charAt(int index): 返回字符串中指定索引处的字符。

String str = "Hello";
char ch = str.charAt(1);  // ch is 'e'

3. substring(int beginIndex) 和 substring(int beginIndex, int endIndex): 返回从指定索引开始的子字符串。如果提供了结束索引，那么返回的子字符串将不包含结束索引处的字符。

String str = "Hello";
String sub = str.substring(1);  // 结果： "ello"
String sub2 = str.substring(1, 3);  // 结果： "el"

4. indexOf(String s) 和 lastIndexOf(String s): 返回指定子字符串在此字符串中第一次出现处的索引，或者最后一次出现的索引。如果没有找到，则返回-1。

String str = "Hello";
int i = str.indexOf('l');  //  结果： 2
int j = str.lastIndexOf('l');  // 结果： 3

5. equals(Object anObject): 比较此字符串与指定的对象是否相等。

String str1 = "Hello";
String str2 = "Hello";
boolean eq = str1.equals(str2);  //  结果：true

6. equalsIgnoreCase(String anotherString): 忽略大小写，比较两个字符串是否相等。

String str1 = "Hello";
String str2 = "hello";
boolean eq = str1.equalsIgnoreCase(str2);  // 结果： true

7. startsWith(String prefix) 和 endsWith(String suffix): 检查字符串是否以指定的前缀开始或者后缀结束。

String str = "Hello";
boolean st = str.startsWith("He");  //  结果： true
boolean en = str.endsWith("lo");  //  结果： true

8. toLowerCase() 和 toUpperCase(): 返回字符串的小写或大写形式。

String str = "Hello";
String lower = str.toLowerCase();  // 结果： "hello"
String upper = str.toUpperCase();  // 结果： "HELLO"

9. trim(): 返回字符串的副本，忽略前导空白和尾部空白。

String str = " Hello ";
String trimmed = str.trim();  // 结果： "Hello"

10. replace(char oldChar, char newChar): 返回新的字符串，用新字符替换所有出现的旧字符。

String str = "Hello";
String replaced = str.replace('l', 'w');  // 结果： "Hewwo"

在这里插入图片描述

5、大数值类型

对于精确度更高的计算，可以使用大数值类型，分为：BigInteger与BigDecimal ；
通过valueOf()方法可以将普通的数值转换为大数值，比如：

BigDecimal a = BigDecimal.valueOf(200.25);

BigInteger b = BigInteger.valueOf(100);

通过new对象的方式，进行大数值类型的初始化

BigInteger big1 = new BigInteger("100");

BigDecimal big2 = new BigDecimal("200.22");

大数值类型计算方式与普通的数值类型计算方式有所不同，具体计算公式如下：

BigInteger：

语法：

// 加法：
Biglnteger add(Biglnteger other)
// 减法
Biglnteger subtract(Biglnteger other)
// 乘法
Biglnteger multipiy(Biginteger other)
// 除法
Biglnteger divide(Biglnteger other)
// 如果这个大整数与另一个大整数 other 相等， 返回 0; 如果这个大整数小于另一个大整数 other, 返回负数；否则， 返回正数。
int compareTo(Biglnteger other)

实例：

// 初始化
BigInteger big1 = new BigInteger("200");
BigInteger big2 = new BigInteger("100");
// 计算        
BigInteger add = big1.add(big2); // 结果：300
BigInteger subtract = big1.subtract(big2); // 结果：100
BigInteger multiply = big1.multiply(big2); // 结果：20000
BigInteger divide = big1.divide(big2); // 结果：2
int i = big1.compareTo(big2); // 结果：1 ，因为：(big1>big2)

BigDecimal：

语法：

// 加法：
Biglnteger add(Biglnteger other)
// 减法
Biglnteger subtract(Biglnteger other)
// 乘法
Biglnteger multipiy(Biginteger other)
// 除法
Biglnteger divide(Biglnteger other)// 直接除，如果无限循环小数将报错
Biglnteger divide(Biglnteger other,RoundingMode roundingMode)// 对除后的结果，进行四舍五入到>整数位
Biglnteger divide(Biglnteger other,int scale, RoundingMode roundingMode)// 对除后的结果，保留指>定位数，再进行四舍五入
// 如果这个大整数与另一个大整数 other 相等， 返回 0; 如果这个大整数小于另一个大整数 other, 返回>负数；否则， 返回正数。
int compareTo(Biglnteger other)

实例：

BigDecimal big1 = new BigDecimal("200");
BigDecimal big2 = new BigDecimal("3");

BigDecimal add = big1.add(big2); // 结果：203
BigDecimal subtract = big1.subtract(big2); // 结果：197
BigDecimal multiply = big1.multiply(big2); // 结果：600
BigDecimal divide1 = big1.divide(big2, RoundingMode.HALF_UP); // 结果：67
BigDecimal divide2 = big1.divide(big2,3,RoundingMode.HALF_UP); // 结果：66.667
int i = big1.compareTo(big2); // 结果：1 (big1>big2)

6、数组对象

数组（Array）是一种用于存储相同类型数据的数据结构。它是一个固定长度的容器，可以在内存中连续存储多个元素，一单数组的长度确定了，就不能再进行修改。

6.1 数据创建即使用

声明数组： 声明一个数组时，需要指定数组类型和数组名称；完成声明后，实际的数组对象还没有被创建，比如声明numbers与names两个数组：

int[] numbers; 

String[] names;

创建数组： 使用 new 关键字来创建一个数组对象，并且指定数组的长度，数组创建成功后数组中的每个元素都拥有一个默认值(默认值与数据类型有关)，比如：

// 声明
int[] numbers; 
String[] names;

// 创建
numbers = new int[5]; 
names = new String[10];

// 创建时同时进行声明，常用
int[] numbers2 = new int[5];  // 默认值为：0
String[] names2 = new String[10]; // 默认值为：null

访问数组元素： 通过指定数组的下标索引值，就可以访问到指定的数组元素，数组的下标值从0开始，需要注意的是：由于数组下标从0开始，所以下标的最大值为数组长度减1，比如：

int[] numbers = new int[5];
numbers[0]; // 第一个元素
numbers[4]; // 第无个元素

初始化数组： 初始化分为静态初始化与动态初始化。

静态初始化：在声明和创建数组的同时为数组赋初值；
动态初始化：在创建数组后，后续根据业务需求，再为指定的数组元素赋值；

// 静态初始化
int[] numbers = {1, 2, 3}; 

String[] names = {"a", "b", "c"};

// 动态初始化
int[] numbers2 = new int[5];
String[] names2 = new String[10];
numbers2[0] = 2; // 为数组中的第一个元素，赋值为:2
names2[1] = "hello"; // 为数组中的第二个元素，赋值为:"hello"

实例：

public class ArrayExample {
    public static void main(String[] args) {
        // 声明和创建数组
        int[] numbers = new int[5];

        // 静态初始化数组
        String[] names = {"John", "Alice", "Bob"};

        // 动态初始化数组
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;

        // 访问数组元素
        int value = numbers[2];
        System.out.println("Value: " + value);

        // 修改数组元素值
        numbers[3] = 40;
   }
}

6.2 数据常用API

1. length：数组的属性，用于获取数组的长度。

int[] numbers = {1, 2, 3, 4, 5};
int length = numbers.length; // 获取数组的长度，结果为5

1. clone()：用于创建数组的副本。

int[] numbers = {1, 2, 3, 4, 5};
int[] copy = numbers.clone(); // 创建数组的副本

3. toString()：将数组转换为字符串表示。

int[] numbers = {1, 2, 3, 4, 5};
String str = Arrays.toString(numbers); // 结果："[1, 2, 3, 4, 5]"

4. equals()：用于比较两个数组是否相等。

// 需要数组中，各个下标位置的数值一样，得到的结果才是true
int[] numbers1 = {1, 2, 3, 4, 5};
int[] numbers2 = {1, 2, 3, 4, 5};
boolean isEqual = Arrays.equals(numbers1, numbers2); // 结果为：true

int[] numbers3 = {1, 2, 3, 4, 5};
int[] numbers4 = {1, 2, 3, 5, 4};
boolean isEqual2 = Arrays.equals(numbers3, numbers4); // 结果为：false

5. sort()：对数组进行排序。

int[] numbers = {5, 3, 1, 4, 2};
Arrays.sort(numbers); // 对数组进行排序，结果为[1, 2, 3, 4, 5]

5. copyOf()：对数组进行复制。
复制时，会三种情况：复制后数组变小、复制后数组不变、复制后数组变大

 int[] originalArray = {1, 2, 3, 4, 5};
// 复制原始数组的全部元素
int[] newArray1 = Arrays.copyOf(originalArray, 

// 复制原始数组的前3个元素
int[] newArray2 = Arrays.copyOf(originalArray, 3);

// 创建长度为7的新数组，如果超出原始数组长度部分填充默认值
int[] newArray3 = Arrays.copyOf(originalArray, 7);