【一步一步了解Java系列】：认识String类

最新推荐文章于 2024-11-01 14:48:20 发布

Gu Gu Study

最新推荐文章于 2024-11-01 14:48:20 发布

阅读量1.3k

点赞数 52

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2302_81249757/article/details/139728022

版权

看到这句话的时候证明：此刻你我都在努力
加油陌生人
微信图片编辑_20240229212205.png

个人主页：Gu Gu Study
专栏：一步一步了解Java

喜欢的一句话：常常会回顾努力的自己，所以要为自己的努力留下足迹

喜欢的话可以点个赞谢谢了。
作者：小闭

String在Java中是一个类，平常我们存储字符串时也是储存在这个类型中的，但是Java创建Strring类肯定不仅仅让我们储存字符串而已，他也为我们提供了许多成员方法。接下来就让我们来学习一下。

String的构造

字符串的构造有挺多的，现在我就列出比较常用的三种构造方式：
以下是三种构造方式：

使用常量串进行构造
使用new关键字进行构造
使用字符串进行构造

public class Test {
    public static void main(String[] args) {
        //使用常量串进行构造
        String s1="hehe";

        //使用new关键字进行构造
        String s2=new String("hehe");

       //使用字符串进行构造
        char[] arr={'h','e','h','e'};
        String s3=new String(arr);

    }



}

注意：String是一个引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下：在现在的jdk中是一个byte类型的数组进行储存的。

String 的比较

在Java中String中，==的比较对于不同类型的数据比较方式是不同的，对于基本类型是比较其中的值是否相等，对于引用类型是进行比较引用的地址是否相等。当然如果用常量字符串进行构造那么其地址是一样的，也就是两个用常量字符串构造的字符串成员变量他们是相等的。

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 10;
// 对于基本类型变量，==比较两个变量中存储的值是否相同
        System.out.println(a == b); // false
        System.out.println(a == c); // true
// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("world");
        String s4 = s1;
        String s5 = "hehe";    //字符串构造的方法构造字符串
        String s6 = "hehe";
        System.out.println(s1 == s2); // false
        System.out.println(s2 == s3); // false
        System.out.println(s1 == s4); // true
        System.out.println(s5 == s6); // true
        
    }

那么使用什么比较方法可以比较里面的内容呢？这时我们就要引入一个方法了equals，这是字符串自带的一个比较方法。那接下来我们就看看如何使用吧。

public class Test {

    String s1=new String("hehe");
    String s2=new String("haha");
    String s3=new String("hehe");
    String s4=s1;

    public static void main(String[] args) {
        Test t=new Test();
        System.out.println(t.s1.equals(t.s2));

        System.out.println(t.s1.equals(t.s4));

        System.out.println(t.s1.equals(t.s3));

        System.out.println(t.s1==t.s3);


    }



}

equals是比较字符串里面的内容的，而不是比较地址所以有了以上的结果。

字符串的查找

大家在了解了一定的字符串知识后可能也想到了一个问题。那就是字符串能不能查找某个字符所在的位置呢？答案肯定是可以的。这时我们就又需要到String类自带的方法了。

Java 中的 String 类提供了多种查找方法，这些方法可以用于在字符串中查找子字符串、字符或者模式。以下是一些常用的查找方法：

indexOf(int ch) - 返回指定字符 ch 在字符串中首次出现的索引。
indexOf(int ch, int fromIndex) - 从 fromIndex 位置开始搜索，返回指定字符 ch 在字符串中首次出现的索引。
indexOf(String str) - 返回子字符串 str 在字符串中首次出现的索引。
indexOf(String str, int fromIndex) - 从 fromIndex 位置开始搜索，返回子字符串 str 在字符串中首次出现的索引。
lastIndexOf(int ch) - 返回指定字符 ch 在字符串中最后一次出现的索引。
lastIndexOf(int ch, int fromIndex) - 从 fromIndex 位置开始反向搜索，返回指定字符 ch 在字符串中最后一次出现的索引。
lastIndexOf(String str) - 返回子字符串 str 在字符串中最后一次出现的索引。
lastIndexOf(String str, int fromIndex) - 从 fromIndex 位置开始反向搜索，返回子字符串 str 在字符串中最后一次出现的索引。
contains(CharSequence s) - 判断字符串是否包含序列 s。
startsWith(String prefix) - 判断字符串是否以指定前缀 prefix 开始。
startsWith(String prefix, int toffset) - 从指定索引 toffset 开始，判断字符串是否以指定前缀 prefix 开始。
endsWith(String suffix) - 判断字符串是否以指定后缀 suffix 结束。

