文章目录

一、String1. Java中的数据类型2. 字符串概述3. 字符串构造方法4. 字符串构造内存原理5. 字符串比较6. 字符串常见方法 二、StringBuilder1. 定义2. 常用方法3. StringBuilder内存分析 三、StringJoiner1. 定义2. 常用方法

一、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 的功能，但它是处理字符串长度的一个常见方法）。