Java實現字元串替換

一、基本概念

字元串替換是指替換一段文本中的某些內容為另外一些內容，通常應用在編輯器、網路通信、文本分析等場景中。Java提供了多種方式實現字元串替換，本文將從基本概念、Java提供的API方法、正則表達式、自定義實現四方面對其進行詳細介紹。

二、Java提供的API方法

Java字元串提供了replace、replaceAll、replaceFirst三個方法進行簡單的字元串替換操作。

replace(char oldChar, char newChar)

    /**
     * 返回一個字元串，它是通過用 newChar 替換此字元串中出現的所有 oldChar 得到的。 
     */
    public String replace(char oldChar, char newChar) {
        char[] value = this.value;
        int len = value.length;
        int i = -1;
        while (++i < len) {
            if (value[i] == oldChar)
                break;
        }
        if (i < len) {
            char buf[] = new char[len];
            for (int j = 0; j < i; j++)
                buf[j] = value[j];
            for (; i < len; i++) {
                char c = value[i];
                buf[i] = (c == oldChar) ? newChar : c;
            }
            return new String(buf, true);
        }
        return this;
    }

replace(CharSequence target, CharSequence replacement)

    /**
     * 返回一個新的字元串，它是通過用 newChar 替換此字元串中所有 occurrence 字元串
     * 得到的。 
     */
    public String replace(CharSequence target, CharSequence replacement) {
        if (target == null) {
            throw new NullPointerException("target == null");
        }
        if (replacement == null) {
            throw new NullPointerException("replacement == null");
        }
        String tgtStr = target.toString();
        int tgtLen = tgtStr.length();
        if (tgtLen == 0) {
            StringBuilder sb = new StringBuilder(replacement.length() * (value.length + 2));
            sb.append(replacement);
            for (int i = 0; i < value.length; i++) {
                sb.append(value[i]);
                sb.append(replacement);
            }
            return sb.toString();
        }
        StringBuilder sb = null;
        int i = 0;
        while (i < value.length) {
            int j = indexOf(value, i, tgtStr);
            if (j == -1) {
                break;
            }
            if (sb == null) {
                sb = new StringBuilder(value.length + 16 * tgtLen);
            }
            sb.append(value, i, j-i);
            sb.append(replacement);
            i = j + tgtLen;
        }
        if (sb == null) {
            return this;
        }
        sb.append(value, i, value.length- i);
        return sb.toString();
    }

replaceAll(String regex, String replacement)

    /**
     * 使用給定的字面值替換此字元串中所有匹配字面值目標序列的子字元串。
     */
    public String replaceAll(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceAll(replacement);
    }

replaceFirst(String regex, String replacement)

    /**
     * 使用給定的字面值替換此字元串匹配給定的正則表達式的第一個子字元串。
     */
    public String replaceFirst(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
    }

三、正則表達式

在Java中，使用正則表達式進行複雜的字元串替換操作。具體步驟如下：

1、定義Pattern對象

Pattern類是正則表達式的編譯表示，給定一個正則表達式，可以使用Pattern.compile方法生成一個Pattern對象。

    Pattern pattern = Pattern.compile("Hello");  //定義一個模式

2、定義Matcher對象

Matcher類是用於匹配字元串的對象，給定待匹配的字元串，使用Pattern.matcher方法生成一個Matcher對象。

    Matcher matcher = pattern.matcher("Hello Java"); //定義一個匹配者
    System.out.println(matcher.find());  //true

3、執行替換操作

Matcher類提供了replaceFirst、replaceAll、appendReplacement和appendTail等方法進行替換操作。

    String newStr = matcher.replaceAll("Hi");
    System.out.println(newStr); //Hi Java

四、自定義實現

除了Java自帶的API和正則表達式外，我們也可以自定義實現字元串替換。

    public static String replace(String str, String searchStr, String replaceStr) {
        StringBuilder sb = new StringBuilder();
        int index = 0;
        while (true) {
            int i = str.indexOf(searchStr, index);
            if (i == -1) {
                sb.append(str, index, str.length());
                break;
            }
            sb.append(str, index, i);
            sb.append(replaceStr);
            index = i + searchStr.length();
        }
        return sb.toString();
    }

總結

本文介紹了Java實現字元串替換的基本概念、Java提供的API方法、正則表達式、自定義實現四個方面，並給出了相應代碼示例。學習完本文可以更好地掌握Java字元串替換的基本知識。