හැමෝම ව්‍යතිරේක / රීජෙක්ස් විසඳුම් සඳහා පෙළඹෙන්නේ ඇයි?
බොහෝ අය උත්සාහ කිරීම / අල්ලා ගැනීම භාවිතා කිරීම හොඳ බව මට තේරුම් ගත හැකි අතර, ඔබට එය නිතර කිරීමට අවශ්‍ය නම් ... එය අතිශයින්ම බදු අය කළ හැකිය.
මා මෙහි කළේ වඩාත්ම කාර්යක්ෂම වන්නේ කුමක් දැයි බැලීමට රීජෙක්ස්, පාර්ස්නම්බර් () ක්‍රම සහ අරාව සෙවීමේ ක්‍රමය ගැනීමයි. මෙවර මම පූර්ණ සංඛ්‍යා දෙස බැලුවෙමි.
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;
}
මට ලැබුණු වේගයේ ප්‍රති results ල:
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
වියාචනය: මෙම ක්‍රම 100% ප්‍රශස්ත යැයි මම නොකියමි, ඒවා දත්ත නිරූපණය කිරීම සඳහා පමණි
ව්‍යතිරේකයන් දිනන්නේ අංක 4 ක් හෝ ඊට අඩු නම් පමණක් වන අතර සෑම නූලක්ම සෑම විටම සංඛ්‍යාවක් වේ ... කුමන අවස්ථාවකදී පවා චෙක්පතක් ඇත්තේ ඇයි?
කෙටියෙන් කිවහොත්, ඔබ උත්සාහය / ඇල්ලීම සමඟ නිතර වලංගු නොවන සංඛ්‍යා වලට දුවන්නේ නම් එය අතිශයින්ම වේදනාකාරී වේ. මම සැමවිටම අනුගමනය කරන වැදගත් රීතියක් නම් වැඩසටහන් ප්‍රවාහය සඳහා කිසි විටෙකත් උත්සාහ නොකරන්න . මෙය උදාහරණයක්.
සිත්ගන්නා කරුණ නම් සරල නම් වර්‍ගය <0 || > 9 ලිවීමට අතිශයින්ම සරලයි, මතක තබා ගැනීමට පහසුය (සහ විවිධ භාෂාවලින් වැඩ කළ යුතුය) සහ සියලු පරීක්ෂණ අවස්ථා පාහේ ජය ගනී.
මෙහි ඇති අවාසිය නම් මම අනුමාන කරන්නේ Integer.parseInt () ASCII නොවන සංඛ්‍යා හැසිරවිය හැකි නමුත් අරාව සෙවීමේ ක්‍රමය එසේ නොකරන බවයි.
අරා අරා එකක් මතක තබා ගැනීම පහසු යැයි මා කීවේ ඇයිදැයි කල්පනා කරන අයට, negative ණාත්මක සං signs ා නොමැති බව ඔබ දන්නේ නම්, ඔබට cond නීභවනය වූ දෙයක් සමඟ පහසුවෙන් ගැලවිය හැකිය:
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;
අවසාන සටහනක් ලෙස, පිළිගත් උදාහරණයේ දී සියලු ඡන්ද ඉහළට ඔසවා තැබීමේ ක්‍රියාකරු ගැන මට කුතුහලයක් ඇති විය. පැවරුමට එකතු කිරීම
double d = Double.parseDouble(...)
ඔබ වටිනාකම පවා භාවිතා නොකරන බැවින් එය නිෂ් less ල නොවේ, නමුත් එය සැකසීමේ කාලය නාස්ති කරන අතර ධාවන කාලය නැනෝ තත්පර කිහිපයකින් වැඩි කරයි (එමඟින් පරීක්ෂණ 100-200 ms වැඩි වීමට හේතු විය). කාර්ය සාධනය අඩු කිරීම සඳහා එය අතිරේක වැඩක් බැවින් කිසිවෙකු එසේ කරන්නේ මන්දැයි මට නොපෙනේ.
ඔබ සිතන්නේ එය ප්‍රශස්ත වනු ඇති බවයි ... සමහර විට මම බයිට් කේතය පරීක්ෂා කර සම්පාදකයා කරන්නේ කුමක්දැයි බලන්න. එය කෙසේ හෝ ප්‍රශස්තිකරණය කළත් එය සෑම විටම මට වඩා දිගු ලෙස පෙන්වීමට හේතුව එය පැහැදිලි නොකරයි ... එබැවින් සිදුවන්නේ කුමක්දැයි මම කල්පනා කරමි. සටහනක් ලෙස: දිගින්, මම අදහස් කළේ 10000000 පුනරාවර්තන සඳහා පරීක්ෂණය ධාවනය කිරීම සහ එම වැඩසටහන කිහිප වතාවක් ධාවනය කිරීම (10x +) සෑම විටම එය මන්දගාමී බව පෙන්නුම් කරයි.
සංස්කරණය කරන්න: Character.isDigit () සඳහා පරීක්ෂණයක් යාවත්කාලීන කරන ලදි