Warum drängen alle auf Ausnahme- / Regex-Lösungen?
Ich kann zwar verstehen, dass die meisten Leute mit try / catch gut zurechtkommen, aber wenn Sie es häufig tun möchten, kann es extrem anstrengend sein.
Was ich hier getan habe, war die Verwendung des regulären Ausdrucks, der parseNumber () -Methoden und der Array-Suchmethode, um festzustellen, welche die effizienteste war. Dieses Mal habe ich nur ganzzahlige Zahlen betrachtet.
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;
}
Die Ergebnisse in Geschwindigkeit, die ich bekam, waren:
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
Haftungsausschluss: Ich behaupte nicht, dass diese Methoden zu 100% optimiert sind, sondern nur zur Demonstration der Daten
Ausnahmen wurden nur dann gewonnen, wenn die Zahl 4 Zeichen oder weniger beträgt und jede Zeichenfolge immer eine Zahl ist. In welchem Fall sollte überhaupt ein Scheck ausgestellt werden?
Kurz gesagt, es ist äußerst schmerzhaft, wenn Sie beim Versuch / Fang häufig auf ungültige Zahlen stoßen, was Sinn macht. Eine wichtige Regel, die ich immer befolge, ist, NIEMALS try / catch für den Programmfluss zu verwenden . Dies ist ein Beispiel dafür.
Interessanterweise ist das einfache if char <0 || > 9 war extrem einfach zu schreiben, leicht zu merken (und sollte in mehreren Sprachen funktionieren) und gewinnt fast alle Testszenarien.
Der einzige Nachteil ist, dass Integer.parseInt () möglicherweise Nicht-ASCII-Zahlen verarbeitet, während dies bei der Array-Suchmethode nicht der Fall ist.
Für diejenigen, die sich fragen, warum ich gesagt habe, dass es einfach ist, sich an das Zeichenarray zu erinnern. Wenn Sie wissen, dass es keine negativen Vorzeichen gibt, können Sie leicht mit etwas davonkommen, das sich wie folgt verdichtet:
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;
Abschließend war ich neugierig auf den Zuweisungsoperator im akzeptierten Beispiel mit allen abgegebenen Stimmen. Hinzufügen in der Zuordnung von
double d = Double.parseDouble(...)
ist nicht nur nutzlos, da Sie den Wert nicht einmal verwenden, sondern verschwendet auch Verarbeitungszeit und erhöht die Laufzeit um einige Nanosekunden (was zu einer Erhöhung der Tests um 100 bis 200 ms führte). Ich kann nicht verstehen, warum das jemand tun würde, da es tatsächlich zusätzliche Arbeit ist, um die Leistung zu reduzieren.
Sie würden denken, das wäre optimiert ... obwohl ich vielleicht den Bytecode überprüfen und sehen sollte, was der Compiler tut. Das erklärt nicht, warum es für mich immer länger war, wenn es irgendwie optimiert ist ... deshalb frage ich mich, was los ist. Als Hinweis: Mit länger meine ich, den Test für 10000000 Iterationen auszuführen und dieses Programm mehrmals (10x +) auszuführen, hat immer gezeigt, dass es langsamer ist.
BEARBEITEN: Ein Test für Character.isDigit () wurde aktualisiert.