दिलचस्प पोस्ट
जावा जेनेरिक्स वाइल्डकार्ड प्रश्न: सूची <? ए विस्तारित करता है पायथन को तेज करना जावास्क्रिप्ट: क्यों निजी क्षेत्र के अंदर "यह" वैश्विक दायरे को दर्शाता है? पूंछ कॉल opcode उत्पन्न रूबी 1.9 Array.to_s अलग ढंग से व्यवहार करता है? Iframe की सामग्री सेट करें इसे स्क्रीन पर रखते हुए पाइप स्टडआउट कैसे करें? (और एक आउटपुट फ़ाइल नहीं) समारोह से प्रारंभिक प्रस्थान? जर्सी में प्रतिक्रिया इकाई के रूप में स्ट्रीमिंग आउटपुट का उपयोग करने का उदाहरण PostgreSQL अनुक्रमणिका सरणी स्तंभ कर सकते हैं? एंड्रॉइड पर मेरी बहुत ही यूआरआई योजना कैसे लागू करें I Node.js के साथ एक JSON API कॉल करना गुमनाम प्रकार के परिणाम लौटें? सतह दृश्य और दृश्य के बीच का अंतर? उड़ने पर आईओएस एपी की भाषा बदलें

Integer.parseInt (encapsulate करने का अच्छा तरीका)

मेरे पास एक ऐसा प्रोजेक्ट है जिसमें हम अक्सर स्ट्रिंग को एक int में कनवर्ट करने के लिए Integer.parseInt() का उपयोग करते हैं। जब कुछ गलत हो जाता है (उदाहरण के लिए, String संख्या नहीं है, लेकिन अक्षर a , या जो कुछ भी) यह विधि एक अपवाद फेंक देगा हालांकि, अगर मुझे हर जगह अपने कोड में अपवादों को संभालना है, तो यह बहुत बदसूरत बहुत जल्दी दिखना शुरू कर देता है। मैं इसे एक विधि में रखना चाहूंगा, फिर भी, मुझे कोई सुराग नहीं है कि रूपांतरण गलत हो जाने के लिए एक साफ मूल्य कैसे लौटाया जाए।

सी ++ में मैं एक ऐसा तरीका बना सकता था जो एक इंटर्न के लिए पॉइंटर को स्वीकार करता था और विधि को सही या गलत रूप में वापस करने देता था। हालांकि, जहां तक ​​मुझे पता है, यह जावा में संभव नहीं है। मैं एक ऐसी वस्तु भी बना सकता हूं जिसमें एक सच्चे / झूठी चर और रूपांतरित मूल्य होता है, लेकिन यह आदर्श नहीं लगता है या तो। वही बात एक वैश्विक मूल्य के लिए जाती है, और इससे मुझे बहुस्तरीयता के साथ कुछ परेशानी हो सकती है

ऐसा करने का एक साफ तरीका क्या है?

Solutions Collecting From Web of "Integer.parseInt (encapsulate करने का अच्छा तरीका)"

आप एक Integer बजाय एक Integer लौटा सकते हैं, पार्स विफलता पर null लौट सकते हैं।

यह शर्म की बात है कि जावा बिना किसी आंतरिक रूप से फेंक दिया अपवाद के बिना ऐसा करने का एक तरीका प्रदान नहीं करता है – आप अपवाद को छुपा सकते हैं (उसे पकड़कर और रिक्त लौटकर), लेकिन अगर आप सैकड़ों पार्सिंग कर रहे हैं तो यह अभी भी एक प्रदर्शन समस्या हो सकती है उपयोगकर्ता द्वारा प्रदत्त आंकड़ों के हजारों बिट्स का

संपादित करें: ऐसी विधि के लिए कोड:

 public static Integer tryParse(String text) { try { return Integer.parseInt(text); } catch (NumberFormatException e) { return null; } } 

ध्यान दें कि मुझे यकीन नहीं है कि मेरे सिर के शीर्ष से यह क्या होगा अगर text शून्य है आपको उस पर विचार करना चाहिए – यदि यह एक बग का प्रतिनिधित्व करता है (अर्थात आपका कोड एक अमान्य मूल्य पार कर सकता है, लेकिन उसे निरर्थक नहीं करना चाहिए) तो अपवाद फेंकना उचित है; अगर यह किसी बग का प्रतिनिधित्व नहीं करता है, तो आपको शायद किसी भी अन्य अमान्य मूल्य के लिए आप के रूप में रिक्त होना चाहिए।

