मैं जावा में एक स्ट्रिंग को इंट में कैसे बदल सकता हूं?

3026

मैं जावा में ए Stringको कैसे बदल सकता हूं int?

मेरे स्ट्रिंग में केवल संख्याएँ हैं, और मैं उस संख्या को वापस करना चाहता हूँ जिसका वह प्रतिनिधित्व करता है।

उदाहरण के लिए, स्ट्रिंग "1234"को देखते हुए परिणाम संख्या होनी चाहिए 1234।

java  string  int  type-conversion 
— अज्ञात उपयोगकर्ता
स्रोत
1
वैसे, ध्यान रखें कि यदि स्ट्रिंग शून्य है, तो कॉल करें: int i = Integer.parseInt (null); नंबरफॉरमैट अपवाद, NullPointerException नहीं फेंकता है।
— पावेल मोलचानोव
2
मुझे थोड़ा आश्चर्य हुआ कि विनिर्देश के एक महत्वपूर्ण हिस्से के गायब होने पर इस प्रश्न को बहुत अधिक मूल्यांकित किया जाना चाहिए: क्या होगा यदि स्ट्रिंग DOESN'T में केवल अंक न हों? उदाहरण के लिए, बहुत से उत्तर "-1" को खुशी से पार्स करेंगे और -1 लौटाएंगे, लेकिन हम नहीं जानते कि यह स्वीकार्य है या नहीं।
— माइकल काय

जवाबों:

4084 
String myString = "1234";
int foo = Integer.parseInt(myString);

यदि आप जावा डॉक्यूमेंटेशन को देखते हैं, तो आप "कैच" पर ध्यान देंगे कि यह फ़ंक्शन एक फेंक सकता है NumberFormatException, जो आपको निश्चित रूप से संभालना होगा:

int foo;
try {
   foo = Integer.parseInt(myString);
}
catch (NumberFormatException e)
{
   foo = 0;
}

(यह उपचार एक विकृत संख्या को परिभाषित करता है 0, लेकिन आप चाहें तो कुछ और कर सकते हैं।)

वैकल्पिक रूप से, आप Intsअमरूद लाइब्रेरी से एक विधि का उपयोग कर सकते हैं , जो जावा 8 के संयोजन में Optional, एक स्ट्रिंग को एक इंट में बदलने के लिए एक शक्तिशाली और संक्षिप्त तरीके से बनाता है:

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)
— रोब हरसुका
स्रोत
23
NumberFormatException को पकड़ने के अलावा, उपयोगकर्ता को उन तारों की लंबाई के बारे में भी सावधान रहना चाहिए, जिनमें वे गुजर रहे हैं; यदि वे किसी पूर्णांक को ओवरफ्लो करने के लिए लंबे समय से हैं, तो वे इसके बजाय Long :: parseLong का उपयोग करने पर विचार कर सकते हैं।
— एलीसन
6
@ विशेष रूप से यदि उदाहरण के लिए PostgreSQL ऑटो बढ़े हुए प्राथमिक कुंजी फ़ील्ड में BIGINT फ़ील्ड का उपयोग किया जाता है। लंबे समय तक उपयोग करने के लिए बहुत सुरक्षित
— लेथोल्ड्रस
7
आप जाँच सकते हैं कि क्या स्ट्रिंग पहले नंबर है: stackoverflow.com/questions/1102891/…
— JPRLCol
यह विधि भी अपवाद फेंकता है जब स्ट्रिंग 10. बेस में पार्स करने योग्य पूर्णांक नहीं है। अन्य अड्डों में काम करने के लिए ओवरलोड विधि का उपयोग करें। उदाहरण के लिए Integer.parseInt ("1001", 8); आधार के लिए 8. स्रोत ।
— lokesh
2
जावा 8 के वैकल्पिक के साथ संयोजन में अमरूद का उपयोग करते समय भी, यह शक्तिशाली हो सकता है, यह संभवत: एक ओवरकिल है और अपाचे कॉमन्स-लैंग लाइब्रेरी से नंबर यूटिल्स.टोइंट (स्ट्रिंग, इंट डिफॉल्ट वेल्यू) का उपयोग करने के रूप में संक्षिप्त नहीं है :int foo = NumberUtils.toInt(myString, 0);
— कुंडा
681

उदाहरण के लिए, यहाँ दो तरीके हैं:

Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);

इन विधियों में थोड़ा अंतर है:

  • valueOf का नया या कैश्ड उदाहरण देता है java.lang.Integer
  • parseIntआदिम लौटाता है int।

सभी मामलों के लिए समान है: Short.valueOf/ parseShort, Long.valueOf/ parseLong, आदि।

— lukastymo
स्रोत
80
दो तरीकों के बीच अंतर के लिए, इस प्रश्न को
— हर्ट्ज़स्प्रंग
19
valueOfविधि सिर्फ हैreturn valueOf(parseInt(string));
— पॉल वेरेस्ट
@PaVVest मुझे नहीं मिला ... valueOfखुद को पुनरावर्ती कहता है?
— आईडीक्लेव ४६३०३५18१
1
@ user463035818 valueOf में दो अधिभार हैं - इंट और स्ट्रिंग के लिए। valueOf(String)स्ट्रिंग का उपयोग करके पहले इंट को पार्स करके parseInt(String)और फिर एक इंटीजर को उस इंटीग्रेशन में लपेटकर लागू किया जाता है valueOf(int)। यहां कोई पुनरावृत्ति नहीं होती है valueOf(String)और valueOf(int)दो पूरी तरह से अलग कार्य हैं, भले ही उनका नाम एक ही हो।
— फिलिप्पोमन
244

