Em desenvolvimento de software, é comum encontrar templates que utilizam o formato ${chave} para representar valores dinâmicos. Para processar esses padrões em Java, as expressões regulares (regex) são uma ferramenta poderosa.

1. Construindo o padrão de correspondência

Para identificar a presença de uma ou mais ocorrências de ${chave} em uma string, onde chave cosniste em uma ou mais letras minúsculas, podemos usar a seguinte expressão:

.*\$\{([a-z]+)\}.*

Este padrão verifica se a string contém pelo menos um trecho como ${nome} ou ${valor}.

Se o objetivo for extrair apenas o conteúdo interno das chaves (por exemplo, "nome" de ${nome}), o padrão mais eficiente é:

\$\{([a-z]+)\}

As chaves () definem um grupo de captura, que no Java é acessado via Matcher.group(1).

2. Implementação em Java

A classe Pattern do Java permite compilar a expressão regular uma única vez para melhor performance. A classe Matcher é então utilizada para aplicar o padrão a uma string de entrada e iterar sobre as correspondências encontradas.

Exempplo de código que verifica a existência de parâmetros dinâmicos e os extrai em ordem de aparição, sem duplicatas:

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

public class TemplateUtils {
    private static final Pattern PARAMETER_PATTERN = Pattern.compile("\\$\\{([a-z]+)\\}");

    /**
     * Verifica se o conteúdo contém ao menos um parâmetro no formato ${key}.
     */
    public static boolean hasDynamicParameters(String content) {
        Matcher matcher = PARAMETER_PATTERN.matcher(content);
        return matcher.find();
    }

    /**
     * Extrai todos os parâmetros únicos do conteúdo, mantendo a ordem de primeira aparição.
     */
    public static List<string> extractParameterKeys(String content) {
        Set<string> keysInOrder = new LinkedHashSet<>();
        Matcher matcher = PARAMETER_PATTERN.matcher(content);

        while (matcher.find()) {
            keysInOrder.add(matcher.group(1));
        }
        return new ArrayList<>(keysInOrder);
    }

    // Método para demonstração
    public static void main(String[] args) {
        String template = "Bem-vindo, ${usuario}. Seu pedido ${codigo} está a caminho.";
        
        if (hasDynamicParameters(template)) {
            List<string> parameters = extractParameterKeys(template);
            System.out.println("Parâmetros dinâmicos encontrados:");
            parameters.forEach(System.out::println);
        } else {
            System.out.println("Nenhum parâmetro dinâmico encontrado.");
        }
    }
}</string></string></string>

Compilar a expressão regular com Pattern.compile() fora de loops ou métodos frequentemente chamados é uma boa prática para otimizar a performance. O uso de um LinkedHashSet no método extractParameterKeys garante a unicidade das chaves mantendo sua ordem de inserção.