मूल रूप से इस उत्तर में new Integer(String) कन्स्ट्रक्टर का उपयोग किया गया; यह अब Integer.parseInt और मुक्केबाजी संचालन का उपयोग करता है; इस तरह से छोटे मूल्यों को कैश्ड Integer ऑब्जेक्ट में बॉक्सिंग किया जा रहा है, जिससे उन परिस्थितियों में इसे और अधिक कुशल बना दिया जा सकता है।

जब कोई संख्या नहीं है तो आप क्या व्यवहार करते हैं?

यदि, उदाहरण के लिए, आपके पास अक्सर कोई डिफ़ॉल्ट मान है, जब इनपुट संख्या नहीं है, तो एक विधि जैसे कि यह उपयोगी हो सकती है:

 public static int parseWithDefault(String number, int defaultVal) { try { return Integer.parseInt(number); } catch (NumberFormatException e) { return defaultVal; } } 

जब भी इनपुट को पार्स नहीं किया जा सकता है, तो अलग-अलग व्यवहार के लिए समान तरीके लिखा जा सकता है।

कुछ मामलों में आपको असफल-तेज परिस्थितियों के रूप में पार्सिंग त्रुटियों को संभालना चाहिए, लेकिन अन्य मामलों में, जैसे अनुप्रयोग कॉन्फ़िगरेशन, मैं अपाचे कॉमन्स लैंग 3 नंबर यूटल्स का उपयोग करते हुए डिफ़ॉल्ट मानों के साथ गुम इनपुट को संभाल करना पसंद करता हूं ।

 int port = NumberUtils.toInt(properties.getProperty("port"), 8080); 