खैर, एक बहुत महत्वपूर्ण बात पर विचार करना है कि पूर्णांक पार्सर NumberFormatException फेंकता के रूप में कहा गया है जावाडोक ।

int foo;
String StringThatCouldBeANumberOrNot = "26263Hello"; //will throw exception
String StringThatCouldBeANumberOrNot2 = "26263"; //will not throw exception
try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot);
} catch (NumberFormatException e) {
      //Will Throw exception!
      //do something! anything to handle the exception.
}

try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot2);
} catch (NumberFormatException e) {
      //No problem this time, but still it is good practice to care about exceptions.
      //Never trust user input :)
      //Do something! Anything to handle the exception.
}

विभाजित अपवादों या गतिशील रूप से किसी चीज़ को पार्स करने से पूर्णांक मान प्राप्त करने का प्रयास करते समय इस अपवाद को संभालना महत्वपूर्ण है।

— अली अब्दुरक
स्रोत
मैं "26263 हेलो" को कैसे पार्स कर सकता हूं? मैं उस मामले में 26263 निकालना चाहता हूं
— idclev 463035818
1
@ user463035818 - देखें docs.oracle.com/javase/8/docs/api/java/util/regex/… - नियमित रूप "([0-9]+)"से एक या अधिक अंक प्राप्त करने वाले एक या अधिक अंकों के पहले अनुक्रम को "कब्जा" करेंगे। को देखो Matcherकि पैकेज में वर्ग।
— मार्क स्टीवर्ट
83

इसे मैन्युअल रूप से करें:

public static int strToInt( String str ){
    int i = 0;
    int num = 0;
    boolean isNeg = false;

    //Check for negative sign; if it's there, set the isNeg flag
    if (str.charAt(0) == '-') {
        isNeg = true;
        i = 1;
    }

    //Process each character of the string;
    while( i < str.length()) {
        num *= 10;
        num += str.charAt(i++) - '0'; //Minus the ASCII code of '0' to get the value of the charAt(i++).
    }

    if (isNeg)
        num = -num;
    return num;
}
— Billz
स्रोत
21
यदि इनपुट 2 ^ 32 से अधिक है तो क्या होगा? क्या होगा यदि इनपुट में गैर-संख्यात्मक वर्ण हैं?
— युहम
86
एक प्रोग्रामर को कार्यबल में शामिल होने पर सीखना चाहिए, यदि पहले नहीं, तो पहियों को फिर से आविष्कार करने के लिए कभी नहीं। यह एक मजेदार अभ्यास हो सकता है, लेकिन यदि आप किसी वाणिज्यिक सेटिंग में इस तरह की बात करते हैं, तो कोड की समीक्षा करने के लिए अपने कोड की अपेक्षा न करें।
— दाऊद इब्न करीम
42
-1 क्षमा करें, लेकिन यह बहुत खराब एल्गोरिथ्म है, जिसमें बहुत सी सीमाएं हैं, कोई त्रुटि से निपटने, और कुछ अजीब विसंगतियां (जैसे "" एक अपवाद देता है, "-" 0 का उत्पादन करेगा, और "+" -5 का उत्पादन करता है)। कोई भी इसे क्यों चुनेगा Integer.parseInt(s)? - मैं इस बारे में एक साक्षात्कार प्रश्न होने की बात देख रहा हूं, लेकिन क) इसका मतलब यह नहीं है कि आप इसे इस तरह से करेंगे (जो कि प्रश्नकर्ता ने पूछा है), और ख) वैसे भी इस उत्तर का एक बहुत बुरा उदाहरण है।
— सुसानडब्ल्यू
1
-1 क्योंकि अगर मैं 31 इंट आधार को पार्स करना चाहता हूं तो क्या होगा? Integer.parseInt (str, 31) ऐसा करने के लिए एक लाइनर है। थोड़ा मुखर टिप्पणी, लेकिन नीचे गंभीर बिंदु। कभी भी पहिए का आविष्कार न करें जब किसी और ने पहले ही काम में लगा दिया हो
— नाथन एडम्स
1
यह कोड ऐसा लगता है जैसे प्रतिस्पर्धी प्रोग्रामिंग प्रतियोगिताओं में तेजी से आईओ के लिए एक प्रसिद्ध पुस्तकालय से अनुकूलित किया गया था। उस संदर्भ में, इनपुट डेटा वैध होने की गारंटी है, और समाधान गति पर वर्गीकृत हैं। यह तेजी से होना चाहिए Integer.parseInt क्योंकि यह कोई सत्यापन नहीं करता है।
— काया ३
53

एक वैकल्पिक समाधान अपाचे कॉमन्स नंबरुलेट्स का उपयोग करना है:

