Java: Replace a string from multiple replaced strings to multiple substitutes-优快云博客

本文介绍了一个实用的Java工具类，该工具类能够实现从多个待替换字符串到多个替代字符串的批量转换。通过正则表达式的应用，使得字符串的批量替换变得高效且便捷。

Provide helper methods to replace a string from multiple replaced strings to multiple substitutes

import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class StringHelper {
    
    /**
     * This is test method to replace a string from:
     * aaa > zzz
     * \t > /t
     * \r > /r
     * \n > /n
     */
    public static void run()
    {
        
        String[] replacedStrings = new String[] {"aaa", "\t", "\r", "\n"};
        String[] replacements = new String[] {"zzz", "/t", "/r", "/n"};
    
        Pattern pattern = getReplacePattern(replacedStrings);
        
        // The result is "zzza/tb/rc/nd/te/nf"
        System.out.println(replace("aaaa\tb\rc\nd\te\nf", pattern, replacedStrings, replacements));
        
        // The result is "zzza/tb/rc/nd/te/nf/r"
        System.out.println(replace("aaaa\tb\rc\nd\te\nf\r", pattern, replacedStrings, replacements));
    }
    
    /**
     * Return a Pattern instance from a specific replaced string array.
     * @param replacedStrings replaced strings
     * @return a Pattern instance
     */
    public static Pattern getReplacePattern(String[] replacedStrings)
    {
        if (replacedStrings == null || replacedStrings.length == 0) return null;
        
        String regex = "";
        for (String replacedString : replacedStrings)
        {
            if (regex.length() != 0)
            {
                regex = regex + "|";
            }
            regex = regex + "(" + replacedString + ")";
        }
        regex = regex + "";

        return Pattern.compile(regex, Pattern.DOTALL | Pattern.MULTILINE);
    }
    

    /**
     * Replace a string.
     * @param value the string.
     * @param pattern the Pattern instance.
     * @param replacedStrings the replaced string array.
     * @param replacements the replacement array.
     * @return
     */
    public static String replace(String value, Pattern pattern, String[] replacedStrings, String[] replacements)
    {
        if (pattern == null) return value;
        if (replacedStrings == null || replacedStrings.length == 0) return value;
        if (replacements == null || replacements.length == 0) return value;
        
        if (replacedStrings.length != replacements.length) 
        {
            throw new RuntimeException("replacedStrings length must same as replacements length.");
        }
        
        Matcher matcher = pattern.matcher(value);
        StringBuffer buffer = new StringBuffer();
        int lastIndex = 0;
        
        while (matcher.find()) {
            buffer.append(value.subSequence(lastIndex,  matcher.start()));
            lastIndex = matcher.end();

            String group = matcher.group();
             
            for (int i = 0; i < replacedStrings.length; i++)
            {
                if (group.equals(replacedStrings[i]))
                {
                    buffer.append(replacements[i]);
                    break;
                }
            }
         }
         
         buffer.append(value.subSequence(lastIndex, value.length()));
         return buffer.toString();
    }
}

转载于:https://www.cnblogs.com/steven-yang/p/5345296.html