কোনও স্ট্রিং পার্স করার আগে এটি একটি নম্বর ছিল কিনা আপনি কীভাবে পরীক্ষা করবেন?
Integer.parseInt()
মোবাইল নম্বরগুলি বিশ্লেষণে ব্যর্থ হবে NumberFormatException
।
কোনও স্ট্রিং পার্স করার আগে এটি একটি নম্বর ছিল কিনা আপনি কীভাবে পরীক্ষা করবেন?
Integer.parseInt()
মোবাইল নম্বরগুলি বিশ্লেষণে ব্যর্থ হবে NumberFormatException
।
উত্তর:
সঙ্গে এ্যাপাচি কমন্স ল্যাঙ 3.5 এবং উপরোক্ত: NumberUtils.isCreatable
বা StringUtils.isNumeric
।
সঙ্গে এ্যাপাচি কমন্স ল্যাঙ 3.4 এবং নীচের: NumberUtils.isNumber
বা StringUtils.isNumeric
।
আপনি খালি স্ট্রিংগুলির জন্য StringUtils.isNumericSpace
যা প্রত্যাবর্তন true
করে এবং স্ট্রিংয়ের অভ্যন্তরীণ স্পেসগুলি উপেক্ষা করে তাও আপনি ব্যবহার করতে পারেন । আর একটি উপায় NumberUtils.isParsable
যা জাভা অনুসারে নম্বরটি পার্সেবল হয় তা মূলত যাচাই করা হয় use (লিঙ্কযুক্ত জাভাডোকগুলিতে প্রতিটি পদ্ধতির বিশদ উদাহরণ রয়েছে))
StringUtils.isNumeric()
সম্ভবত এখানে উপযুক্ত হবে না যেহেতু এটি কেবলমাত্র যদি স্ট্রিংটি সংখ্যার ক্রম হয় তা পরীক্ষা করে। দশমিক দশক, গ্রুপ বিভাজনকারী ইত্যাদির সংখ্যার জন্য বেশিরভাগ ইনটগুলির পক্ষে ঠিক আছে তবে
StringUtils
নেতৃস্থানীয় লক্ষণগুলি সমর্থন করে না তবে আপনার পরীক্ষা করা উচিত NumberUtils.isCreatable
, এটি নেতিবাচকগুলি সঠিকভাবে সমর্থন করে।
এটি সাধারণত একটি সাধারণ ব্যবহারকারী-সংজ্ঞায়িত ফাংশন (অর্থাত রোল-আপনার নিজের "isNumeric" ফাংশন) দিয়ে সম্পন্ন হয়।
কিছুটা এইরকম:
public static boolean isNumeric(String str) {
try {
Double.parseDouble(str);
return true;
} catch(NumberFormatException e){
return false;
}
}
তবে, যদি আপনি এই ফাংশনটিকে অনেক কল করে থাকেন এবং আপনি সংখ্যা না পাওয়ার কারণে অনেকগুলি চেক ব্যর্থ হওয়ার প্রত্যাশা করেন তবে এই ব্যবস্থার পারফরম্যান্স দুর্দান্ত হবে না, যেহেতু আপনি প্রতিটি ব্যর্থতার জন্য ছুঁড়ে দেওয়া ব্যতিক্রমগুলির উপর নির্ভর করছেন, যা মোটামুটি ব্যয়বহুল অপারেশন।
বিকল্প পদ্ধতির সংখ্যা হবার জন্য বৈধতা যাচাই করার জন্য নিয়মিত ভাব প্রকাশ করা হতে পারে:
public static boolean isNumeric(String str) {
return str.matches("-?\\d+(\\.\\d+)?"); //match a number with optional '-' and decimal.
}
উপরের রেগেক্স মেকানিজমটি সম্পর্কে সতর্ক থাকুন, যদিও এটি ব্যর্থ হবে যদি আপনি অ-আরবি অংক ব্যবহার করেন (অর্থাত্ 0 থেকে 9 এর মধ্যে অন্যান্য সংখ্যা)। এটি কারণ RegEx এর "\ d" অংশটি কেবল [0-9] এর সাথে মিলবে এবং কার্যকরভাবে আন্তর্জাতিকভাবে সংখ্যাগতভাবে সচেতন নয়। (এটি নির্দেশ করার জন্য ওরেগনহোস্টকে ধন্যবাদ!)
বা অন্য বিকল্পটি জাভা-এর অন্তর্নির্মিত জাভা.টেক্সট.নাম্বারফর্ম্যাট অবজেক্টটি ব্যবহার করে স্ট্রিংকে বিশ্লেষণের পরে পার্সার অবস্থানটি স্ট্রিংয়ের শেষে রয়েছে কিনা তা দেখতে। যদি এটি হয় তবে আমরা ধরে নিতে পারি যে পুরো স্ট্রিংটি সংখ্যাসূচক:
public static boolean isNumeric(String str) {
NumberFormat formatter = NumberFormat.getInstance();
ParsePosition pos = new ParsePosition(0);
formatter.parse(str, pos);
return str.length() == pos.getIndex();
}
.
আপনার রেজেক্সের মধ্যে কোনও দশমিক বিভাজক চরিত্র নয়, কোনও অক্ষরের সাথে মিলবে।
আপনি যদি অ্যান্ড্রয়েডে থাকেন তবে আপনার ব্যবহার করা উচিত:
android.text.TextUtils.isDigitsOnly(CharSequence str)
এটি সহজ রাখুন । বেশিরভাগই "পুনরায় প্রোগ্রাম" করতে পারেন (একই জিনিস)।
.
,-
জাভা 8 লাম্বদা এক্সপ্রেশন।
String someString = "123123";
boolean isNumeric = someString.chars().allMatch( Character::isDigit );
যেহেতু @ ক্রেইগটিপি তার দুর্দান্ত উত্তরে উল্লেখ করেছে, আমারও স্ট্রিংটি সংখ্যাসূচক কিনা তা পরীক্ষা করতে ব্যতিক্রমগুলি ব্যবহার করার ক্ষেত্রে একই রকম পারফরম্যান্স উদ্বেগ রয়েছে। সুতরাং আমি স্ট্রিং বিভক্ত করা এবং ব্যবহার শেষ java.lang.Character.isDigit()
।
public static boolean isNumeric(String str)
{
for (char c : str.toCharArray())
{
if (!Character.isDigit(c)) return false;
}
return true;
}
জাভাডোকের মতে ,Character.isDigit(char)
নন-ল্যাটিন অঙ্কগুলি সঠিকভাবে স্বীকৃতি দেবে। পারফরম্যান্স-ভিত্তিক, আমি মনে করি একটি সাধারণ এন তুলনা সংখ্যা যেখানে এন স্ট্রিংয়ের অক্ষরের সংখ্যা হ'ল রেগেক্স ম্যাচিংয়ের তুলনায় আরও গণনামূলকভাবে দক্ষ হবে।
আপডেট: মন্তব্যটিতে জিন-ফ্রানসোইস কর্পেট দ্বারা নির্দেশিত হিসাবে, উপরের কোডটি কেবল ইতিবাচক পূর্ণসংখ্যাকে বৈধতা দেবে, যা আমার ব্যবহারের বেশিরভাগ ক্ষেত্রেই অন্তর্ভুক্ত। নীচে আপডেট করা কোড যা আপনার সিস্টেমে ব্যবহৃত ডিফল্ট লোকেল অনুসারে দশমিক সংখ্যাগুলি সঠিকভাবে বৈধ করে, এই ধারণাটি সহ যে দশমিক বিভাজকটি কেবল একবার স্ট্রিং-এ আসে।
public static boolean isStringNumeric( String str )
{
DecimalFormatSymbols currentLocaleSymbols = DecimalFormatSymbols.getInstance();
char localeMinusSign = currentLocaleSymbols.getMinusSign();
if ( !Character.isDigit( str.charAt( 0 ) ) && str.charAt( 0 ) != localeMinusSign ) return false;
boolean isDecimalSeparatorFound = false;
char localeDecimalSeparator = currentLocaleSymbols.getDecimalSeparator();
for ( char c : str.substring( 1 ).toCharArray() )
{
if ( !Character.isDigit( c ) )
{
if ( c == localeDecimalSeparator && !isDecimalSeparatorFound )
{
isDecimalSeparatorFound = true;
continue;
}
return false;
}
}
return true;
}
toCharArray()
স্ট্রিং অবজেক্টে অ্যারের একটি অনুলিপি তৈরি করবে কারণ স্ট্রিংগুলি পরিবর্তনযোগ্য নয়। সম্ভবত charAt(int index)
স্ট্রিং অবজেক্টে পদ্ধতিটি ব্যবহার করতে আরও দ্রুত ।
StringIndexOutOfBoundsException
যখন দৈর্ঘ্য 0. সঙ্গে একটি স্ট্রিং পাস সংশোধন করা যেতে পারেif(str.length() == 0) return false;
Google এর পেয়ারা গ্রন্থাগার এই কাজ করতে একটি চমৎকার সাহায্যকারী পদ্ধতি প্রদান করে: Ints.tryParse
। আপনি এটি পছন্দ মতো ব্যবহার করেন তবে স্ট্রিংটি কোনও বৈধ পূর্ণসংখ্যায় পার্স না করলে এটি একটি ব্যতিক্রম Integer.parseInt
ছোঁড়ার null
পরিবর্তে ফিরে আসে । মনে রাখবেন যে এটি পূর্ণসংখ্যার পূর্বাবস্থায় ফিরে আসে, না আন্তঃ, সুতরাং আপনাকে এটিকে পূর্বে ইনট / অটোবক্সে রূপান্তর করতে হবে।
উদাহরণ:
String s1 = "22";
String s2 = "22.2";
Integer oInt1 = Ints.tryParse(s1);
Integer oInt2 = Ints.tryParse(s2);
int i1 = -1;
if (oInt1 != null) {
i1 = oInt1.intValue();
}
int i2 = -1;
if (oInt2 != null) {
i2 = oInt2.intValue();
}
System.out.println(i1); // prints 22
System.out.println(i2); // prints -1
তবে বর্তমান প্রকাশ হিসাবে - পেয়ারা আর 11 - এটি এখনও @ বেটা চিহ্নিত রয়েছে।
আমি এটি বেঞ্চমার্ক করি নি। উত্স কোডের দিকে তাকিয়ে প্রচুর পরিমাণে বিচক্ষণতা যাচাইয়ের থেকে কিছু ওভারহেড রয়েছে তবে শেষ পর্যন্ত তারা Character.digit(string.charAt(idx))
উপরের @ ইব্রাহিমের উত্তরটি ব্যবহার করে , অনুরূপ, তবে কিছুটা পৃথক। তাদের প্রয়োগের কভারগুলির অধীনে ওভারহেড পরিচালনা করা কোনও ব্যতিক্রম নয়।
আপনার মানগুলি বৈধ করতে ব্যতিক্রমগুলি ব্যবহার করবেন না। পরিবর্তে অ্যাপাচি নম্বরের ব্যবহারের জন্য ইউটিলি লিবস ব্যবহার করুন:
NumberUtils.isNumber(myStringValue);
সম্পাদনা করুন :
দয়া করে লক্ষ্য করুন যে, যদি আপনার স্ট্রিং 0 দিয়ে শুরু হয়, সংখ্যা ইউটিসগুলি আপনার মানটিকে হেক্সাডেসিমাল হিসাবে ব্যাখ্যা করবে।
NumberUtils.isNumber("07") //true
NumberUtils.isNumber("08") //false
Number.isNumber()
।
Number.isNumber()
প্রথম সংস্করণ থেকে 24 শে সেপ্টেম্বর '12 তারিখে 17:01 এ উপস্থিত ছিল।
সবাই কেন ব্যতিক্রম / রেজেক্স সমাধানের জন্য চাপ দিচ্ছে?
যদিও আমি বুঝতে পারি বেশিরভাগ লোক চেষ্টা / ধরা ব্যবহারে ভাল আছেন, আপনি যদি এটি ঘন ঘন করতে চান ... তবে এটি চূড়ান্তভাবে ট্যাক্সযুক্ত হতে পারে।
আমি এখানে যা করেছি তা হ'ল রেজেজ, পার্সিং নম্বর () পদ্ধতিগুলি এবং অ্যারে অনুসন্ধানের পদ্ধতিটি সবচেয়ে দক্ষ কিনা তা দেখার জন্য। এবার আমি কেবল পূর্ণসংখ্যার সংখ্যার দিকে চেয়েছিলাম।
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;
}
আমি যে গতিতে ফলাফল পেয়েছি তা হ'ল:
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 টি অক্ষর বা তার চেয়ে কম হয় এবং প্রতিটি স্ট্রিং সর্বদা একটি সংখ্যা হয় ... তবে এই ক্ষেত্রে কেন একটি চেক আছে?
সংক্ষেপে, আপনি চেষ্টা / ধরার সাথে ঘন ঘন অবৈধ সংখ্যায় দৌড়ালে এটি অত্যন্ত বেদনাদায়ক which একটি গুরুত্বপূর্ণ নিয়ম যা আমি সর্বদা অনুসরণ করি তা হ'ল প্রোগ্রাম প্রবাহের জন্য চেষ্টা / ক্যাপচার কখনও ব্যবহার না । এটি কেন একটি উদাহরণ।
মজার বিষয় হল, সরল যদি চর <0 || > 9 লিখতে অত্যন্ত সহজ ছিল, মনে রাখা সহজ (এবং একাধিক ভাষায় কাজ করা উচিত) এবং পরীক্ষার প্রায় সমস্ত পরিস্থিতিতেই জয় লাভ করে।
একমাত্র খারাপ দিকটি হ'ল আমি অনুমান করছি যে পূর্ণসংখ্যা.পার্সইন্ট () এএসসিআইআই নম্বরগুলি হ্যান্ডেল করতে পারে, তবে অ্যারে অনুসন্ধানের পদ্ধতিটি তা করে না।
যারা ভাবছেন তাদের জন্য কেন আমি বললাম চরিত্রের অ্যারেটি মনে রাখা সহজ, যদি আপনি জানেন যে কোনও নেতিবাচক লক্ষণ নেই তবে আপনি সহজেই এই হিসাবে ঘনীভূত কিছু দিয়ে দূরে সরে যেতে পারেন:
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(...)
আপনি কেবল মানটি ব্যবহার না করার কারণে এটি কেবল অকেজো নয়, তবে এটি প্রক্রিয়াজাতকরণের সময় নষ্ট করে এবং কয়েকটি ন্যানোসেকেন্ড দ্বারা রানটাইম বাড়িয়ে তোলে (যা পরীক্ষাগুলিতে 100-200 এমএস বৃদ্ধি পেয়েছিল)। আমি দেখতে পাচ্ছি না যে কেউ কেন এটি করবে কারণ এটি কার্য সম্পাদন হ্রাস করার জন্য অতিরিক্ত কাজ।
আপনি ভাবতেন যে এটি অপ্টিমাইজ হবে ... যদিও আমার বাইকোডটি পরীক্ষা করা উচিত এবং সংকলকটি কী করছে তা দেখতে হবে। এটি কেন সবসময় আমার জন্য দীর্ঘতর হতে দেখায় তা ব্যাখ্যা করে না যদিও এটি যদি কোনওভাবেই অনুকূলিত হয় ... সুতরাং আমি অবাক হই যে কী হচ্ছে। একটি দ্রষ্টব্য হিসাবে: দৈর্ঘ্য অনুসারে, আমার অর্থ 10000000 পুনরাবৃত্তির জন্য পরীক্ষা চালানো, এবং সেই প্রোগ্রামটি একাধিক বার চালানো (10x +) সর্বদা এটি ধীর হতে দেখায়।
সম্পাদনা: ক্যারেক্টার.আইসডিগেট () এর জন্য একটি পরীক্ষা আপডেট করেছে
public static boolean isNumeric(String str)
{
return str.matches("-?\\d+(.\\d+)?");
}
ক্রেগটিপি-র নিয়মিত প্রকাশ (উপরে দেখানো) কিছু মিথ্যা ইতিবাচক উত্স তৈরি করে। উদাহরণস্বরূপ "23y4" একটি সংখ্যা হিসাবে গণ্য হবে কারণ ''। দশমিক বিন্দু নয় কোনও অক্ষরের সাথে মেলে।
এছাড়াও এটি নেতৃস্থানীয় '+' সহ যে কোনও সংখ্যা প্রত্যাখ্যান করবে
এই দুটি ছোট সমস্যা এড়ানো একটি বিকল্প হ'ল
public static boolean isNumeric(String str)
{
return str.matches("[+-]?\\d*(\\.\\d+)?");
}
true
একটি একক প্লাস জন্য "+"
বা মাইনাস "-"
এবং false
জন্য"0."
matches("-?\\d+([.]\\d+)?")
আমরা প্রদত্ত স্ট্রিং থেকে সমস্ত সংখ্যাকে ("") অর্থ ফাঁকা স্থান দিয়ে প্রতিস্থাপন করার চেষ্টা করতে পারি এবং যদি তার পরে স্ট্রিংয়ের দৈর্ঘ্য শূন্য হয় তবে আমরা বলতে পারি প্রদত্ত স্ট্রিংয়ে কেবল সংখ্যা রয়েছে। [যদি আপনি এই উত্তরটি সহায়ক মনে করেন তবে দয়া করে এটির ভোটাভুটি বিবেচনা করুন] উদাহরণ:
boolean isNumber(String str){
if(str.length() == 0)
return false; //To check if string is empty
if(str.charAt(0) == '-')
str = str.replaceFirst("-","");// for handling -ve numbers
System.out.println(str);
str = str.replaceFirst("\\.",""); //to check if it contains more than one decimal points
if(str.length() == 0)
return false; // to check if it is empty string after removing -ve sign and decimal point
System.out.println(str);
return str.replaceAll("[0-9]","").length() == 0;
}
""
একটি সংখ্যা কিন্তু "3.14"
ও "-1"
হয় না?
আপনি ব্যবহার করতে পারেন NumberFormat#parse
:
try
{
NumberFormat.getInstance().parse(value);
}
catch(ParseException e)
{
// Not a number.
}
value
।
যদি আপনি অ্যান্ড্রয়েড অ্যাপ্লিকেশন বিকাশ করতে জাভা ব্যবহার করেন তবে আপনি TextUtils.isDigits কেবলমাত্র ফাংশন ব্যবহার করতে পারেন ।
সমস্যাটি সম্পর্কে আমার উত্তর এখানে ছিল।
একটি ধরা সব সুবিধার পদ্ধতি যা আপনি পার্সার কোন প্রকার সঙ্গে কোনো স্ট্রিং বিশ্লেষণ করতে ব্যবহার করতে পারেন: isParsable(Object parser, String str)
। পার্সারটি এক Class
বা একটি হতে পারে object
। এটি আপনাকে লিখিত কাস্টম পার্সার ব্যবহার করার অনুমতি দেয় এবং চিরসবুজ দৃশ্যের জন্য কাজ করা উচিত, যেমন:
isParsable(Integer.class, "11");
isParsable(Double.class, "11.11");
Object dateFormater = new java.text.SimpleDateFormat("yyyy.MM.dd G 'at' HH:mm:ss z");
isParsable(dateFormater, "2001.07.04 AD at 12:08:56 PDT");
পদ্ধতি বিবরণ সহ আমার কোড এখানে সম্পূর্ণ।
import java.lang.reflect.*;
/**
* METHOD: isParsable<p><p>
*
* This method will look through the methods of the specified <code>from</code> parameter
* looking for a public method name starting with "parse" which has only one String
* parameter.<p>
*
* The <code>parser</code> parameter can be a class or an instantiated object, eg:
* <code>Integer.class</code> or <code>new Integer(1)</code>. If you use a
* <code>Class</code> type then only static methods are considered.<p>
*
* When looping through potential methods, it first looks at the <code>Class</code> associated
* with the <code>parser</code> parameter, then looks through the methods of the parent's class
* followed by subsequent ancestors, using the first method that matches the criteria specified
* above.<p>
*
* This method will hide any normal parse exceptions, but throws any exceptions due to
* programmatic errors, eg: NullPointerExceptions, etc. If you specify a <code>parser</code>
* parameter which has no matching parse methods, a NoSuchMethodException will be thrown
* embedded within a RuntimeException.<p><p>
*
* Example:<br>
* <code>isParsable(Boolean.class, "true");<br>
* isParsable(Integer.class, "11");<br>
* isParsable(Double.class, "11.11");<br>
* Object dateFormater = new java.text.SimpleDateFormat("yyyy.MM.dd G 'at' HH:mm:ss z");<br>
* isParsable(dateFormater, "2001.07.04 AD at 12:08:56 PDT");<br></code>
* <p>
*
* @param parser The Class type or instantiated Object to find a parse method in.
* @param str The String you want to parse
*
* @return true if a parse method was found and completed without exception
* @throws java.lang.NoSuchMethodException If no such method is accessible
*/
public static boolean isParsable(Object parser, String str) {
Class theClass = (parser instanceof Class? (Class)parser: parser.getClass());
boolean staticOnly = (parser == theClass), foundAtLeastOne = false;
Method[] methods = theClass.getMethods();
// Loop over methods
for (int index = 0; index < methods.length; index++) {
Method method = methods[index];
// If method starts with parse, is public and has one String parameter.
// If the parser parameter was a Class, then also ensure the method is static.
if(method.getName().startsWith("parse") &&
(!staticOnly || Modifier.isStatic(method.getModifiers())) &&
Modifier.isPublic(method.getModifiers()) &&
method.getGenericParameterTypes().length == 1 &&
method.getGenericParameterTypes()[0] == String.class)
{
try {
foundAtLeastOne = true;
method.invoke(parser, str);
return true; // Successfully parsed without exception
} catch (Exception exception) {
// If invoke problem, try a different method
/*if(!(exception instanceof IllegalArgumentException) &&
!(exception instanceof IllegalAccessException) &&
!(exception instanceof InvocationTargetException))
continue; // Look for other parse methods*/
// Parse method refuses to parse, look for another different method
continue; // Look for other parse methods
}
}
}
// No more accessible parse method could be found.
if(foundAtLeastOne) return false;
else throw new RuntimeException(new NoSuchMethodException());
}
/**
* METHOD: willParse<p><p>
*
* A convienence method which calls the isParseable method, but does not throw any exceptions
* which could be thrown through programatic errors.<p>
*
* Use of {@link #isParseable(Object, String) isParseable} is recommended for use so programatic
* errors can be caught in development, unless the value of the <code>parser</code> parameter is
* unpredictable, or normal programtic exceptions should be ignored.<p>
*
* See {@link #isParseable(Object, String) isParseable} for full description of method
* usability.<p>
*
* @param parser The Class type or instantiated Object to find a parse method in.
* @param str The String you want to parse
*
* @return true if a parse method was found and completed without exception
* @see #isParseable(Object, String) for full description of method usability
*/
public static boolean willParse(Object parser, String str) {
try {
return isParsable(parser, str);
} catch(Throwable exception) {
return false;
}
}
নেতিবাচক সংখ্যা এবং বৈজ্ঞানিক স্বরলিপি চেষ্টা করা এবং পরিচালনা করা এড়ানো একটি ভাল সম্পাদন পদ্ধতি।
Pattern PATTERN = Pattern.compile( "^(-?0|-?[1-9]\\d*)(\\.\\d+)?(E\\d+)?$" );
public static boolean isNumeric( String value )
{
return value != null && PATTERN.matcher( value ).matches();
}
স্ট্রিংয়ের সংখ্যাটি কিনা তা পরীক্ষা করার জন্য আমার ক্লাস এখানে is এটি সংখ্যার স্ট্রিংগুলিও স্থির করে:
আপনি এখানে যান ...
public class NumUtils {
/**
* Transforms a string to an integer. If no numerical chars returns a String "0".
*
* @param str
* @return retStr
*/
static String makeToInteger(String str) {
String s = str;
double d;
d = Double.parseDouble(makeToDouble(s));
int i = (int) (d + 0.5D);
String retStr = String.valueOf(i);
System.out.printf(retStr + " ");
return retStr;
}
/**
* Transforms a string to an double. If no numerical chars returns a String "0".
*
* @param str
* @return retStr
*/
static String makeToDouble(String str) {
Boolean dotWasFound = false;
String orgStr = str;
String retStr;
int firstDotPos = 0;
Boolean negative = false;
//check if str is null
if(str.length()==0){
str="0";
}
//check if first sign is "-"
if (str.charAt(0) == '-') {
negative = true;
}
//check if str containg any number or else set the string to '0'
if (!str.matches(".*\\d+.*")) {
str = "0";
}
//Replace ',' with '.' (for some european users who use the ',' as decimal separator)
str = str.replaceAll(",", ".");
str = str.replaceAll("[^\\d.]", "");
//Removes the any second dots
for (int i_char = 0; i_char < str.length(); i_char++) {
if (str.charAt(i_char) == '.') {
dotWasFound = true;
firstDotPos = i_char;
break;
}
}
if (dotWasFound) {
String befDot = str.substring(0, firstDotPos + 1);
String aftDot = str.substring(firstDotPos + 1, str.length());
aftDot = aftDot.replaceAll("\\.", "");
str = befDot + aftDot;
}
//Removes zeros from the begining
double uglyMethod = Double.parseDouble(str);
str = String.valueOf(uglyMethod);
//Removes the .0
str = str.replaceAll("([0-9])\\.0+([^0-9]|$)", "$1$2");
retStr = str;
if (negative) {
retStr = "-"+retStr;
}
return retStr;
}
static boolean isNumeric(String str) {
try {
double d = Double.parseDouble(str);
} catch (NumberFormatException nfe) {
return false;
}
return true;
}
}
রেজেক্স ম্যাচিং
আরও বৈধতাগুলির সাথে আপগ্রেড করা "ক্রেইগটিপি" রেজেক্স মিলের আরও একটি উদাহরণ এখানে।
public static boolean isNumeric(String str)
{
return str.matches("^(?:(?:\\-{1})?\\d+(?:\\.{1}\\d+)?)$");
}
রেজেক্স টেস্ট
1 -- **VALID**
1. -- INVALID
1.. -- INVALID
1.1 -- **VALID**
1.1.1 -- INVALID
-1 -- **VALID**
--1 -- INVALID
-1. -- INVALID
-1.1 -- **VALID**
-1.1.1 -- INVALID
ব্যতিক্রম ব্যয়বহুল, তবে এই ক্ষেত্রে RegEx অনেক বেশি সময় নেয়। নীচের কোডটি দুটি ফাংশনের একটি সহজ পরীক্ষা দেখায় - একটি ব্যতিক্রম ব্যবহার করে এবং একটি রেজেেক্স ব্যবহার করে। আমার মেশিনে রেজিএক্স সংস্করণটি ব্যতিক্রমের চেয়ে 10 গুণ ধীর।
import java.util.Date;
public class IsNumeric {
public static boolean isNumericOne(String s) {
return s.matches("-?\\d+(\\.\\d+)?"); //match a number with optional '-' and decimal.
}
public static boolean isNumericTwo(String s) {
try {
Double.parseDouble(s);
return true;
} catch (Exception e) {
return false;
}
}
public static void main(String [] args) {
String test = "12345.F";
long before = new Date().getTime();
for(int x=0;x<1000000;++x) {
//isNumericTwo(test);
isNumericOne(test);
}
long after = new Date().getTime();
System.out.println(after-before);
}
}
// দয়া করে কোড নীচে চেক করুন
public static boolean isDigitsOnly(CharSequence str) {
final int len = str.length();
for (int i = 0; i < len; i++) {
if (!Character.isDigit(str.charAt(i))) {
return false;
}
}
return true;
}
// only int
public static boolean isNumber(int num)
{
return (num >= 48 && c <= 57); // 0 - 9
}
// is type of number including . - e E
public static boolean isNumber(String s)
{
boolean isNumber = true;
for(int i = 0; i < s.length() && isNumber; i++)
{
char c = s.charAt(i);
isNumber = isNumber & (
(c >= '0' && c <= '9') || (c == '.') || (c == 'e') || (c == 'E') || (c == '')
);
}
return isInteger;
}
// is type of number
public static boolean isInteger(String s)
{
boolean isInteger = true;
for(int i = 0; i < s.length() && isInteger; i++)
{
char c = s.charAt(i);
isInteger = isInteger & ((c >= '0' && c <= '9'));
}
return isInteger;
}
public static boolean isNumeric(String s)
{
try
{
Double.parseDouble(s);
return true;
}
catch (Exception e)
{
return false;
}
}
এটি এই চেকের জন্য একটি সাধারণ উদাহরণ:
public static boolean isNumericString(String input) {
boolean result = false;
if(input != null && input.length() > 0) {
char[] charArray = input.toCharArray();
for(char c : charArray) {
if(c >= '0' && c <= '9') {
// it is a digit
result = true;
} else {
result = false;
break;
}
}
}
return result;
}
আপনি java.util.Scanner অবজেক্টটি ব্যবহার করতে পারেন।
public static boolean isNumeric(String inputData) {
Scanner sc = new Scanner(inputData);
return sc.hasNextInt();
}
আমি বৈজ্ঞানিক স্বরলিপি এবং ডট এবং কমা উভয় দশমিক বিভাজক হিসাবে গ্রহণ করার জন্য ক্রেগটিপি'র সমাধানটি সংশোধন করেছি
^-?\d+([,\.]\d+)?([eE]-?\d+)?$
উদাহরণ
var re = new RegExp("^-?\d+([,\.]\d+)?([eE]-?\d+)?$");
re.test("-6546"); // true
re.test("-6546355e-4456"); // true
re.test("-6546.355e-4456"); // true, though debatable
re.test("-6546.35.5e-4456"); // false
re.test("-6546.35.5e-4456.6"); // false
এজন্যই .NET এ চেষ্টা করুন * পদ্ধতির পছন্দ। জাভা মতো traditionalতিহ্যবাহী পার্স পদ্ধতি ছাড়াও, আপনার কাছে ট্রাইপার্স পদ্ধতিও রয়েছে। আমি জাভা সিনট্যাক্সে ভাল নই (প্যারামিটারগুলি আউট?), সুতরাং দয়া করে নিম্নলিখিতটি কিছু ধরণের সিউডো কোড হিসাবে বিবেচনা করুন। যদিও ধারণাটি পরিষ্কার করা উচিত।
boolean parseInteger(String s, out int number)
{
try {
number = Integer.parseInt(myString);
return true;
} catch(NumberFormatException e) {
return false;
}
}
ব্যবহার:
int num;
if (parseInteger("23", out num)) {
// Do something with num.
}
এটি পার্স করুন (যেমন সহ Integer#parseInt
) এবং কেবল ব্যতিক্রমটি ধরুন। =)
স্পষ্ট করার জন্য: পার্সইন্ট ফাংশনটি পরীক্ষা করে যদি এটি কোনও ক্ষেত্রে সংখ্যাকে পার্স করতে পারে (স্পষ্টতই) এবং যদি আপনি যেভাবেই পার্স করতে চান, আপনি পার্সিং করে আসলে কোনও পারফরম্যান্স হিট করবেন না।
আপনি যদি এটি বিশ্লেষণ করতে না চান (বা এটি খুব, খুব কমই পার্স করতে পারেন) তবে আপনি অবশ্যই অন্যভাবে এটি করতে ইচ্ছুক হতে পারেন।
আপনি অ্যাপাচি কমন্স ল্যাং থেকে নাম ইউটিলস.আইসক্রিটেবল () ব্যবহার করতে পারেন ।
যেহেতু সংখ্যা-ইউটিস.আইস নাম্বারটি ৪.০ এ অবমূল্যায়ন করা হবে, সুতরাং এর পরিবর্তে নাম্বুটিস.আইসক্রিটেবল () ব্যবহার করুন।
জাভা 8 স্ট্রিম, ল্যাম্বডা এক্সপ্রেশন, ফাংশনাল ইন্টারফেস
সমস্ত ক্ষেত্রে পরিচালিত ( স্ট্রিং নাল, স্ট্রিং খালি ইত্যাদি )
String someString = null; // something="", something="123abc", something="123123"
boolean isNumeric = Stream.of(someString)
.filter(s -> s != null && !s.isEmpty())
.filter(Pattern.compile("\\D").asPredicate().negate())
.mapToLong(Long::valueOf)
.boxed()
.findAny()
.isPresent();
আমি কোনও এপিআই ব্যবহার না করে সংখ্যা এবং দশমিক পরীক্ষা করার জন্য কিছু শর্ত চিত্রিত করেছি,
দৈর্ঘ্য 1 ডিজিটের নম্বর স্থির করুন
Character.isDigit(char)
দৈর্ঘ্যের সংখ্যাটি স্থির করুন পরীক্ষা করুন (ধরুন দৈর্ঘ্য 6)
String number = "132452";
if(number.matches("([0-9]{6})"))
System.out.println("6 digits number identified");
মধ্যে দৈর্ঘ্য সংখ্যা পরিবর্তন করুন (4 থেকে 6 দৈর্ঘ্য ধরুন)
// {n,m} n <= length <= m
String number = "132452";
if(number.matches("([0-9]{4,6})"))
System.out.println("Number Identified between 4 to 6 length");
String number = "132";
if(!number.matches("([0-9]{4,6})"))
System.out.println("Number not in length range or different format");
দৈর্ঘ্যের দশমিক সংখ্যাটির মধ্যে ভ্যারিয়িং দৈর্ঘ্যের দশমিক সংখ্যা পরীক্ষা করুন (4 থেকে 7 দৈর্ঘ্য ধরুন)
// It will not count the '.' (Period) in length
String decimal = "132.45";
if(decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Numbers Identified between 4 to 7");
String decimal = "1.12";
if(decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Numbers Identified between 4 to 7");
String decimal = "1234";
if(decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Numbers Identified between 4 to 7");
String decimal = "-10.123";
if(decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Numbers Identified between 4 to 7");
String decimal = "123..4";
if(!decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Decimal not in range or different format");
String decimal = "132";
if(!decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Decimal not in range or different format");
String decimal = "1.1";
if(!decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Decimal not in range or different format");
আশা করি এটি অনেকের সাহায্য করবে।
অন্যান্য উত্তরের ভিত্তিতে আমি আমার নিজের লিখেছি এবং এটি ব্যতিক্রম পরীক্ষার সাথে নিদর্শনগুলি বা পার্সিং ব্যবহার করে না।
এটি সর্বাধিক এক বিয়োগ চিহ্নের জন্য পরীক্ষা করে এবং সর্বোচ্চ এক দশমিক পয়েন্ট পরীক্ষা করে।
এখানে কয়েকটি উদাহরণ এবং তাদের ফলাফল:
"1", "-1", "-1.5" এবং "-1.556" সত্য ফিরে আসে
"1.. 1..", "১ এ .৫", "1.5 ডি", "-" এবং "- 1" মিথ্যা প্রত্যাবর্তন করবে
দ্রষ্টব্য: প্রয়োজনে আপনি একটি স্থানীয় প্যারামিটার গ্রহণ করতে এটি পরিবর্তন করতে পারেন এবং বর্তমানের পরিবর্তে একটি নির্দিষ্ট লোকেল ব্যবহারের জন্য ডেসিমালফোর্ম্যাটসিম্বলস.বিজ্ঞাপন () কলগুলিতে এটি পাস করতে পারেন।
public static boolean isNumeric(final String input) {
//Check for null or blank string
if(input == null || input.isBlank()) return false;
//Retrieve the minus sign and decimal separator characters from the current Locale
final var localeMinusSign = DecimalFormatSymbols.getInstance().getMinusSign();
final var localeDecimalSeparator = DecimalFormatSymbols.getInstance().getDecimalSeparator();
//Check if first character is a minus sign
final var isNegative = input.charAt(0) == localeMinusSign;
//Check if string is not just a minus sign
if (isNegative && input.length() == 1) return false;
var isDecimalSeparatorFound = false;
//If the string has a minus sign ignore the first character
final var startCharIndex = isNegative ? 1 : 0;
//Check if each character is a number or a decimal separator
//and make sure string only has a maximum of one decimal separator
for (var i = startCharIndex; i < input.length(); i++) {
if(!Character.isDigit(input.charAt(i))) {
if(input.charAt(i) == localeDecimalSeparator && !isDecimalSeparatorFound) {
isDecimalSeparatorFound = true;
} else return false;
}
}
return true;
}
এখানে দুটি পদ্ধতি যা কার্যকর হতে পারে। (ব্যতিক্রম ব্যবহার না করে)। দ্রষ্টব্য: জাভা ডিফল্টরূপে একটি পাস-বাই-মান এবং স্ট্রিংয়ের মান স্ট্রিংয়ের অবজেক্ট ডেটার ঠিকানা। সুতরাং, যখন আপনি করছেন
stringNumber = stringNumber.replaceAll(" ", "");
আপনি কোনও ফাঁকা স্থান নেই ইনপুট মানটি পরিবর্তন করেছেন। আপনি চাইলে সেই লাইনটি সরাতে পারেন।
private boolean isValidStringNumber(String stringNumber)
{
if(stringNumber.isEmpty())
{
return false;
}
stringNumber = stringNumber.replaceAll(" ", "");
char [] charNumber = stringNumber.toCharArray();
for(int i =0 ; i<charNumber.length ;i++)
{
if(!Character.isDigit(charNumber[i]))
{
return false;
}
}
return true;
}
আপনি যদি ভাসমানদের অনুমতি দিতে চান তবে এখানে আরও একটি পদ্ধতি রয়েছে যা এই পদ্ধতিটি অভিযোগ করে ফর্মের নম্বরগুলিকে 1,123,123,123,123,123.123 পাস করার অনুমতি দেয় যা আমি সবে তৈরি করেছি এবং আমি মনে করি এটি কাজ করছে কিনা তা নিশ্চিত করার জন্য এটি আরও পরীক্ষার প্রয়োজন।
private boolean isValidStringTrueNumber(String stringNumber)
{
if(stringNumber.isEmpty())
{
return false;
}
stringNumber = stringNumber.replaceAll(" ", "");
int countOfDecimalPoint = 0;
boolean decimalPointPassed = false;
boolean commaFound = false;
int countOfDigitsBeforeDecimalPoint = 0;
int countOfDigitsAfterDecimalPoint =0 ;
int commaCounter=0;
int countOfDigitsBeforeFirstComma = 0;
char [] charNumber = stringNumber.toCharArray();
for(int i =0 ; i<charNumber.length ;i++)
{
if((commaCounter>3)||(commaCounter<0))
{
return false;
}
if(!Character.isDigit(charNumber[i]))//Char is not a digit.
{
if(charNumber[i]==',')
{
if(decimalPointPassed)
{
return false;
}
commaFound = true;
//check that next three chars are only digits.
commaCounter +=3;
}
else if(charNumber[i]=='.')
{
decimalPointPassed = true;
countOfDecimalPoint++;
}
else
{
return false;
}
}
else //Char is a digit.
{
if ((commaCounter>=0)&&(commaFound))
{
if(!decimalPointPassed)
{
commaCounter--;
}
}
if(!commaFound)
{
countOfDigitsBeforeFirstComma++;
}
if(!decimalPointPassed)
{
countOfDigitsBeforeDecimalPoint++;
}
else
{
countOfDigitsAfterDecimalPoint++;
}
}
}
if((commaFound)&&(countOfDigitsBeforeFirstComma>3))
{
return false;
}
if(countOfDecimalPoint>1)
{
return false;
}
if((decimalPointPassed)&&((countOfDigitsBeforeDecimalPoint==0)||(countOfDigitsAfterDecimalPoint==0)))
{
return false;
}
return true;
}