int num = NumberUtils.toInt("1234");

अपाचे की उपयोगिता अच्छी है क्योंकि यदि स्ट्रिंग एक अमान्य संख्या प्रारूप है तो 0 हमेशा लौटाया जाता है। इसलिए आप को पकड़ने की कोशिश ब्लॉक को बचाने।

अपाचे NumberUtils एपीआई संस्करण 3.4

— Ryboflavin
स्रोत
33
जब कोई अमान्य संख्या पार्स हो, तो आप शायद ही कभी 0 का उपयोग करना चाहते हों।
— wnoise
4
यदि किसी ऑब्जेक्ट पर कोई इंटिग्रेटेड फ़ील्ड सेट नहीं है, तो जीरो डिफ़ॉल्ट रूप में जावा का उपयोग करता है। तो इस संबंध में यह समझ में आता है।
— रयबोफ्लेविन
14
@ रयबोफ्लेविन नहीं, यह नहीं है। उनमें से एक एक अच्छी तरह से परिभाषित भाषा शब्दार्थ है, और दूसरा एक अपवाद है
— ईथर
44

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

पहली चीज इनपुट प्राप्त करना है, इस मामले में, अंकों की एक स्ट्रिंग; मैं इसे कॉल करूंगा String number, और इस मामले में, मैं 12 नंबर का उपयोग करके इसे उदाहरण के लिए छोड़ दूँगाString number = "12";

एक और सीमा यह थी कि मैं दोहराव वाले चक्रों का उपयोग नहीं कर सकता था, इसलिए, एक forचक्र (जो एकदम सही होता) का भी उपयोग नहीं किया जा सकता है। यह हमें थोड़ा सीमित करता है, लेकिन फिर, यही लक्ष्य है। चूँकि मुझे केवल दो अंकों की आवश्यकता थी (अंतिम दो अंक लेना), एक सरल charAtहल:

 // Obtaining the integer values of the char 1 and 2 in ASCII
 int semilastdigitASCII = number.charAt(number.length()-2);
 int lastdigitASCII = number.charAt(number.length()-1);

कोड होने के बाद, हमें केवल तालिका को देखना होगा, और आवश्यक समायोजन करना होगा:

 double semilastdigit = semilastdigitASCII - 48;  //A quick look, and -48 is the key
 double lastdigit = lastdigitASCII - 48;

अब, डबल क्यों? खैर, वास्तव में "अजीब" कदम के कारण। वर्तमान में हमारे पास दो युगल हैं, 1 और 2, लेकिन हमें इसे 12 में बदलने की आवश्यकता है, कोई भी गणितीय ऑपरेशन नहीं है जो हम कर सकते हैं।

हम बाद के (अंतिम) को 2/10 = 0.2इस तरह से 10 से विभाजित कर रहे हैं (इसलिए दोहरा क्यों) इस तरह से हैं:

 lastdigit = lastdigit/10;

यह केवल संख्या के साथ खेल रहा है। हम अंतिम अंक को दशमलव में बदल रहे थे। लेकिन अब, देखो क्या होता है:

 double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2

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

 int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"

और वहां तुम जाओ। आपने निम्न सीमाओं पर विचार करते हुए, उन दो अंकों से बने पूर्णांक में, अंकों का एक स्ट्रिंग (इस मामले में, दो अंक) को बदल दिया:

  • कोई दोहराव चक्र नहीं
  • कोई "मैजिक" अभिव्यक्त नहीं है जैसे कि पार्सेइंट
