代码收藏家 Java字符串相关类知识：构造方法、比较、常见方法及内存管理
文章目录
一、String
1. Java中的数据类型
Java中的数据类型分为两大类：基本数据类型（Primitive Types）和引用数据类型（Reference Types）。String 是一种引用数据类型，用于存储一系列字符（即文本）。
2. 字符串概述
String 是 Java 中用于表示文本（字符序列）的类。它是不可变的（immutable），即一旦创建就不能改变其内容。
3. 字符串构造方法
String 类提供了多种构造方法来创建字符串实例，例如：
String(): 创建一个空字符串。String(char[] value): 使用字符数组来创建字符串。String(byte[] bytes): 使用字节数组来创建字符串（注意字符编码）。String(String original): 创建一个字符串的副本。String(char[] value, int offset, int count): 使用字符数组的一部分来创建字符串。当讨论 String 类的构造方法时，以下是一些示例代码，展示了如何使用这些构造方法来创建 String 对象：
public class StringExamples {
public static void main(String[] args) {
// 1. 创建一个空字符串
String emptyString = new String();
System.out.println(emptyString); // 输出: ""
// 2. 使用字符数组来创建字符串
char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String stringFromCharArray = new String(charArray);
System.out.println(stringFromCharArray); // 输出: Hello
// 3. 使用字节数组来创建字符串（注意字符编码，这里使用默认编码）
byte[] byteArray = "Hello, World!".getBytes(); // 使用平台默认字符集进行编码
String stringFromByteArray = new String(byteArray);
System.out.println(stringFromByteArray); // 输出: Hello, World!（前提是默认字符集支持该文本）
// 4. 创建一个字符串的副本
String originalString = "Original";
String copyOfString = new String(originalString);
System.out.println(copyOfString); // 输出: Original
// 5. 使用字符数组的一部分来创建字符串
char[] substringCharArray = {'W', 'o', 'r', 'l', 'd', '!', 'a', 'n', 'd', ' ', 'm', 'o', 'r', 'e'};
String substringString = new String(substringCharArray, 6, 5); // 从索引6开始，取5个字符
System.out.println(substringString); // 输出: and more
}
}
在上面的示例中，展示了如何使用 String 类的不同构造方法来创建字符串。当使用字节数组创建字符串时，需要确保字节数组中的字节可以正确地被解释为字符，这通常涉及到字符编码。在上面的示例中，我们使用了 getBytes() 方法来获取字符串的字节表示，并默认使用了平台的默认字符集。然后，我们使用 new String(byteArray) 来将这些字节转换回字符串。然而，在实际应用中，可能会明确指定一个字符集，如 UTF-8，以避免编码问题。
另外，值得注意的是，当使用字符串字面量（如 "Hello, World!"）时，JVM 会自动在字符串常量池中创建字符串对象。但是，当使用 new String("Hello, World!") 时，会在堆上创建一个新的字符串对象，即使它的内容与常量池中的某个字符串相同。这两个对象在内存中是分开的，并且在 == 操作符的比较下是不相等的，但它们在 equals() 方法的比较下是相等的。
4. 字符串构造内存原理
当使用字面量或 new 关键字创建 String 对象时，Java 会在字符串常量池（String Constant Pool）或堆（Heap）内存中为它们分配空间。字面量通常存储在字符串常量池中，而使用 new 创建的 String 对象则始终在堆上。
5. 字符串比较
equals() 和 equalsIgnoreCase(): 用于比较两个字符串的内容是否相等（忽略大小写）。compareTo() 和 compareToIgnoreCase(): 用于按字典顺序比较两个字符串，并返回一个整数表示它们之间的关系。==: 用于比较两个字符串引用是否指向内存中的同一对象（不推荐用于内容比较）。当涉及到字符串比较时，以下是 equals(), equalsIgnoreCase(), compareTo(), compareToIgnoreCase(), 和 == 的代码示例：
public class StringComparisonExamples {
public static void main(String[] args) {
// 1. 使用 equals() 比较两个字符串的内容
String str1 = "Hello";
String str2 = new String("Hello");
System.out.println(str1.equals(str2)); // 输出: true，因为内容相同
// 2. 使用 equalsIgnoreCase() 忽略大小写比较
String str3 = "HELLO";
System.out.println(str1.equalsIgnoreCase(str3)); // 输出: true，因为内容相同（忽略大小写）
// 3. 使用 compareTo() 比较两个字符串的字典顺序
String str4 = "Apple";
String str5 = "Banana";
int result = str4.compareTo(str5);
System.out.println(result); // 输出: 负数，因为 "Apple" 在字典上小于 "Banana"
// 4. 使用 compareToIgnoreCase() 忽略大小写按字典顺序比较
String str6 = "apple";
String str7 = "Banana";
int resultIgnoreCase = str6.compareToIgnoreCase(str7);
System.out.println(resultIgnoreCase); // 输出: 负数，因为 "apple"（忽略大小写）在字典上小于 "Banana"（忽略大小写）
// 5. 使用 == 比较两个字符串引用
String str8 = "Hello";
String str9 = "Hello"; // 由于是字符串字面量，所以它们指向常量池中的同一对象
String str10 = new String("Hello"); // 使用 new 创建的新对象
System.out.println(str8 == str9); // 输出: true，因为它们是常量池中的同一对象
System.out.println(str8 == str10); // 输出: false，因为 str10 是新创建的对象
}
}
在这个示例中，equals() 和 equalsIgnoreCase() 方法用于比较两个字符串的内容是否相同。compareTo() 和 compareToIgnoreCase() 方法则用于按字典顺序比较两个字符串，并返回一个整数来表示它们在字典中的相对位置。
注意，compareTo() 返回的整数可以是负数（表示第一个字符串在字典上小于第二个字符串）、零（表示两个字符串相等）或正数（表示第一个字符串在字典上大于第二个字符串）。
最后，== 操作符用于比较两个字符串引用是否指向内存中的同一对象。对于字符串字面量，JVM 通常会将它们存储在字符串常量池中，并尝试重用相同的对象。但是，使用 new 关键字创建的字符串对象会在堆上分配新的内存，并创建一个新的对象实例。因此，使用 == 比较两个由 new 创建的字符串对象时，它们通常不会相等（除非它们引用的是同一个对象）。
6. 字符串常见方法
length(): 返回字符串的长度。charAt(int index): 返回指定索引处的字符。substring(int beginIndex, int endIndex): 返回一个新字符串，它是此字符串的一个子字符串。indexOf(int ch) 和 indexOf(String str): 返回指定字符或子字符串在此字符串中第一次出现处的索引。lastIndexOf(int ch) 和 lastIndexOf(String str): 返回指定字符或子字符串在此字符串中最后一次出现处的索引。trim(): 返回字符串的副本，忽略前导空白和尾部空白。replace(char oldChar, char newChar): 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。concat(String str): 将指定字符串连接到此字符串的结尾。toUpperCase() 和 toLowerCase(): 返回此字符串的大写形式或小写形式。当涉及到字符串的常见方法时，以下是您提到的每个方法的代码示例：
public class StringMethodsExamples {
public static void main(String[] args) {
// 1. length(): 返回字符串的长度
String str = "Hello, World!";
int length = str.length();
System.out.println("Length: " + length); // 输出: Length: 13
// 2. charAt(int index): 返回指定索引处的字符
char firstChar = str.charAt(0);
System.out.println("First character: " + firstChar); // 输出: First character: H
// 3. substring(int beginIndex, int endIndex): 返回子字符串
String subStr = str.substring(7, 12);
System.out.println("Substring: " + subStr); // 输出: Substring: World
// 4. indexOf(int ch) 和 indexOf(String str): 返回指定字符或子字符串第一次出现的索引
int indexOfComma = str.indexOf(',');
int indexOfWorld = str.indexOf("World");
System.out.println("Index of comma: " + indexOfComma); // 输出: Index of comma: 7
System.out.println("Index of World: " + indexOfWorld); // 输出: Index of World: 7
// 5. lastIndexOf(int ch) 和 lastIndexOf(String str): 返回指定字符或子字符串最后一次出现的索引
int lastIndexOfO = str.lastIndexOf('o');
int lastIndexOfWorldLast = str.lastIndexOf("World");
System.out.println("Last index of 'o': " + lastIndexOfO); // 输出: Last index of 'o': 10
System.out.println("Last index of 'World': " + lastIndexOfWorldLast); // 输出: Last index of 'World': 7
// 6. trim(): 忽略前导和尾部空白
String strWithSpaces = " Hello, World! ";
String trimmedStr = strWithSpaces.trim();
System.out.println("Trimmed string: " + trimmedStr); // 输出: Trimmed string: Hello, World!
// 7. replace(char oldChar, char newChar): 替换字符
String replacedStr = str.replace('o', 'x');
System.out.println("Replaced string: " + replacedStr); // 输出: Replaced string: Hellx, Wxrld!
// 8. concat(String str): 连接字符串
String concatenatedStr = str.concat(" How are you?");
System.out.println("Concatenated string: " + concatenatedStr); // 输出: Concatenated string: Hello, World! How are you?
// 9. toUpperCase() 和 toLowerCase(): 转换为大写或小写
String upperStr = str.toUpperCase();
String lowerStr = str.toLowerCase();
System.out.println("Uppercase string: " + upperStr); // 输出: Uppercase string: HELLO, WORLD!
System.out.println("Lowercase string: " + lowerStr); // 输出: Lowercase string: hello, world!
}
}
这些示例展示了如何使用 String 类中的常用方法来操作字符串。每个方法都执行特定的任务，并返回修改后的字符串或相关信息。在编程中，这些方法非常有用，因为它们允许你以编程方式操作字符串数据。
二、StringBuilder
1. 定义
StringBuilder 是一个可变的字符序列。与 String 不同，StringBuilder 允许在创建后修改其内容。
2. 常用方法
append(): 将指定的数据追加到此字符序列的末尾。insert(int offset, String str): 将字符串插入此序列的指定位置。delete(int start, int end): 移除此序列的子字符串中的字符。replace(int start, int end, String str): 用指定字符串替换此序列的子字符串。length(): 返回此序列的长度。charAt(int index): 返回此序列中指定索引处的 char 值。substring(int start, int end): 返回一个新的字符串，它是此字符序列的一个子序列。请注意，String 类在 Java 中是不可变的，这意味着你不能直接使用像 append(), insert(), delete(), 或 replace(int, int, String) 这样的方法来修改一个已存在的 String 对象。但是，这些方法在 StringBuilder 和 StringBuffer 类中是可用的，这两个类被设计用来构建和修改字符串。
以下是使用 StringBuilder 的示例，展示了如何使用您提到的这些方法：
public class StringBuilderMethodsExamples {
public static void main(String[] args) {
// 创建一个 StringBuilder 对象
StringBuilder sb = new StringBuilder("Hello");
// 1. append(): 将指定的数据追加到此字符序列的末尾
sb.append(", World!");
System.out.println("Appended string: " + sb.toString()); // 输出: Appended string: Hello, World!
// 2. insert(int offset, String str): 将字符串插入此序列的指定位置
sb.insert(7, "beautiful ");
System.out.println("Inserted string: " + sb.toString()); // 输出: Inserted string: Hello, beautiful World!
// 3. delete(int start, int end): 移除此序列的子字符串中的字符
sb.delete(7, 15);
System.out.println("Deleted string: " + sb.toString()); // 输出: Deleted string: Hello, World!
// 4. replace(int start, int end, String str): 用指定字符串替换此序列的子字符串
sb.replace(7, 12, "Java");
System.out.println("Replaced string: " + sb.toString()); // 输出: Replaced string: Hello, Java!
// 对于 String 类的方法，我们直接使用 String 对象来演示
// 5. length(): 返回此序列的长度
String str = sb.toString();
int length = str.length();
System.out.println("Length: " + length); // 输出: Length: 11
// 6. charAt(int index): 返回此序列中指定索引处的 char 值
char charAtIndex = str.charAt(4);
System.out.println("Character at index 4: " + charAtIndex); // 输出: Character at index 4: ,
// 7. substring(int start, int end): 返回一个新的字符串，它是此字符序列的一个子序列
String substring = str.substring(7, 11);
System.out.println("Substring: " + substring); // 输出: Substring: Java
}
}
在这个示例中，我首先创建了一个 StringBuilder 对象，并使用其方法来修改字符串。然后，我将 StringBuilder 对象转换为 String 对象，并使用 String 类的方法来获取长度、特定索引处的字符和子字符串。请注意，由于 String 类的不可变性，length(), charAt(), 和 substring() 方法返回的都是新的字符串或值，而不是修改原始字符串。
3. StringBuilder内存分析
StringBuilder 对象在堆上分配内存，并且其内容（字符序列）也是动态地在堆上扩展的。由于它是可变的，因此不需要像 String 那样创建新的对象来修改内容。
三、StringJoiner
1. 定义
StringJoiner 是一个用于构建由特定分隔符（delimiter）、前缀（prefix）和后缀（suffix）分隔的字符序列的可变类。
2. 常用方法
add(CharSequence newElement): 添加一个元素。merge(CharSequence delimiter, CharSequence... elements): 合并数组中的元素，并在它们之间添加给定的分隔符。setLength(int newLength): 设置字符序列的长度。toString(): 返回由前缀、分隔符、元素和后缀组成的字符串。StringJoiner 主要用于构建如 CSV（逗号分隔值）或类似格式的字符串。
StringJoiner 是 Java 8 引入的一个类，它位于 java.util 包中，用于构建由特定分隔符、前缀和后缀分隔的字符序列。但是，请注意 StringJoiner 类并没有 merge(CharSequence delimiter, CharSequence... elements) 和 setLength(int newLength) 这两个方法。merge 方法并不是 StringJoiner 的一部分，而 setLength 方法是 StringBuilder 和 StringBuffer 的方法，不适用于 StringJoiner。
以下是基于 StringJoiner 的常用方法 add(CharSequence newElement) 和 toString() 的代码示例：
下滑查看解决方法
import java.util.StringJoiner;
public class StringJoinerExample {
public static void main(String[] args) {
// 创建一个 StringJoiner 对象，使用逗号作为分隔符，并带有前缀 "[" 和后缀 "]"
StringJoiner sj = new StringJoiner(",", "[", "]");
// 使用 add 方法添加元素
sj.add("apple");
sj.add("banana");
sj.add("cherry");
// 使用 toString 方法获取最终的字符串
String result = sj.toString();
System.out.println(result); // 输出: [apple,banana,cherry]
// 假设我们想要合并一个字符串数组，并添加到 StringJoiner 中
// 注意：StringJoiner 没有直接的 merge 方法，但我们可以循环遍历数组并使用 add 方法
String[] fruitsToAdd = {"date", "elderberry"};
for (String fruit : fruitsToAdd) {
sj.add(fruit);
}
// 再次获取最终的字符串
result = sj.toString();
System.out.println(result); // 输出: [apple,banana,cherry,date,elderberry]
// StringJoiner 没有 setLength 方法，因为字符串是不可变的
// 如果你需要截断字符串，你可以在 toString() 之后对字符串进行操作
// 例如，使用 substring 方法
result = result.substring(0, 10); // 截取前10个字符（注意这可能会破坏结构）
System.out.println(result); // 输出可能是: [apple,ban
}
}
在这个示例中，我们创建了一个 StringJoiner 对象，并使用逗号作为分隔符，前缀为 “[” 和后缀为 “]”。然后，我们使用 add 方法添加了几个元素，并使用 toString 方法获取了最终的字符串。接着，我们模拟了一个 “合并” 操作，通过循环遍历一个字符串数组并使用 add 方法将每个元素添加到 StringJoiner 中。最后，我们展示了如何使用 substring 方法来截取字符串（尽管这不是 StringJoiner 的功能，但它是处理字符串长度的一个常见方法）。
作者：代码无疆