अपवादों को संभालने से बचने के लिए यह सुनिश्चित करने के लिए नियमित अभिव्यक्ति का उपयोग करें कि आपके पास पहले सभी अंक हैं:

 if(value.matches("\\d+") { Integer.parseInt(value); } 

Ints.tryParse() में Ints.tryParse() है यह गैर-संख्यात्मक स्ट्रिंग पर अपवाद नहीं डालता है, हालांकि यह रिक्त स्ट्रिंग पर अपवाद फेंकता है।

प्रश्न के उत्तर को पढ़ने के बाद मुझे लगता है कि पार्सआईंट विधि की व्याख्या करना या लपेटना आवश्यक नहीं है, शायद यह भी एक अच्छा विचार नहीं है।

जॉन ने सुझाव दिया था कि आप 'रिक्त' लौट सकते हैं, लेकिन एक अशक्त-चेक द्वारा एक कोशिश / पकड़ बनाने की जगह कम या ज्यादा है। यदि आप 'त्रुटि भूल' भूलते हैं तो व्यवहार पर थोड़ा सा अंतर होता है: यदि आप अपवाद नहीं पकड़ते हैं, तो कोई असाइनमेंट नहीं है और बाएं हाथ की ओर वाला यह पुराना मान रखता है। यदि आप रिक्त के लिए परीक्षण नहीं करते हैं, तो आप शायद JVM (एनपीई) द्वारा हिट हो जाएंगे।

जंभाई का सुझाव मेरे लिए और अधिक सुंदर लग रहा है, क्योंकि मुझे कुछ त्रुटियों या असाधारण राज्यों को संकेत देने के लिए रिक्त स्थान पसंद नहीं है। अब आपको एक पूर्वनिर्धारित ऑब्जेक्ट के साथ रेफरेंसियल समानता की जांच करनी होगी, जो कि एक समस्या को दर्शाती है। लेकिन, जैसा कि दूसरों का तर्क है, यदि आप फिर से 'भूल' की जाँच करें और एक स्ट्रिंग अव्यावहारिक है, तो प्रोग्राम को 'त्रुटि' या 'शून्य' ऑब्जेक्ट में लिपटे इंसट के साथ लगातार जारी रखें।

निकोले का समाधान और अधिक वस्तु केंद्रित है और अन्य आवरण वर्गों से parseXXX विधियों के साथ भी काम करेगा I लेकिन अंत में, उन्होंने सिर्फ ऑपरेशन नॉट अपपोर्ट अपवाद द्वारा नंबरफॉर्मैट एक्सपेशेशन को बदल दिया – फिर आपको अस्थायी इनपुट को संभालने के लिए एक प्रयास / पकड़ की आवश्यकता है।

इसलिए, यह मेरा निष्कर्ष सादे पार्सआईट विधि को समापित नहीं करने के लिए। मैं केवल अगर मैं कुछ (आवेदन निर्भर) त्रुटि के रूप में अच्छी तरह से निपटने जोड़ सकता है encapsulate होगा।

हो सकता है कि आप इस तरह से कुछ का उपयोग कर सकते हैं:

 public class Test { public interface Option<T> { T get(); T getOrElse(T def); boolean hasValue(); } final static class Some<T> implements Option<T> { private final T value; public Some(T value) { this.value = value; } @Override public T get() { return value; } @Override public T getOrElse(T def) { return value; } @Override public boolean hasValue() { return true; } } final static class None<T> implements Option<T> { @Override public T get() { throw new UnsupportedOperationException(); } @Override public T getOrElse(T def) { return def; } @Override public boolean hasValue() { return false; } } public static Option<Integer> parseInt(String s) { Option<Integer> result = new None<Integer>(); try { Integer value = Integer.parseInt(s); result = new Some<Integer>(value); } catch (NumberFormatException e) { } return result; } } 

आप सी ++ व्यवहार को दोहरा सकते हैं, जिसे आप बहुत आसानी से चाहते हैं

 public static boolean parseInt(String str, int[] byRef) { if(byRef==null) return false; try { byRef[0] = Integer.parseInt(prop); return true; } catch (NumberFormatException ex) { return false; } } 

आप इस तरह से विधि का उपयोग करेंगे:

 int[] byRef = new int[1]; boolean result = parseInt("123",byRef); 

इसके बाद वेरिएबल के result यह सत्य हैं कि सब कुछ ठीक हो गया और byRef[0] में पार्स किए गए मान शामिल है।

व्यक्तिगत रूप से, मैं अपवाद को पकड़ने के लिए छड़ी होगी

मेरा जावा थोड़ी सी जंगली है, लेकिन मुझे देखने दो कि मैं आपको सही दिशा में बता सकता हूं:

 public class Converter { public static Integer parseInt(String str) { Integer n = null; try { n = new Integer(Integer.tryParse(str)); } catch (NumberFormatException ex) { // leave n null, the string is invalid } return n; } } 

यदि आपका रिटर्न वैल्यू null , तो आपके पास खराब मान है अन्यथा, आपके पास मान्य Integer

ParseInt विधि फर्क करने के बारे में क्या?

यह आसान है, बस एक नई उपयोगिता को कॉपी-चिपकाएं जो Integer या Optional<Integer> और रिटर्न के साथ प्रतिस्थापित करता है। ऐसा लगता है कि अंतर्निहित कोड में कोई अपवाद नहीं है, लेकिन बेहतर जांच

संपूर्ण अपवाद हैंडलिंग सामान को छोड़कर, आप कुछ समय के लिए अमान्य इनपुट पर बचा सकते हैं। और विधि जेडीके 1.0 के बाद से है, इसलिए यह संभव नहीं है कि आपको इसे अद्यतित रखने के लिए बहुत कुछ करना होगा।

आप ऐसा नल-ऑब्जेक्ट का उपयोग कर सकते हैं:

 public class Convert { @SuppressWarnings({"UnnecessaryBoxing"}) public static final Integer NULL = new Integer(0); public static Integer convert(String integer) { try { return Integer.valueOf(integer); } catch (NumberFormatException e) { return NULL; } } public static void main(String[] args) { Integer a = convert("123"); System.out.println("a.equals(123) = " + a.equals(123)); System.out.println("a == NULL " + (a == NULL)); Integer b = convert("onetwothree"); System.out.println("b.equals(123) = " + b.equals(123)); System.out.println("b == NULL " + (b == NULL)); Integer c = convert("0"); System.out.println("equals(0) = " + c.equals(0)); System.out.println("c == NULL " + (c == NULL)); } } 

इस उदाहरण में मुख्य परिणाम:

 a.equals(123) = true a == NULL false b.equals(123) = false b == NULL true c.equals(0) = true c == NULL false 

इस तरह से आप हमेशा असफल रूपांतरण के लिए परीक्षण कर सकते हैं लेकिन अभी भी परिणाम के साथ पूर्णांक के उदाहरणों के साथ काम करते हैं। आप संख्या नल का प्रतिनिधित्व करने के लिए भी ज़ूम कर सकते हैं (≠ 0)।

मैं सुझाव दूँगा कि आप एक तरह की विधि पर विचार करें

  IntegerUtilities.isValidInteger(String s) 

जिसे आप तब लागू करते हैं जब आप फिट दिखते हैं यदि आप परिणाम को वापस लेना चाहते हैं – शायद इसलिए कि आप पूर्णांक .parseInt () का उपयोग करें – आप सरणी चाल का उपयोग कर सकते हैं।

  IntegerUtilities.isValidInteger(String s, int[] result) 

जहां आप परिणाम में [0] को पूर्णांक मान में निर्धारित करते हैं।

यह कुछ निकोले के समाधान के समान है:

  private static class Box<T> { T me; public Box() {} public T get() { return me; } public void set(T fromParse) { me = fromParse; } } private interface Parser<T> { public void setExclusion(String regex); public boolean isExcluded(String s); public T parse(String s); } public static <T> boolean parser(Box<T> ref, Parser<T> p, String toParse) { if (!p.isExcluded(toParse)) { ref.set(p.parse(toParse)); return true; } else return false; } public static void main(String args[]) { Box<Integer> a = new Box<Integer>(); Parser<Integer> intParser = new Parser<Integer>() { String myExclusion; public void setExclusion(String regex) { myExclusion = regex; } public boolean isExcluded(String s) { return s.matches(myExclusion); } public Integer parse(String s) { return new Integer(s); } }; intParser.setExclusion("\\D+"); if (parser(a,intParser,"123")) System.out.println(a.get()); if (!parser(a,intParser,"abc")) System.out.println("didn't parse "+a.get()); } 

मुख्य विधि कोड को अभिव्यक्त करता है। पार्सर इंटरफ़ेस को कार्यान्वित करने का दूसरा तरीका स्पष्ट रूप से निर्माण से "\ D +" सेट करना होगा, और तरीकों से कुछ भी नहीं किया जाएगा।

आप अपना खुद का रोल कर सकते हैं, लेकिन कॉमन लैंग की StringUtils.isNumeric() विधि का उपयोग करना आसान है। यह स्ट्रिंग में प्रत्येक वर्ण को पुनरावृति करने के लिए Character.isDigit () का उपयोग करता है।

वे जिस तरह से मैं इस समस्या को लगातार संभालता है उदाहरण के लिए कंसोल से डेटा पढ़ते समय:

 Java.util.Scanner keyboard = new Java.util.Scanner(System.in); public int GetMyInt(){ int ret; System.out.print("Give me an Int: "); try{ ret = Integer.parseInt(keyboard.NextLine()); } catch(Exception e){ System.out.println("\nThere was an error try again.\n"); ret = GetMyInt(); } return ret; } 

अपवाद से बचने के लिए, आप जावा के Format.parseObject का उपयोग कर सकते हैं। नीचे दिया गया कोड मूल रूप से अपाचे कॉमन के इंटिजरविदेटर क्लास का सरलीकृत संस्करण है।

 public static boolean tryParse(String s, int[] result) { NumberFormat format = NumberFormat.getIntegerInstance(); ParsePosition position = new ParsePosition(0); Object parsedValue = format.parseObject(s, position); if (position.getErrorIndex() > -1) { return false; } if (position.getIndex() < s.length()) { return false; } result[0] = ((Long) parsedValue).intValue(); return true; } 

आप या तो अपनी पसंद के आधार पर AtomicInteger या int[] सरणी चाल का उपयोग कर सकते हैं

यहां मेरा परीक्षण है जो इसका उपयोग करता है –

 int[] i = new int[1]; Assert.assertTrue(IntUtils.tryParse("123", i)); Assert.assertEquals(123, i[0]); 

मुझे भी यही समस्या थी यह एक विधि है जिसे मैंने एक इनपुट के लिए उपयोगकर्ता से पूछने के लिए लिखा था और इनपुट को स्वीकार नहीं किया, जब तक कि यह एक पूर्णांक न हो। कृपया ध्यान दें कि मैं एक शुरुआत कर रहा हूं, यदि अपेक्षित के रूप में कोड काम नहीं कर रहा है, तो मेरी अनुभवहीनता को दोष दें!

 private int numberValue(String value, boolean val) throws IOException { //prints the value passed by the code implementer System.out.println(value); //returns 0 is val is passed as false Object num = 0; while (val) { num = br.readLine(); try { Integer numVal = Integer.parseInt((String) num); if (numVal instanceof Integer) { val = false; num = numVal; } } catch (Exception e) { System.out.println("Error. Please input a valid number :-"); } } return ((Integer) num).intValue(); } 

जॉन स्कीट द्वारा दिए गए उत्तर ठीक है, लेकिन मैं एक null पूर्णांक वस्तु को वापस नहीं देना पसंद करता हूं। मुझे इसका उपयोग करने में भ्रमित है जावा 8 के बाद से OptionalInt का उपयोग करते हुए एक बेहतर विकल्प (मेरी राय में) है:

 public static OptionalInt tryParse(String value) { try { return OptionalInt.of(Integer.parseInt(value)); } catch (NumberFormatException e) { return OptionalInt.empty(); } } 

यह स्पष्ट करता है कि आपको उस केस को संभालना होगा जहां कोई मान उपलब्ध नहीं है। मैं चाहूंगी कि भविष्य में जावा लाइब्रेरी में इस तरह के फ़ंक्शन को जोड़ा जाएगा, लेकिन मुझे नहीं पता कि क्या ऐसा कभी नहीं होगा।

यह 8391979 के प्रश्न का उत्तर है, "क्या जावा में एक इंट। ट्रीपेरस है जो खराब डेटा के लिए एक अपवाद नहीं डालता है? [डुप्लिकेट]" जो बंद है और इस प्रश्न से जुड़ा है

2016 08 को संपादित करें: जोड़ा गया ltrimZeroes विधियां और tryParse () में उन्हें बुलाया। संख्या में अग्रणी शून्य के बिना स्ट्रिंग झूठे परिणाम दे सकती है (कोड में टिप्पणियां देखें)। अब भी सार्वजनिक स्थैतिक स्ट्रिंग लिट्रिमजरोस (स्ट्रिंग नंबर स्ट्रिंग) विधि है जो सकारात्मक और नकारात्मक "संख्या" (END संपादन) के लिए काम करती है

नीचे आपको एक उच्च गति अनुकूलित ट्रांस्पोर्ट पर्स () सी (सी # के समान) विधि के साथ एक अल्पविकसित रैपर (मुक्केबाजी) वर्ग मिलता है जो स्ट्रिंग को पार्स करता है और जावा से पूर्णांक। पैरासेन्ट (स्ट्रिंग) की तुलना में थोड़ा सा तेज है।

 public class IntBoxSimple { // IntBoxSimple - Rudimentary class to implement a C#-like tryParse() method for int // A full blown IntBox class implementation can be found in my Github project // Copyright (c) 2016, Peter Sulzer, Fürth // Program is published under the GNU General Public License (GPL) Version 1 or newer protected int _n; // this "boxes" the int value // BEGIN The following statements are only executed at the // first instantiation of an IntBox (ie only once) or // already compiled into the code at compile time: public static final int MAX_INT_LEN = String.valueOf(Integer.MAX_VALUE).length(); public static final int MIN_INT_LEN = String.valueOf(Integer.MIN_VALUE).length(); public static final int MAX_INT_LASTDEC = Integer.parseInt(String.valueOf(Integer.MAX_VALUE).substring(1)); public static final int MAX_INT_FIRSTDIGIT = Integer.parseInt(String.valueOf(Integer.MAX_VALUE).substring(0, 1)); public static final int MIN_INT_LASTDEC = -Integer.parseInt(String.valueOf(Integer.MIN_VALUE).substring(2)); public static final int MIN_INT_FIRSTDIGIT = Integer.parseInt(String.valueOf(Integer.MIN_VALUE).substring(1,2)); // END The following statements... // ltrimZeroes() methods added 2016 08 16 (are required by tryParse() methods) public static String ltrimZeroes(String s) { if (s.charAt(0) == '-') return ltrimZeroesNegative(s); else return ltrimZeroesPositive(s); } protected static String ltrimZeroesNegative(String s) { int i=1; for ( ; s.charAt(i) == '0'; i++); return ("-"+s.substring(i)); } protected static String ltrimZeroesPositive(String s) { int i=0; for ( ; s.charAt(i) == '0'; i++); return (s.substring(i)); } public static boolean tryParse(String s,IntBoxSimple intBox) { if (intBox == null) // intBoxSimple=new IntBoxSimple(); // This doesn't work, as // intBoxSimple itself is passed by value and cannot changed // for the caller. I. e. "out"-arguments of C# cannot be simulated in Java. return false; // so we simply return false s=s.trim(); // leading and trailing whitespace is allowed for String s int len=s.length(); int rslt=0, d, dfirst=0, i, j; char c=s.charAt(0); if (c == '-') { if (len > MIN_INT_LEN) { // corrected (added) 2016 08 17 s = ltrimZeroesNegative(s); len = s.length(); } if (len >= MIN_INT_LEN) { c = s.charAt(1); if (!Character.isDigit(c)) return false; dfirst = c-'0'; if (len > MIN_INT_LEN || dfirst > MIN_INT_FIRSTDIGIT) return false; } for (i = len - 1, j = 1; i >= 2; --i, j *= 10) { c = s.charAt(i); if (!Character.isDigit(c)) return false; rslt -= (c-'0')*j; } if (len < MIN_INT_LEN) { c = s.charAt(i); if (!Character.isDigit(c)) return false; rslt -= (c-'0')*j; } else { if (dfirst >= MIN_INT_FIRSTDIGIT && rslt < MIN_INT_LASTDEC) return false; rslt -= dfirst * j; } } else { if (len > MAX_INT_LEN) { // corrected (added) 2016 08 16 s = ltrimZeroesPositive(s); len=s.length(); } if (len >= MAX_INT_LEN) { c = s.charAt(0); if (!Character.isDigit(c)) return false; dfirst = c-'0'; if (len > MAX_INT_LEN || dfirst > MAX_INT_FIRSTDIGIT) return false; } for (i = len - 1, j = 1; i >= 1; --i, j *= 10) { c = s.charAt(i); if (!Character.isDigit(c)) return false; rslt += (c-'0')*j; } if (len < MAX_INT_LEN) { c = s.charAt(i); if (!Character.isDigit(c)) return false; rslt += (c-'0')*j; } if (dfirst >= MAX_INT_FIRSTDIGIT && rslt > MAX_INT_LASTDEC) return false; rslt += dfirst*j; } intBox._n=rslt; return true; } // Get the value stored in an IntBoxSimple: public int get_n() { return _n; } public int v() { // alternative shorter version, v for "value" return _n; } // Make objects of IntBoxSimple (needed as constructors are not public): public static IntBoxSimple makeIntBoxSimple() { return new IntBoxSimple(); } public static IntBoxSimple makeIntBoxSimple(int integerNumber) { return new IntBoxSimple(integerNumber); } // constructors are not public(!=: protected IntBoxSimple() {} { _n=0; // default value an IntBoxSimple holds } protected IntBoxSimple(int integerNumber) { _n=integerNumber; } } 

कक्षा इंटोबॉक्स के लिए टेस्ट / उदाहरण प्रोग्राम: सरल

 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class IntBoxSimpleTest { public static void main (String args[]) { IntBoxSimple ibs = IntBoxSimple.makeIntBoxSimple(); String in = null; BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); do { System.out.printf( "Enter an integer number in the range %d to %d:%n", Integer.MIN_VALUE, Integer.MAX_VALUE); try { in = br.readLine(); } catch (IOException ex) {} } while(! IntBoxSimple.tryParse(in, ibs)); System.out.printf("The number you have entered was: %d%n", ibs.v()); } } 

नियमित अभिव्यक्ति और डिफ़ॉल्ट पैरामीटर तर्क के साथ प्रयास करें

 public static int parseIntWithDefault(String str, int defaultInt) { return str.matches("-?\\d+") ? Integer.parseInt(str) : defaultInt; } int testId = parseIntWithDefault("1001", 0); System.out.print(testId); // 1001 int testId = parseIntWithDefault("test1001", 0); System.out.print(testId); // 1001 int testId = parseIntWithDefault("-1001", 0); System.out.print(testId); // -1001 int testId = parseIntWithDefault("test", 0); System.out.print(testId); // 0 

यदि आप apache.commons.lang3 का उपयोग कर रहे हैं तो NumberUtils का उपयोग करके :

 int testId = NumberUtils.toInt("test", 0); System.out.print(testId); // 0