— बलूत
स्रोत
7
पूर्णांक को पार्स करने के लिए टाइप डबल का उपयोग करना न केवल एक बुरा विचार प्रदर्शन-वार है। मान जैसे ०.२ फ्लोटिंग-पॉइंट प्रतिनिधित्व में आवधिक संख्याएँ हैं और उनका सटीक प्रतिनिधित्व नहीं किया जा सकता है। बिंदु देखने के लिए System.out.println (0.1 + 0.2) आज़माएं - परिणाम 0.3 नहीं होगा! पुस्तकालय कोड के साथ बेहतर छड़ी जहां भी आप कर सकते हैं, इस मामले में Integer.parseInt ()।
— क्रिस 23
9
यह स्पष्ट नहीं है कि यह समस्या किस तरह की समस्या को हल करने की कोशिश करती है, पहले, किसी को भी कभी भी उस प्रतिबंध का वर्णन करना चाहिए जो आप का वर्णन करते हैं, दूसरा, आपको एएससीआईआई तालिका को क्यों देखना है, क्योंकि आप '0'इसके बजाय केवल चरित्र के लिए उपयोग कर सकते हैं 48और कभी नहीं करना चाहिए इसके वास्तविक संख्यात्मक मान से परेशान हैं। तीसरा, doubleमानों के साथ पूरा चक्कर लगाने का कोई मतलब नहीं है क्योंकि आप दस से विभाजित कर रहे हैं, बस दस के साथ गुणा करने के लिए। परिणाम केवल semilastdigit * 10 + lastdigitप्राथमिक विद्यालय में सीखा जाता है, जब दशमलव प्रणाली की शुरुआत की गई थी ...
— होल्गर
2
@ होल्गर मुझे व्यक्तिगत रूप से वह प्रतिबंध दिया गया था जब पहली बार प्रोग्रामिंग शुरू की गई थी, और यह भी कि जब मुझे एक परीक्षण में समान बातचीत (पेन / पेपर) लिखनी थी। यह असामान्य है, लेकिन यह एक ऐसी विधि है जो आसानी से समझ में आती है और मील द्वारा सबसे कुशल नहीं होने के बावजूद यह एक ऐसी विधि है जो छोटी परियोजनाओं के लिए शालीनता से काम करती है। SO.SE का मतलब हर किसी की मदद करना है, न कि केवल कुछ। मैंने एक वैकल्पिक विधि प्रदान की, जो उन लोगों के लिए सीख रहे हैं जो छद्म एल्गोरिथ्म बनाने के लिए सीख रहे हैं और इसे प्रीमियर जावा अभिव्यक्तियों का उपयोग करने के बजाय एक एल्गोरिथ्म में बदल रहे हैं। हालांकि मैं भूल गया कि '0' शांत है
— ओक
क्यों सब कुछ 10 से विभाजित करें फिर अंत में 10 से फिर से गुणा करें ?! इसके अलावा, "parseInt" जादू नहीं है और यह एक अभिव्यक्ति नहीं है, यह एक इनबिल्ट लाइब्रेरी फ़ंक्शन है जिसे लगभग 3 दशकों से परीक्षण और सिद्ध किया गया है
— नाथन एडम्स
1
यह एक अच्छा जवाब नहीं है। सवाल यह है कि मैं जावा में स्ट्रिंग को इंट में कैसे बदलूं? नहीं, "मैं मनमाने प्रतिबंधों के साथ इस होमवर्क समस्या को कैसे हल करूं?" यह StackOverflow नहीं, HomeworkOverflow है।
— डेविड नोव
37

Integer.decode

आप भी इस्तेमाल कर सकते हैं public static Integer decode(String nm) throws NumberFormatException।

यह बेस 8 और 16 के लिए भी काम करता है:

// base 10
Integer.parseInt("12");     // 12 - int
Integer.valueOf("12");      // 12 - Integer
Integer.decode("12");       // 12 - Integer
// base 8
// 10 (0,1,...,7,10,11,12)
Integer.parseInt("12", 8);  // 10 - int
Integer.valueOf("12", 8);   // 10 - Integer
Integer.decode("012");      // 10 - Integer
// base 16
// 18 (0,1,...,F,10,11,12)
Integer.parseInt("12",16);  // 18 - int
Integer.valueOf("12",16);   // 18 - Integer
Integer.decode("#12");      // 18 - Integer
Integer.decode("0x12");     // 18 - Integer
Integer.decode("0X12");     // 18 - Integer
// base 2
Integer.parseInt("11",2);   // 3 - int
Integer.valueOf("11",2);    // 3 - Integer

यदि आप intइसके बजाय प्राप्त करना चाहते Integerहैं तो उपयोग कर सकते हैं:

  1. बॉक्स से निकालना:

    int val = Integer.decode("12");

  2. intValue():

    Integer.decode("12").intValue();
— ROMANIA_engineer
स्रोत
आखिरकार! कोई है जो वास्तव में रूपांतरणों के परिणाम / आउटपुट पोस्ट करने के लिए परेशान करता है! क्या आप "-" संकेतों के साथ कुछ जोड़ सकते हैं?
— Not2qubit
29

जब भी इस बात की थोड़ी सी भी संभावना है कि दिए गए स्ट्रिंग में एक इंटेगर नहीं है, तो आपको इस विशेष मामले को संभालना होगा। अफसोस की बात है, मानक जावा तरीके Integer::parseIntऔर इस विशेष मामले को इंगित करने के लिए Integer::valueOfएक फेंक देते हैं NumberFormatException। इस प्रकार, आपको प्रवाह नियंत्रण के अपवादों का उपयोग करना होगा, जिसे आमतौर पर खराब कोडिंग शैली माना जाता है।

मेरी राय में, खाली लौटकर इस विशेष मामले को संभालना चाहिए Optional<Integer>। चूंकि जावा इस तरह की विधि की पेशकश नहीं करता है, इसलिए मैं निम्नलिखित आवरण का उपयोग करता हूं:

