首页 > Python资料 博客日记

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

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

本篇文章分享【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 对象。但是,这些方法在 StringBuilderStringBuffer 类中是可用的,这两个类被设计用来构建和修改字符串。

以下是使用 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 方法是 StringBuilderStringBuffer 的方法,不适用于 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 的功能,但它是处理字符串长度的一个常见方法)。


版权声明:本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若内容造成侵权/违法违规/事实不符,请联系邮箱:jacktools123@163.com进行投诉反馈,一经查实,立即删除!

标签:

相关文章

本站推荐