Por que todos estão pressionando por soluções de exceção / regex?
Embora eu possa entender que a maioria das pessoas está bem em usar try / catch, se você quiser fazer isso com frequência ... pode ser extremamente desgastante.
O que fiz aqui foi pegar o regex, os métodos parseNumber () e o método de pesquisa de matriz para ver qual era o mais eficiente. Desta vez, eu olhei apenas para números inteiros.
public static boolean isNumericRegex(String str) {
if (str == null)
return false;
return str.matches("-?\\d+");
}
public static boolean isNumericArray(String str) {
if (str == null)
return false;
char[] data = str.toCharArray();
if (data.length <= 0)
return false;
int index = 0;
if (data[0] == '-' && data.length > 1)
index = 1;
for (; index < data.length; index++) {
if (data[index] < '0' || data[index] > '9') // Character.isDigit() can go here too.
return false;
}
return true;
}
public static boolean isNumericException(String str) {
if (str == null)
return false;
try {
/* int i = */ Integer.parseInt(str);
} catch (NumberFormatException nfe) {
return false;
}
return true;
}
Os resultados na velocidade que obtive foram:
Done with: for (int i = 0; i < 10000000; i++)...
With only valid numbers ("59815833" and "-59815833"):
Array numeric took 395.808192 ms [39.5808192 ns each]
Regex took 2609.262595 ms [260.9262595 ns each]
Exception numeric took 428.050207 ms [42.8050207 ns each]
// Negative sign
Array numeric took 355.788273 ms [35.5788273 ns each]
Regex took 2746.278466 ms [274.6278466 ns each]
Exception numeric took 518.989902 ms [51.8989902 ns each]
// Single value ("1")
Array numeric took 317.861267 ms [31.7861267 ns each]
Regex took 2505.313201 ms [250.5313201 ns each]
Exception numeric took 239.956955 ms [23.9956955 ns each]
// With Character.isDigit()
Array numeric took 400.734616 ms [40.0734616 ns each]
Regex took 2663.052417 ms [266.3052417 ns each]
Exception numeric took 401.235906 ms [40.1235906 ns each]
With invalid characters ("5981a5833" and "a"):
Array numeric took 343.205793 ms [34.3205793 ns each]
Regex took 2608.739933 ms [260.8739933 ns each]
Exception numeric took 7317.201775 ms [731.7201775 ns each]
// With a single character ("a")
Array numeric took 291.695519 ms [29.1695519 ns each]
Regex took 2287.25378 ms [228.725378 ns each]
Exception numeric took 7095.969481 ms [709.5969481 ns each]
With null:
Array numeric took 214.663834 ms [21.4663834 ns each]
Regex took 201.395992 ms [20.1395992 ns each]
Exception numeric took 233.049327 ms [23.3049327 ns each]
Exception numeric took 6603.669427 ms [660.3669427 ns each] if there is no if/null check
Isenção de responsabilidade: não estou afirmando que esses métodos estão 100% otimizados, são apenas para demonstração dos dados
Exceções ganhas se e somente se o número tiver 4 caracteres ou menos, e cada string for sempre um número ... nesse caso, por que um cheque?
Em resumo, é extremamente doloroso se você encontrar números inválidos frequentemente com o try / catch, o que faz sentido. Uma regra importante que eu sempre sigo é NUNCA usar try / catch para o fluxo do programa . Este é um exemplo do porquê.
Curiosamente, o simples se char <0 || > 9 foi extremamente simples de escrever, fácil de lembrar (e deve funcionar em vários idiomas) e vence quase todos os cenários de teste.
A única desvantagem é que eu acho que Integer.parseInt () pode lidar com números não ASCII, enquanto o método de pesquisa de matriz não.
Para aqueles que se perguntam por que eu disse que é fácil lembrar a matriz de caracteres, se você sabe que não há sinais negativos, pode facilmente se safar com algo condensado como este:
public static boolean isNumericArray(String str) {
if (str == null)
return false;
for (char c : str.toCharArray())
if (c < '0' || c > '9')
return false;
return true;
Por fim, como nota final, fiquei curioso sobre o operador de atribuição no exemplo aceito com todos os votos. Adicionando na atribuição de
double d = Double.parseDouble(...)
não é apenas inútil, pois você nem usa o valor, mas perde tempo de processamento e aumenta o tempo de execução em alguns nanossegundos (o que leva a um aumento de 100-200 ms nos testes). Não vejo por que alguém faria isso, pois na verdade é um trabalho extra para reduzir o desempenho.
Você pensaria que isso seria otimizado ... embora talvez eu deva verificar o bytecode e ver o que o compilador está fazendo. Isso não explica por que sempre apareceu como mais longo para mim, mas se de alguma forma é otimizado ... portanto, eu me pergunto o que está acontecendo. Como observação: por mais tempo, quero dizer executar o teste para 10000000 iterações e executar esse programa várias vezes (10x +) sempre mostrou que era mais lento.
EDIT: Atualizado um teste para Character.isDigit ()