private Optional<Integer> tryParseInteger(String string) {
    try {
        return Optional.of(Integer.valueOf(string));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

उदाहरण उपयोग:

// prints "12"
System.out.println(tryParseInteger("12").map(i -> i.toString()).orElse("invalid"));
// prints "-1"
System.out.println(tryParseInteger("-1").map(i -> i.toString()).orElse("invalid"));
// prints "invalid"
System.out.println(tryParseInteger("ab").map(i -> i.toString()).orElse("invalid"));

हालांकि यह अभी भी आंतरिक रूप से प्रवाह नियंत्रण के अपवादों का उपयोग कर रहा है, उपयोग कोड बहुत साफ हो जाता है। इसके अलावा, आप स्पष्ट रूप से उस मामले को अलग कर सकते हैं, जहां -1एक वैध मूल्य के रूप में पार्स किया गया है और उस मामले में जहां अमान्य स्ट्रिंग को पार्स नहीं किया जा सकता है।

— स्टीफन डॉलसे
स्रोत
24

एक स्ट्रिंग को एक इंट में बदलना केवल एक संख्या को बदलने से अधिक जटिल है। आप निम्नलिखित मुद्दों के बारे में सोचते हैं:

  • क्या स्ट्रिंग में केवल 0-9 नंबर होते हैं ?
  • स्ट्रिंग के पहले या बाद में - / + के साथ क्या हो रहा है? क्या यह संभव है (लेखांकन संख्याओं का जिक्र)?
  • MAX _- / MIN_INFINITY के साथ क्या हो रहा है ? यदि स्ट्रिंग 99999999999999999999 है तो क्या होगा? क्या मशीन इस स्ट्रिंग को इंट के रूप में मान सकती है?
— डेनिस अहास
स्रोत
1
हाँ - और -2 ^ 31 के आसपास एक बुरा किनारा मामला है। यदि आप 2 ^ 31 को नकारने की कोशिश करते हैं, तो आप मुश्किलों में भाग सकते हैं ......
— सुसानडब्ल्यू
24

इसे करने के तरीके:

 1. Integer.parseInt(s)
 2. Integer.parseInt(s, radix)
 3. Integer.parseInt(s, beginIndex, endIndex, radix)
 4. Integer.parseUnsignedInt(s)
 5. Integer.parseUnsignedInt(s, radix)
 6. Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
 7. Integer.valueOf(s)
 8. Integer.valueOf(s, radix)
 9. Integer.decode(s)
 10. NumberUtils.toInt(s)
 11. NumberUtils.toInt(s, defaultValue)

Integer.valueOf इंटेगर ऑब्जेक्ट, अन्य सभी तरीकों का उत्पादन करता है - आदिम इंट।

कॉमन्स-लैंग 3 से अंतिम 2 विधियां और यहां परिवर्तित करने के बारे में बड़ा लेख ।

— द्मित्रो श्वेचिकोव
स्रोत
22

स्ट्रिंग मान को पूर्णांक मान में परिवर्तित करने के लिए हम रैपर क्लास की parseInt(String str)विधि का उपयोग कर सकते हैं Integer।

उदाहरण के लिए:

String strValue = "12345";
Integer intValue = Integer.parseInt(strVal);

Integerवर्ग भी प्रदान करता है valueOf(String str)विधि:

String strValue = "12345";
Integer intValue = Integer.valueOf(strValue);

हम रूपांतरण के लिए NumberUtils उपयोगिता वर्गtoInt(String strValue) का भी उपयोग कर सकते हैं :

String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);
— गिरिधर कुमार
स्रोत
22

का उपयोग करें Integer.parseInt(yourString)।

निम्नलिखित बातें याद रखें:

Integer.parseInt("1"); // ठीक

Integer.parseInt("-1"); // ठीक

Integer.parseInt("+1"); // ठीक

Integer.parseInt(" 1"); // अपवाद (रिक्त स्थान)

Integer.parseInt("2147483648");// अपवाद (पूर्णांक 2,147,483,647 के अधिकतम मूल्य तक सीमित है )

Integer.parseInt("1.1");// अपवाद ( । या , या जो कुछ भी अनुमति नहीं है)

Integer.parseInt(""); // अपवाद (0 या कुछ नहीं)

केवल एक प्रकार का अपवाद है: NumberFormatException

— लुकास बाउर
स्रोत
क्या यहाँ int का अधिकतम मान भी एक NumberFormatException देता है?
— कोडिंग वॉम्बैट
नहीं, अधिकतम मूल्य स्टिल ठीक है
— लुकास बाउर
19

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

static public Integer str2Int(String str) {
    Integer result = null;
    if (null == str || 0 == str.length()) {
        return null;
    }
    try {
        result = Integer.parseInt(str);
    } 
    catch (NumberFormatException e) {
        String negativeMode = "";
        if(str.indexOf('-') != -1)
            negativeMode = "-";
        str = str.replaceAll("-", "" );
        if (str.indexOf('.') != -1) {
            str = str.substring(0, str.indexOf('.'));
            if (str.length() == 0) {
                return (Integer)0;
            }
        }
        String strNum = str.replaceAll("[^\\d]", "" );
        if (0 == strNum.length()) {
            return null;
        }
        result = Integer.parseInt(negativeMode + strNum);
    }
    return result;
}

JUnit के साथ परीक्षण:

@Test
public void testStr2Int() {
    assertEquals("is numeric", (Integer)(-5), Helper.str2Int("-5"));
    assertEquals("is numeric", (Integer)50, Helper.str2Int("50.00"));
    assertEquals("is numeric", (Integer)20, Helper.str2Int("$ 20.90"));
    assertEquals("is numeric", (Integer)5, Helper.str2Int(" 5.321"));
    assertEquals("is numeric", (Integer)1000, Helper.str2Int("1,000.50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int("0.50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int(".50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int("-.10"));
    assertEquals("is numeric", (Integer)Integer.MAX_VALUE, Helper.str2Int(""+Integer.MAX_VALUE));
    assertEquals("is numeric", (Integer)Integer.MIN_VALUE, Helper.str2Int(""+Integer.MIN_VALUE));
    assertEquals("Not
     is numeric", null, Helper.str2Int("czv.,xcvsa"));
    /**
     * Dynamic test
     */
    for(Integer num = 0; num < 1000; num++) {
        for(int spaces = 1; spaces < 6; spaces++) {
            String numStr = String.format("%0"+spaces+"d", num);
            Integer numNeg = num * -1;
            assertEquals(numStr + ": is numeric", num, Helper.str2Int(numStr));
            assertEquals(numNeg + ": is numeric", numNeg, Helper.str2Int("- " + numStr));
        }
    }
}
— fitorec
स्रोत
आप इसे सरल कर सकते हैं:(int) Double.parseDouble(input.replaceAll("[^0-9\\.\\-]", ""));
— डेविद होर्वाथ
17

आप सभी गैर-संख्यात्मक वर्णों को हटाकर और फिर पूर्णांक को पार्स करके शुरू कर सकते हैं:

String mystr = mystr.replaceAll("[^\\d]", "");
int number = Integer.parseInt(mystr);

लेकिन चेतावनी दी जाए कि यह केवल गैर-नकारात्मक संख्याओं के लिए काम करता है।

— Thijser
स्रोत
18
यह के -42रूप में पार्स किया जाएगा 42।
10
हाँ, यह केवल गैर नकारात्मक संख्याओं के लिए काम करता है, जो शुरू करने के लिए सही हैं और इसलिए, इस प्रतिस्थापन कदम की आवश्यकता नहीं है। हर दूसरे मामले के लिए, यह स्वचालित रूप से इसे ठीक करने का प्रयास, चीजों को बदतर बना देगा (जैसा कि लगभग हर प्रयास कुछ स्वचालित रूप से ठीक करने के लिए)। यदि मैं अंदर जाता "4+2"हूं, तो मुझे 42बिना किसी संकेत के परिणाम मिलेगा कि मैंने जो करने की कोशिश की थी, वह गुमराह था। उपयोगकर्ता को यह आभास हो जाएगा कि बुनियादी भाव दर्ज करना 4+2एक वैध इनपुट था, लेकिन आवेदन गलत मूल्य के साथ जारी है। इसके अलावा, प्रकार है String, नहीं string...
— होल्गर
या पहली पंक्ति को बदलकर -> स्ट्रिंग मिस्ट = मिस्ट्री.रेप्लेस ऑल ("[^ \\ d \\ -]", "");
— एपीएम
13

पिछले उत्तरों के अलावा, मैं कई कार्य जोड़ना चाहूंगा। जब आप उनका उपयोग करते हैं तो ये परिणाम होते हैं:

public static void main(String[] args) {
  System.out.println(parseIntOrDefault("123", 0)); // 123
  System.out.println(parseIntOrDefault("aaa", 0)); // 0
  System.out.println(parseIntOrDefault("aaa456", 3, 0)); // 456
  System.out.println(parseIntOrDefault("aaa789bbb", 3, 6, 0)); // 789
}

कार्यान्वयन:

public static int parseIntOrDefault(String value, int defaultValue) {
  int result = defaultValue;
  try {
    result = Integer.parseInt(value);
  }
  catch (Exception e) {
  }
  return result;
}

public static int parseIntOrDefault(String value, int beginIndex, int defaultValue) {
  int result = defaultValue;
  try {
    String stringValue = value.substring(beginIndex);
    result = Integer.parseInt(stringValue);
  }
  catch (Exception e) {
  }
  return result;
}

public static int parseIntOrDefault(String value, int beginIndex, int endIndex, int defaultValue) {
  int result = defaultValue;
  try {
    String stringValue = value.substring(beginIndex, endIndex);
    result = Integer.parseInt(stringValue);
  }
  catch (Exception e) {
  }
  return result;
}
— nxhoaf
स्रोत
10

जैसा कि कहा गया है, अपाचे कॉमन्स ' NumberUtilsकर सकते हैं। 0यदि यह स्ट्रिंग को इंट में परिवर्तित नहीं कर पाता है तो यह वापस आ जाता है।

आप अपने स्वयं के डिफ़ॉल्ट मान को भी परिभाषित कर सकते हैं:

NumberUtils.toInt(String str, int defaultValue)

उदाहरण:

NumberUtils.toInt("3244", 1) = 3244
NumberUtils.toInt("", 1)     = 1
NumberUtils.toInt(null, 5)   = 5
NumberUtils.toInt("Hi", 6)   = 6
NumberUtils.toInt(" 32 ", 1) = 1 // Space in numbers are not allowed
NumberUtils.toInt(StringUtils.trimToEmpty("  32 ", 1)) = 32;
— अलीरज़ा फ़ताही
स्रोत
9

आप इस कोड का उपयोग कुछ सावधानियों के साथ भी कर सकते हैं।

  • विकल्प # 1: अपवाद को स्पष्ट रूप से संभालें, उदाहरण के लिए, एक संदेश संवाद दिखा रहा है और फिर वर्तमान वर्कफ़्लो के निष्पादन को रोक देता है। उदाहरण के लिए:

    try
    {
        String stringValue = "1234";

        // From String to Integer
        int integerValue = Integer.valueOf(stringValue);

        // Or
        int integerValue = Integer.ParseInt(stringValue);

        // Now from integer to back into string
        stringValue = String.valueOf(integerValue);
    }
catch (NumberFormatException ex) {
    //JOptionPane.showMessageDialog(frame, "Invalid input string!");
    System.out.println("Invalid input string!");
    return;
}

  • विकल्प # 2: प्रभावित चर को रीसेट करें यदि अपवाद के मामले में निष्पादन प्रवाह जारी रह सकता है। उदाहरण के लिए, कैच ब्लॉक में कुछ संशोधनों के साथ

    catch (NumberFormatException ex) {
    integerValue = 0;
}

तुलना या किसी भी प्रकार की कंप्यूटिंग के लिए एक स्ट्रिंग स्थिरांक का उपयोग करना हमेशा एक अच्छा विचार होता है, क्योंकि एक स्थिरांक कभी भी शून्य मान नहीं देता है।

— मणिकांत गौतम
स्रोत
4
JOptionPane.showMessageDialog()वेनिला जावा प्रश्न के उत्तर में डालने से कोई मतलब नहीं है।
— जॉन Hascall
2
Integer.valueOf(String);प्रकार वापस नहीं करता है int।
— php_coder_3809625
9

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

  1. मान्य सकारात्मक पूर्णांक के लिए:

    private static int parseInt(String str) {
    int i, n = 0;

    for (i = 0; i < str.length(); i++) {
        n *= 10;
        n += str.charAt(i) - 48;
    }
    return n;
}

  2. सकारात्मक और नकारात्मक दोनों पूर्णांकों के लिए:

    private static int parseInt(String str) {
    int i=0, n=0, sign=1;
    if (str.charAt(0) == '-') {
        i = 1;
        sign = -1;
    }
    for(; i<str.length(); i++) {
        n* = 10;
        n += str.charAt(i) - 48;
    }
    return sign*n;
}

  3. यदि आप इन नंबरों से पहले या बाद में एक व्हाट्सएप की उम्मीद कर रहे हैं, तो str = str.trim()आगे की प्रक्रिया से पहले एक बार करना सुनिश्चित करें ।

— रमन सहसी
स्रोत
7

बस आप यह कोशिश कर सकते हैं:

  • का प्रयोग करें Integer.parseInt(your_string);एक कन्वर्ट करने के Stringलिएint
  • का प्रयोग करें Double.parseDouble(your_string);एक कन्वर्ट करने के Stringलिएdouble

उदाहरण

String str = "8955";
int q = Integer.parseInt(str);
System.out.println("Output>>> " + q); // Output: 8955
String str = "89.55";
double q = Double.parseDouble(str);
System.out.println("Output>>> " + q); // Output: 89.55
— विशाल यादव
स्रोत
यह उत्तर कुछ वर्षों से पहले पोस्ट किए गए उत्तरों से परे कुछ भी जोड़ने के लिए प्रकट नहीं होता है। कुछ साल पहले पोस्ट किया गया था (स्ट्रिंग को डबल में बदलना एक अलग प्रश्न होगा )।
— बर्नहार्ड बार्कर
7

एक सामान्य स्ट्रिंग के लिए आप इसका उपयोग कर सकते हैं:

int number = Integer.parseInt("1234");

स्ट्रिंग बिल्डर और स्ट्रिंग बफर के लिए आप उपयोग कर सकते हैं:

Integer.parseInt(myBuilderOrBuffer.toString());
— आदित्य
स्रोत
6 
int foo=Integer.parseInt("1234");

सुनिश्चित करें कि स्ट्रिंग में कोई गैर-संख्यात्मक डेटा नहीं है।

— iking
स्रोत
5
यह ठीक वैसा ही है जैसे चुनिंदा जवाब।
— स्टीव स्मिथ
5
साइट का कोई मूल्य नहीं है, एक उत्तर को दोहराते हुए कि कोई और आपके सामने FIVE YEARS पोस्ट करता है।
— दाऊद इब्न करीम
यह पहले से ही स्वीकृत उत्तर (लगभग 5 साल पहले पोस्ट) में कवर किया गया है ।
— पीटर मोर्टेंसन
6

मुझे थोड़ी हैरानी है कि किसी ने इंटर्जेन्जर कंस्ट्रक्टर का जिक्र नहीं किया जो स्ट्रिंग को एक पैरामीटर के रूप में लेता है।

तो, यहाँ यह है:

String myString = "1234";
int i1 = new Integer(myString);

जावा 8 - इंटेगर (स्ट्रिंग) ।

बेशक, निर्माता प्रकार लौट आएगा Integer, और एक अनबॉक्सिंग ऑपरेशन मूल्य को धर्मान्तरित करता है int।

यह उल्लेख करना महत्वपूर्ण है : यह निर्माता parseIntविधि को कॉल करता है।

public Integer(String var1) throws NumberFormatException {
    this.value = parseInt(var1, 10);
}
— djm.im
स्रोत
5

Integer.parseInt () का उपयोग करें और इसे try...catchकिसी भी त्रुटि को संभालने के लिए एक ब्लॉक के अंदर रखें , यदि कोई गैर-संख्यात्मक चरित्र दर्ज किया गया हो, उदाहरण के लिए,

private void ConvertToInt(){
    String string = txtString.getText();
    try{
        int integerValue=Integer.parseInt(string);
        System.out.println(integerValue);
    }
    catch(Exception e){
       JOptionPane.showMessageDialog(
         "Error converting string to integer\n" + e.toString,
         "Error",
         JOptionPane.ERROR_MESSAGE);
    }
 }
— डेविड
स्रोत
5

इसे सात तरीकों से किया जा सकता है:

import com.google.common.primitives.Ints;
import org.apache.commons.lang.math.NumberUtils;

String number = "999";

1) का उपयोग कर Ints.tryParse:

int result = Ints.tryParse(number);

2) का उपयोग कर NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) का उपयोग कर NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) का उपयोग कर Integer.valueOf:

Integer result = Integer.valueOf(number);

5) का उपयोग कर Integer.parseInt:

