Perché tutti spingono per soluzioni di eccezione / regex?
Anche se riesco a capire che la maggior parte delle persone sta bene usando try / catch, se vuoi farlo frequentemente ... può essere estremamente faticoso.
Quello che ho fatto qui è stato prendere il regex, i metodi parseNumber () e il metodo di ricerca dell'array per vedere quale era il più efficiente. Questa volta, ho solo guardato i numeri interi.
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;
}
I risultati nella velocità che ho ottenuto sono stati:
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
Disclaimer: non sto affermando che questi metodi sono ottimizzati al 100%, sono solo per la dimostrazione dei dati
Eccezioni vinte se e solo se il numero è composto da 4 caratteri o meno, e ogni stringa è sempre un numero ... nel qual caso, perché anche avere un controllo?
In breve, è estremamente doloroso imbattersi frequentemente in numeri non validi con il tentativo / cattura, il che ha senso. Una regola importante che seguo sempre è MAI utilizzare try / catch per il flusso del programma . Questo è un esempio del perché.
È interessante notare che il semplice se char <0 || > 9 è stato estremamente semplice da scrivere, facile da ricordare (e dovrebbe funzionare in più lingue) e vince quasi tutti gli scenari di test.
L'unico aspetto negativo è che suppongo che Integer.parseInt () potrebbe gestire numeri non ASCII, mentre il metodo di ricerca dell'array non lo fa.
Per quelli che si chiedono perché ho detto che è facile ricordare l'array di personaggi uno, se sai che non ci sono segni negativi, puoi facilmente scappare con qualcosa di condensato come questo:
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;
Infine, come nota finale, ero curioso dell'operatore incaricato nell'esempio accettato con tutti i voti in su. Aggiungendo nell'assegnazione di
double d = Double.parseDouble(...)
non è solo inutile poiché non si utilizza nemmeno il valore, ma si spreca il tempo di elaborazione e aumenta il tempo di esecuzione di alcuni nanosecondi (il che ha portato a un aumento di 100-200 ms nei test). Non riesco a capire perché qualcuno dovrebbe farlo dal momento che in realtà è un lavoro extra per ridurre le prestazioni.
Penseresti che sarebbe ottimizzato ... anche se forse dovrei controllare il bytecode e vedere cosa sta facendo il compilatore. Questo non spiega perché mi sia sempre apparso più lungo, anche se in qualche modo è stato ottimizzato ... quindi mi chiedo cosa stia succedendo. Come nota: per più lungo, intendo eseguire il test per 10000000 iterazioni e l'esecuzione di quel programma più volte (10x +) ha sempre mostrato che è più lento.
EDIT: aggiornato un test per Character.isDigit ()