这些方法在处理字符串时非常有用，可以根据需要选择适当的方法来进行字符串的查找操作。

因为函数太多就不一一示例了，就简单给大家简单使用几个函数。

public class Test1 {
    String s1="holle world";
    String s2="this is a person";

    public static void main(String[] args) {
        Test1 t=new Test1();
        System.out.println(t.s1.indexOf("w", 2));
        System.out.println(t.s1.indexOf("w", 7));
        System.out.println(t.s1.lastIndexOf("w",2));
        System.out.println(t.s1.lastIndexOf("w"));
        System.out.println(t.s1.contains("holle "));


    }
}

如上就是代码的运行结果。

那如果我们想要取出字符串中下标为n的字符，那么这时我们就需要到另一个字符串方法了。那就是
char charAt( int n);

public class Test1 {
    String s1="holle world";
    String s2="this is a person";

    public static void main(String[] args) {
        Test1 t=new Test1();
        System.out.println(t.s1.charAt(6));
    }

字符串的转化

String类也包含了方法转化为其它类型，当然其它类型也是可以转化成字符串。接下来我们看一下。
在Java中，String类提供了一个静态方法valueOf()，它可以将各种类型转换为String类型。这个方法非常通用，适用于原始数据类型、对象、数组等。以下是一些使用String.valueOf()方法的例子：

原始数据类型：可以直接将原始类型（如int, double等）转换为String。

int num = 10;
String numStr = String.valueOf(num);

double d = 3.14;
String dStr = String.valueOf(d);

对象：如果对象是null，String.valueOf(null)将返回"null"字符串。对于非null对象，valueOf()将调用对象的toString()方法来获取其字符串表示。

Object obj = new Object();
String objStr = String.valueOf(obj); // 调用obj的toString()方法

String nullStr = String.valueOf(null); // 返回"null"

数组：String.valueOf()可以用于将数组转换为字符串，但不会像Arrays.toString()那样提供友好的数组格式。它只是简单地调用数组的toString()方法。

int[] array = {1, 2, 3};
String arrayStr = String.valueOf(array); // 返回"[I@15aeb7ab"（示例）

集合：对于集合类型，String.valueOf()会调用集合的toString()方法。

List<String> list = Arrays.asList("Hello", "World");
String listStr = String.valueOf(list); // 返回"[Hello, World]"

枚举：枚举类型也可以使用String.valueOf()转换为字符串。

enum Color { RED, GREEN, BLUE }
String colorStr = String.valueOf(Color.RED); // 返回"RED"

字符串字面量：对于字符串字面量，String.valueOf()将直接返回该字符串。

String literal = "Hello, World!";
String str = String.valueOf(literal); // 返回"Hello, World!"

String.valueOf()方法是一个方便的工具，可以用于将几乎所有类型转换为字符串，但它不会对数组或集合进行特殊格式化，只会调用它们的toString()方法。如果需要更友好的格式化输出，可能需要使用其他方法，如Arrays.toString()或自定义的格式化逻辑。

public class Test {
    String s1 = "hello world";

    public static void main(String[] args) {
        Test t = new Test();

// 数字转字符串
        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);
        String s4 = String.valueOf(new Student("Hanmeimei", 18));
        System.out.println(s1);
        System.out.println(s2);

        System.out.println(s3);
        System.out.println(s4);
        System.out.println();

       
// 字符串转数字
// 注意：Integer、Double等是Java中的包装类型
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1);
        System.out.println(data2);
    }
}

String类中的替换和截取方法

