Java string problem: replacing specific part of a string

Instead of encoding the type of the data (email vs phone number) and the replacement key into strings, I would put the data into separate variables and ues data structures like Map:

Map<String, String> tel = Map.of("Anna", "+3456", "Shawn", "+1234");
Map<String, String> mail = Map.of("Peter", "[email protected]", "Shawn", "[email protected]");
String t = replacement(a, tel, mail);

The replacement function could use a regular expression to find the substrings that match the key words you want to replace [something] and {something}. It would check which one it found, and add a replacement using the telephone or email it finds in the map data structure.

private static String replacement(String a, Map<String, String> tel, Map<String, String> mail) {
    Pattern compile = Pattern.compile("\\{(.*?)\\}|\\[(.*?)\\]");
    Matcher matcher = compile.matcher(a);
    StringBuilder sb = new StringBuilder();

    // Find substrings matching {something} and [something]
    while (matcher.find()) {
        String matched = matcher.group(0);

        // Which was it, { or [ ?
        if (matched.charAt(0) == '{') {
            // Email. Replace from "mail"
            String emailAddress = mail.getOrDefault(matcher.group(1), matched);
            matcher.appendReplacement(sb, emailAddress);
        } else if (matched.charAt(0) == '[') {
            // Telephone. Replace from "tel"
            String phoneNumber = tel.getOrDefault(matcher.group(2), matched);
            matcher.appendReplacement(sb, phoneNumber);
        }
    }
    matcher.appendTail(sb);
    return sb.toString();
}

Handling of strings in a specified format is done best using regular expressions. You define a specified pattern and after you find a part matching your pattern, you can replace it or analyze further.

It's best to write your code to make it easily extensible. For example - if a new contact form is added (home address, fax, business phone number), it should be easy to handle it in the code. Your solution makes it harder to resolve such problems as a whole new if branch is required and it's easy to make a mistake, it also makes the code less readable.

When dealing with a kind of dictionary (like your input String array), it's worth using a Map as it makes the processing faster and the code more readable. When a constant values are present, it's worth to define them too - as constants or enum values. Also - Java allows for writing more functional and more readable, functional-style code instead of nested for-eaches - it's worth using those features (JDK8+).

Please, find the code snippet below and a whole project with tests comparing your solution to mine on GitHub - you can view it there or clone the repository and verify the code yourself:

// we can simply add new contact types and their matchers using the constant below
private static final Map<Pattern, ContactType> CONTACT_PATTERNS = Map.of(
        Pattern.compile("\\[(\\S+)]"), ContactType.TEL,
        Pattern.compile("\\{(\\S+)}"), ContactType.MAIL
);

@Override
public String replace(String input, String[] dictionary) {
    // we're mapping the dictionary to make it easier to use and more readable (also in debugging)
    Map<ContactType, Map<String, String>> contactTypeToNameToValue =
            Arrays.stream(dictionary)
                  .map(entry -> entry.split(" ")) // dictionary entry is split by ' ' character
                  .collect(groupingBy(entry -> ContactType.fromString(entry[0]), // first split part is the contact type
                                      toMap(entry -> entry[1], // second part is the person's name
                                            entry -> entry[2]))); // third part is the contact value
    String output = input;
    for (Map.Entry<Pattern, ContactType> entry : CONTACT_PATTERNS.entrySet()) {
        Pattern pattern = entry.getKey();
        ContactType contactType = entry.getValue();
        output = pattern.matcher(output)
                        .replaceAll(matchResult -> {
                            String name = matchResult.group(1);
                            // we search our dictionary and get value from it or get the original value if nothing matches given name
                            return Optional.ofNullable(contactTypeToNameToValue.get(contactType))
                                           .map(nameToValue -> nameToValue.get(name))
                                           .orElseGet(matchResult::group);
                        });
    }
    return output;
}

public enum ContactType {
    TEL,
    MAIL;

    private static ContactType fromString(String value) {
        return Arrays.stream(values())
                     .filter(enumValue -> enumValue.name().equalsIgnoreCase(value))
                     .findFirst()
                     .orElseThrow(RuntimeException::new);
    }
}