Java String.replace()原理，你真的了解吗？

大家好呀，我是猿java。

String.replace()是我们日常开发中经常用到的一个方法，那么，你有看过其底层的源码实现吗？你知道String.replace()是如何工作的吗？String.replace()的性能到底怎么样？这篇文章我们来深入地分析。

在开始今天的问题之前，让我们先来看一个问题：

String original = "Hello, World!";
// 替换字符
String result = original.replace('World', 'Java');

original.replace('World', 'Java')，是把 original的内容直接修改成Hello, Java了，还是重新生成了一个 Hello, Java的 String并返回？

1. String.replace()是什么？

String.replace()位于java.lang包中，它是 Java中的一个重要方法，用于替换字符串中的某些字符或子字符串。以下String.replace()的源码截图。

String.replace()方法用于替换字符串中的某些字符或子字符串。它有多个重载版本，常见的有：

// 用于替换单个字符
public String replace(char oldChar, char newChar);
// 用于替换子字符串
public String replace(CharSequence target, CharSequence replacement);

下面是一个简单的示例，演示了replace方法的用法：

public class ReplaceExample {
    public static void main(String[] args) {
        String original = "Hello, World!";
        
        // 替换字符
        String replacedChar = original.replace('o', 'a');
        System.out.println(replacedChar); // 输出: "Hella, Warld!"
        
        // 替换子字符串
        String replacedString = original.replace("World", "Java");
        System.out.println(replacedString); // 输出: "Hello, Java!"
    }
}

在上面的例子中，我们演示了如何使用replace方法替换字符和子字符串。需要注意的是，String对象在Java中是不可变的（immutable），因此replace方法会返回一个新的字符串，而不会修改原有字符串。

2. 源码分析

上述示例，我们演示了replace方法的用法，接下来，我们来分析下replace方法的实现原理。

2.1 String的不可变性

Java中的String类是不可变的，这意味着一旦创建了一个String对象，其内容不能被改变。这样的设计有助于提高性能和安全性，尤其在多线程环境下。String源码说明如下：

2.2 replace()工作原理

让我们深入了解replace方法的内部实现。以replace(CharSequence target, CharSequence replacement)为例，以下是其基本流程：

1. 检查目标和替换内容 ：方法首先检查传入的target和replacement是否为null，如果是，则抛出NullPointerException。

2. 搜索目标子字符串：在原始字符串中查找所有符合目标子字符串的地方。

3. 构建新的字符串：基于找到的位置，将原始字符串分割，并用替换字符串进行拼接，生成一个新的字符串。

2.3 源码解析

让我们看一下String类中replace方法的源码（简化版）：

public String replace(char oldChar, char newChar) {
   if (oldChar != newChar) {
      String ret = isLatin1() ? StringLatin1.replace(value, oldChar, newChar)
              : StringUTF16.replace(value, oldChar, newChar);
      if (ret != null) {
         return ret;
      }
   }
   return this;
}



public String replace(CharSequence target, CharSequence replacement) {
   String tgtStr = target.toString();
   String replStr = replacement.toString();
   int j = indexOf(tgtStr);
   if (j < 0) {
      return this;
   }
   int tgtLen = tgtStr.length();
   int tgtLen1 = Math.max(tgtLen, 1);
   int thisLen = length();

   int newLenHint = thisLen - tgtLen + replStr.length();
   if (newLenHint < 0) {
      throw new OutOfMemoryError();
   }
   StringBuilder sb = new StringBuilder(newLenHint);
   int i = 0;
   do {
      sb.append(this, i, j).append(replStr);
      i = j + tgtLen;
   } while (j < thisLen && (j = indexOf(tgtStr, j + tgtLen1)) > 0);
   return sb.append(this, i, thisLen).toString();
}

解析步骤

1. 参数校验 ：首先检查target和replacement是否为null，避免后续操作出现NullPointerException。

