Estamos implementando um adaptador para o Jaxen (uma biblioteca XPath para Java) que nos permite usar o XPath para acessar o modelo de dados de nosso aplicativo.
Isso é feito implementando classes que mapeiam seqüências de caracteres (passadas do Jaxen para nós) em elementos do nosso modelo de dados. Estimamos que precisaremos de cerca de 100 classes com mais de 1000 comparações de strings no total.
Eu acho que a melhor maneira de fazer isso é simples declarações if / else com as strings escritas diretamente no código - em vez de definir cada strings como uma constante. Por exemplo:
public Object getNode(String name) {
if ("name".equals(name)) {
return contact.getFullName();
} else if ("title".equals(name)) {
return contact.getTitle();
} else if ("first_name".equals(name)) {
return contact.getFirstName();
} else if ("last_name".equals(name)) {
return contact.getLastName();
...No entanto, sempre fui ensinado que não devemos incorporar valores de string diretamente no código, mas criar constantes em vez disso. Isso seria algo como isto:
private static final String NAME = "name";
private static final String TITLE = "title";
private static final String FIRST_NAME = "first_name";
private static final String LAST_NAME = "last_name";
public Object getNode(String name) {
if (NAME.equals(name)) {
return contact.getFullName();
} else if (TITLE.equals(name)) {
return contact.getTitle();
} else if (FIRST_NAME.equals(name)) {
return contact.getFirstName();
} else if (LAST_NAME.equals(name)) {
return contact.getLastName();
...Nesse caso, acho que é uma má ideia. A constante será usada apenas uma vez no getNode()método. Usar as strings diretamente é tão fácil de ler e entender quanto usar constantes e nos poupa a escrever pelo menos mil linhas de código.
Existe alguma razão para definir constantes de string para um único uso? Ou é aceitável usar seqüências de caracteres diretamente?
PS. Antes que alguém sugira o uso de enumerações, prototipamos isso, mas a conversão de enumerações é 15 vezes mais lenta que a simples comparação de cadeias, para que não seja considerada.
Conclusão: As respostas abaixo expandiram o escopo desta pergunta além de apenas constantes de string, então eu tenho duas conclusões:
- Provavelmente, não há problema em usar as seqüências diretamente, em vez de constantes, neste cenário, mas
- Existem maneiras de evitar o uso de strings, o que pode ser melhor.
Então, eu vou tentar a técnica de invólucro que evita seqüências de caracteres completamente. Infelizmente, não podemos usar a instrução switch de cadeia porque ainda não estamos no Java 7. Em última análise, porém, acho que a melhor resposta para nós é tentar cada técnica e avaliar seu desempenho. A realidade é que, se uma técnica for claramente mais rápida, provavelmente a escolheremos, independentemente de sua beleza ou adesão à convenção.
switchrótulos. Use um switch em vez de ifcascatas.