在Java中，String 类提供了多种方法来替换字符串中的字符或子串，以及截取字符串的一部分。以下是一些常用的字符串操作方法：
替换方法：

replace(char oldChar, char newChar)：替换字符串中的所有指定字符。

String str = "hello world";
String replaced = str.replace('o', 'e'); // "hellE werd"

replace(CharSequence target, CharSequence replacement)：替换字符串中所有匹配的子串。

String str = "hello world";
String replaced = str.replace("world", "Java"); // "hello Java"

replaceAll(String regex, String replacement)：使用正则表达式来替换字符串中的匹配项。

String str = "hello world";
String replaced = str.replaceAll("\\w+", "X"); // "X X"

replaceFirst(String regex, String replacement)：使用正则表达式替换字符串中的第一个匹配项。

String str = "hello world";
String replaced = str.replaceFirst("\\w+", "X"); // "X world"

截取方法：

substring(int beginIndex)：从指定位置开始截取到字符串末尾。

String str = "hello world";
String sub = str.substring(6); // "world"

substring(int beginIndex, int endIndex)：截取字符串的一部分，从beginIndex开始到endIndex - 1结束。

String str = "hello world";
String sub = str.substring(0, 5); // "hello"

charAt(int index)：获取字符串中指定位置的字符。

String str = "hello world";
char ch = str.charAt(0); // 'h'

split(String regex)：使用正则表达式来分割字符串，返回一个字符串数组。

String str = "hello,world";
String[] parts = str.split(","); // ["hello", "world"]

substringBefore(String delimiter) 和 substringAfter(String delimiter)：根据指定的分隔符截取字符串。

String str = "hello-world";
String before = str.substringBefore("-"); // "hello"
String after = str.substringAfter("-"); // "world"

substringTrimmed()：截取字符串，同时去除首尾的空白字符。

String str = "  hello world  ";
String trimmed = str.substringTrimmed(); // "hello world"

请注意，String 类在Java中是不可变的，这意味着所有这些操作都会返回一个新的字符串实例，而不会修改原始字符串。

spilt方法详解
相信大家用过split方法用空格（“ ”）后有时会出现有空字符的元素，那么这是为什么呢？，这就需要我们好好了解一下，split这个方法了。在传给它的参数是“ ”时会怎么分割的呢？

基本分割：如果字符串中包含空格，split() 会按照空格分割字符串。

String str = "hello world";
String[] parts = str.split(" "); // 使用单个空格作为分隔符
// parts 将是 ["hello", "world"]

忽略连续空格： split() 方法默认情况下不会忽略连续的空格。如果字符串中有连续的空格，它们将导致数组中出现空字符串。

String str = "hello   world";
String[] parts = str.split(" "); // 将返回 ["hello", "", "", "world"]

字符串首尾空格： split() 方法不会自动去除字符串首尾的空格。如果需要去除这些空格，你需要在分割前使用 trim() 方法。

String str = " hello world ";
String[] parts = str.trim().split(" "); // 先去除首尾空格，然后分割
// parts 将是 ["hello", "world"]

分割后去除空白：如果你想要去除分割后数组元素的首尾空白，可以在分割后对每个元素使用 trim() 方法。

String str = " hello world ";
String[] parts = str.split(" ");
for (int i = 0; i < parts.length; i++) {
    parts[i] = parts[i].trim(); // 去除每个元素的首尾空白
}
// parts 将是 ["hello", "world"]

使用正则表达式分割：如果你想要更灵活地处理空格，比如同时忽略多个连续空格和首尾空格，你可以使用正则表达式 \s+ 来代替单个空格。

String str = " hello world ";
String[] parts = str.trim().split("\\s+"); // 使用正则表达式来分割
// parts 将是 ["hello", "world"]

空字符串：如果原始字符串是空字符串或者只包含空格，split(" ") 将返回一个包含单个空字符串的数组。

String str = " ";
String[] parts = str.split(" "); // 将返回 [""]

null 值：如果输入的字符串是 null，使用 split(" ") 将抛出 NullPointerException。