int result = Integer.parseInt(number);

6) का उपयोग कर Integer.decode:

int result = Integer.decode(number);

7) का उपयोग कर Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);
— संतोष जदी
स्रोत
NumberUtils के रूप में अच्छी तरह से अशक्त और खाली परिदृश्य संभालती है।
— सुंदरराज गोविंदसामी
5

एक विधि parseInt (स्ट्रिंग) है। यह एक आदिम int लौटाता है:

String number = "10";
int result = Integer.parseInt(number);
System.out.println(result);

दूसरा तरीका valueOf (स्ट्रिंग) है, और यह एक नया पूर्णांक () ऑब्जेक्ट लौटाता है:

String number = "10";
Integer result = Integer.valueOf(number);
System.out.println(result);
— पंकज मंडले
स्रोत
क्या यह पिछले उत्तरों में शामिल नहीं है?
— पीटर मोर्टेंसन
4

आप निम्नलिखित में से किसी का उपयोग कर सकते हैं:

  1. Integer.parseInt(s)
  2. Integer.parseInt(s, radix)
  3. Integer.parseInt(s, beginIndex, endIndex, radix)
  4. Integer.parseUnsignedInt(s)
  5. Integer.parseUnsignedInt(s, radix)
  6. Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
  7. Integer.valueOf(s)
  8. Integer.valueOf(s, radix)
  9. Integer.decode(s)
  10. NumberUtils.toInt(s)
  11. NumberUtils.toInt(s, defaultValue)
