首页 > Python资料博客日记

【Java字符串相关类知识，字符串构造方法，字符串比较，字符串常见方法，内存

2024-06-06 19:00:05Python资料围观66次

本篇文章分享【Java字符串相关类知识，字符串构造方法，字符串比较，字符串常见方法，内存，对你有帮助的话记得收藏一下，看Python资料网收获更多编程知识

文章目录

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

标签：

上一篇：华为OD机试C卷-- 路口最短时间问题（Java & JS & Python & C）
下一篇：华为OD机试C卷-- 素数之积（Java & JS & Python & C）

点击排行

本站推荐

标签云

Python高手进阶指南

首页 > Python资料博客日记

【Java字符串相关类知识，字符串构造方法，字符串比较，字符串常见方法，内存

文章目录

一、String

1. Java中的数据类型

2. 字符串概述

3. 字符串构造方法

4. 字符串构造内存原理

5. 字符串比较

6. 字符串常见方法

二、StringBuilder

1. 定义

2. 常用方法

3. StringBuilder内存分析

三、StringJoiner

1. 定义

2. 常用方法

相关文章

最新发布

点击排行

本站推荐

标签云

首页 > Python资料 博客日记

【Java字符串相关类知识，字符串构造方法，字符串比较，字符串常见方法，内存

文章目录

一、String

1. Java中的数据类型

2. 字符串概述

3. 字符串构造方法

4. 字符串构造内存原理

5. 字符串比较

6. 字符串常见方法

二、StringBuilder

1. 定义

2. 常用方法

3. StringBuilder内存分析

三、StringJoiner

1. 定义

2. 常用方法

相关文章

最新发布

点击排行

本站推荐

标签云

首页 > Python资料博客日记