2. 查找目标字符串 ：使用indexOf方法查找目标子字符串首次出现的位置。如果未找到，直接返回原字符串。

3. 替换逻辑：

   • 使用StringBuilder来构建新的字符串，这是因为StringBuilder在拼接字符串时效率更高。
   • 通过循环查找所有目标子字符串的位置，并将其替换为替换字符串。
   • 最后，拼接剩余的字符串部分，返回最终结果。

性能考虑

由于String的不可变性，每次修改都会创建新的String对象。如果需要进行大量的字符串替换操作，推荐使用StringBuilder或StringBuffer来提高性能。

三、实际示例演示

接下来，我们将通过几个实际的例子，来更好地理解String.replace()的使用场景和效果。

示例1：替换字符

public class ReplaceCharDemo {
    public static void main(String[] args) {
        String text = "banana";
        String result = text.replace('a', 'o');
        System.out.println(result); // 输出: "bonono"
    }
}

解释 ：将所有的'a'替换为'o'，得到"bonono"。

示例2：替换子字符串

public class ReplaceStringDemo {
    public static void main(String[] args) {
        String text = "I love Java. Java is versatile.";
        String result = text.replace("Java", "Python");
        System.out.println(result); // 输出: "I love Python. Python is versatile."
    }
}

解释 ：将所有的"Java"替换为"Python"，结果如上所示。

示例3：替换多个不同的子字符串

有时，我们可能需要在一个字符串中替换多个不同的子字符串。例如，将文中的标点符号替换为空格：

public class ReplaceMultipleDemo {
    public static void main(String[] args) {
        String text = "Hello, World! Welcome to Java.";
        String result = text.replace(",", " ")
                            .replace("!", " ")
                            .replace(".", " ");
        System.out.println(result); // 输出: "Hello  World  Welcome to Java "
    }
}

解释 ：通过链式调用replace方法，依次将,、!和.替换为空格。

示例4：替换不匹配的情况

public class ReplaceNoMatchDemo {
    public static void main(String[] args) {
        String text = "Hello, World!";
        String result = text.replace("Python", "Java");
        System.out.println(result); // 输出: "Hello, World!"
    }
}

解释 ：由于"Python"在原字符串中不存在，replace方法不会做任何替换，直接返回原字符串。

四、String.replace()的技术架构图

虽然文字描述已能帮助我们理解replace方法的工作原理，但通过一个简化的技术架构图，可以更直观地抓住其核心流程。

+---------------------------+
|        String对象         |
| "Hello, World!"           |
+------------+--------------+
             |
             | 调用replace("World", "Java")
             v
+---------------------------+
|   搜索目标子字符串 "World" |
+------------+--------------+
             |
             | 找到位置 7
             v
+---------------------------+
| 构建新的字符串 "Hello, Java!" |
+---------------------------+
             |
             | 返回新字符串
             v
+---------------------------+
|      新的 String对象      |
| "Hello, Java!"            |
+---------------------------+

图解说明

1. 调用replace方法 ：在原始String对象上调用replace("World", "Java")。

2. 搜索目标 ：方法内部使用indexOf找到"World"的位置。

3. 构建新字符串 ：使用StringBuilder将"Hello, "与"Java"拼接，形成新的字符串"Hello, Java!"。

4. 返回新字符串 ：最终返回一个新的String对象，原始字符串保持不变。

五、总结

通过本文的介绍，相信你对Java中String.replace()方法有了更深入的理解。从基本用法到内部原理，再到实际应用示例，每一步都帮助你全面掌握这个重要的方法。

记住，String的不可变性设计虽然带来了安全性和线程安全性，但在频繁修改字符串时，可能影响性能。因此，合理选择使用String还是StringBuilder，根据具体场景优化代码，是每个Java开发者需要掌握的技能。

希望这篇文章能对你在Java编程的道路上提供帮助。如果有任何疑问或更多的讨论，欢迎在评论区留言！

8. 学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。