split() 方法返回的数组大小取决于字符串中空格的数量，包括连续的空格。如果需要忽略连续空格或首尾空格，你可能需要使用 trim() 和正则表达式 \s+ 的组合。

StringBuffer和StringBuilder
StringBuffer 是Java中一个线程安全的可变字符串类。它是 AbstractStringBuilder 类的一个具体实现，并且扩展了 CharSequence 接口。由于其线程安全性，StringBuffer 在多线程环境中经常被使用，以避免多个线程同时修改字符串时发生的问题。
以下是 StringBuffer 的一些主要特点和用法：

线程安全： StringBuffer 类中的所有方法都是同步的，这意味着它可以在多线程环境中安全使用，而不需要额外的同步措施。
可变字符串：与 String 类不同，StringBuffer 允许修改字符串内容，如插入、删除或替换字符。
容量自动增长： StringBuffer 内部维护了一个容量足够大的字符数组来存储字符串。如果字符串增长超出了当前容量，StringBuffer 会自动增长其内部数组。
常用方法：
- append(Object obj)：将对象的字符串表示追加到 StringBuffer 的末尾。
- insert(int offset, Object obj)：在指定位置插入对象的字符串表示。
- delete(int start, int end)：删除从 start 到 end - 1 之间的字符。
- reverse()：反转 StringBuffer 中的字符顺序。
- substring(int start) 和 substring(int start, int end)：返回 StringBuffer 的子字符串。
- capacity()：返回当前分配给 StringBuffer 的容量。
- ensureCapacity(int minimumCapacity)：确保 StringBuffer 的容量至少为指定的最小容量。
- toString()：返回 StringBuffer 的当前字符串表示。
性能考虑：由于同步带来的开销，StringBuffer 的性能可能不如 StringBuilder（非线程安全的可变字符串类）。因此，如果你不需要线程安全，可以考虑使用 StringBuilder。
示例代码：

StringBuffer sb = new StringBuffer("Hello");
sb.append(" World"); // "Hello World"
sb.insert(5, " there"); // "Hello there World"
sb.delete(5, 11); // "Hello World"
sb.reverse(); // "dlroW olleH"
System.out.println(sb.toString()); // 输出 "dlroW olleH"

请注意，StringBuffer 是Java 1.0 引入的，随着Java的发展，一些新的API和特性可能已经出现，但 StringBuffer 仍然是处理多线程字符串操作的可靠选择。

StringBuilder 是Java中一个可变的字符串类，与 StringBuffer 类似，但它不是线程安全的。这意味着 StringBuilder 适合在单线程环境中使用，因为它的性能比 StringBuffer 更高，因为它没有同步的开销。
以下是 StringBuilder 的一些主要特点和用法：

非线程安全： StringBuilder 不包含同步机制，因此在单线程环境中使用时，性能优于 StringBuffer。
可变字符串： StringBuilder 允许对字符串进行修改，包括插入、删除、替换和追加操作。
容量自动增长：与 StringBuffer 类似，StringBuilder 内部维护了一个字符数组，如果字符串增长超出当前容量，它会自动增长。
常用方法：
- append(Object obj)：将对象的字符串表示追加到 StringBuilder 的末尾。
- insert(int index, Object obj)：在指定位置插入对象的字符串表示。
- delete(int start, int end)：删除从 start 到 end - 1 之间的字符。
- reverse()：反转 StringBuilder 中的字符顺序。
- substring(int start) 和 substring(int start, int end)：返回 StringBuilder 的子字符串。
- capacity()：返回当前分配给 StringBuilder 的容量。
- ensureCapacity(int minimumCapacity)：确保 StringBuilder 的容量至少为指定的最小容量。
- toString()：返回 StringBuilder 的当前字符串表示。
性能考虑：由于 StringBuilder 不是线程安全的，所以在多线程环境中使用时，需要额外的同步措施，或者考虑使用 StringBuffer。
示例代码：

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World"); // "Hello World"
sb.insert(5, " there"); // "Hello there World"
sb.delete(5, 11); // "Hello World"
sb.reverse(); // "dlroW olleH"
System.out.println(sb.toString()); // 输出 "dlroW olleH"