— राजीव रंजन
स्रोत
4

यह एक पुस्तकालय का उपयोग किए बिना सकारात्मक और नकारात्मक सभी स्थितियों के साथ एक पूर्ण कार्यक्रम है

import java.util.Scanner;


public class StringToInt {

    public static void main(String args[]) {
        String inputString;
        Scanner s = new Scanner(System.in);
        inputString = s.nextLine();

        if (!inputString.matches("([+-]?([0-9]*[.])?[0-9]+)")) {
            System.out.println("Not a Number");
        }
        else {
            Double result2 = getNumber(inputString);
            System.out.println("result = " + result2);
        }
    }


    public static Double getNumber(String number) {
        Double result = 0.0;
        Double beforeDecimal = 0.0;
        Double afterDecimal = 0.0;
        Double afterDecimalCount = 0.0;
        int signBit = 1;
        boolean flag = false;

        int count = number.length();
        if (number.charAt(0) == '-') {
            signBit = -1;
            flag = true;
        }
        else if (number.charAt(0) == '+') {
            flag = true;
        }
        for (int i = 0; i < count; i++) {
            if (flag && i == 0) {
                continue;
            }
            if (afterDecimalCount == 0.0) {
                if (number.charAt(i) - '.' == 0) {
                    afterDecimalCount++;
                }
                else {
                    beforeDecimal = beforeDecimal * 10 + (number.charAt(i) - '0');
                }
            }
            else {
                afterDecimal = afterDecimal * 10 + number.charAt(i) - ('0');
                afterDecimalCount = afterDecimalCount * 10;
            }
        }
        if (afterDecimalCount != 0.0) {
            afterDecimal = afterDecimal / afterDecimalCount;
            result = beforeDecimal + afterDecimal;
        }
        else {
            result = beforeDecimal;
        }
        return result * signBit;
    }
}
— अनूप गुप्ता
स्रोत
2
पहिया को सुदृढ़ करने की आवश्यकता नहीं है, बस उपयोग करें Integer.parseInt।
— डोरियन ग्रे
@TobiasWeimer हाँ, हम कर सकते हैं लेकिन यह पुस्तकालय का उपयोग किए बिना है
— अनूप गुप्ता
@TobiasWeimer, कुछ लोगों को पुस्तकालय का उपयोग किए बिना यह करने की आवश्यकता है।
— अनूप गुप्ता
5
नहीं, किसी को इसकी आवश्यकता नहीं है क्योंकि यह जेडीके के अंदर एक फ़ंक्शन है, न कि किसी तीसरे पक्ष के प्लगइन।
— डोरियन ग्रे
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.