Dlaczego wszyscy naciskają na rozwiązania wyjątkowe / wyrażenia regularne?
Chociaż rozumiem, że większość ludzi nie ma nic przeciwko używaniu try / catch, jeśli chcesz to robić często ... może to być bardzo obciążające.
To, co zrobiłem tutaj, to wzięcie wyrażenia regularnego, metod parseNumber () i metody przeszukiwania tablicy, aby sprawdzić, która z nich była najbardziej wydajna. Tym razem spojrzałem tylko na liczby całkowite.
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;
}
Wyniki, które uzyskałem, były następujące:
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
Oświadczenie: Nie twierdzę, że te metody są w 100% zoptymalizowane, służą jedynie do demonstracji danych
Wyjątki wygrane wtedy i tylko wtedy, gdy liczba ma 4 znaki lub mniej, a każdy ciąg jest zawsze liczbą ... w takim przypadku, po co w ogóle mieć czek?
Krótko mówiąc, jest to bardzo bolesne, jeśli często próbujesz złapać nieprawidłowe liczby za pomocą try / catch, co ma sens. Ważną zasadą, której zawsze przestrzegam jest NIGDY nie używaj try / catch do przebiegu programu . To jest przykład dlaczego.
Co ciekawe, prosty jeśli char <0 || > 9 było niezwykle łatwe do napisania, łatwe do zapamiętania (i powinno działać w wielu językach) i wygrywa prawie wszystkie scenariusze testowe.
Jedynym minusem jest to, że zgaduję, że Integer.parseInt () może obsługiwać liczby inne niż ASCII, podczas gdy metoda wyszukiwania tablicowego nie.
Dla tych, którzy zastanawiają się, dlaczego powiedziałem, że łatwo jest zapamiętać tablicę znaków, jeśli wiesz, że nie ma żadnych negatywnych znaków, możesz łatwo uciec od czegoś skondensowanego:
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;
Wreszcie, jako ostatnia uwaga, byłem ciekawy operatora przypisania w przyjętym przykładzie z wszystkimi głosami. Dodanie w przypisaniu
double d = Double.parseDouble(...)
jest nie tylko bezużyteczny, ponieważ nawet nie używasz tej wartości, ale marnuje czas przetwarzania i wydłuża czas działania o kilka nanosekund (co doprowadziło do wzrostu testów o 100-200 ms). Nie rozumiem, dlaczego ktoś miałby to zrobić, ponieważ w rzeczywistości jest to dodatkowa praca w celu zmniejszenia wydajności.
Można by pomyśleć, że zostałby zoptymalizowany ... chociaż może powinienem sprawdzić kod bajtowy i zobaczyć, co robi kompilator. To nie tłumaczy, dlaczego zawsze wydawało mi się, że jest dłuższe, jeśli jest w jakiś sposób zoptymalizowane ... dlatego zastanawiam się, co się dzieje. Uwaga: przez dłuższy czas mam na myśli uruchomienie testu dla iteracji 10000000, a wielokrotne uruchomienie tego programu (10x +) zawsze pokazało, że jest wolniejszy.
EDYCJA: Zaktualizowano test dla Character.isDigit ()