Java: Replace a string from multiple replaced strings to multiple substitutes

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();
    }
}