java - मैं जावा में एक स्ट्रिंग को एक int में कैसे परिवर्तित करूं?



15 Answers

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

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

इन विधियों के बीच थोड़ा अंतर है:

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

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

java string int type-conversion

मैं जावा में एक String को एक String कैसे परिवर्तित कर सकता हूं?

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

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




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

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;
}



Apache Commons ' संख्या का उपयोग करने के लिए एक वैकल्पिक समाधान है:

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

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

अपाचे संख्या API संस्करण 3.4 का उपयोग करता है




जब भी थोड़ी सी संभावना होती है कि दिए गए स्ट्रिंग में इंटीजर नहीं होता है, तो आपको इस विशेष मामले को संभालना होगा। अफसोस की बात है, मानक जावा विधियों 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 1234
System.out.println(tryParseInteger("1234").orElse(-1));
// prints -1
System.out.println(tryParseInteger("foobar").orElse(-1));

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




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

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

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

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

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

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

String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);



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 अपवाद




बस मस्ती के लिए: आप एक String को एक Integer में परिवर्तित करने के लिए जावा 8 के Optional का उपयोग कर सकते हैं:

String str = "123";
Integer value = Optional.of(str).map(Integer::valueOf).get();
// Will return the integer value of the specified string, or it
// will throw an NPE when str is null.

value = Optional.ofNullable(str).map(Integer::valueOf).orElse(-1);
// Will do the same as the code above, except it will return -1
// when srt is null, instead of throwing an NPE.

यहां हम केवल Integer.valueOf और Optinal गठबंधन Optinal । शायद यह उपयोगी हो सकता है जब यह उपयोगी हो - उदाहरण के लिए जब आप शून्य जांच से बचना चाहते हैं। प्री जावा 8 कोड इस तरह दिखेगा:

Integer value = (str == null) ? -1 : Integer.parseInt(str);



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

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

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




आप new Scanner("1244").nextInt() उपयोग कर सकते हैं new Scanner("1244").nextInt() । या पूछें कि यहां तक ​​कि एक int मौजूद है: new Scanner("1244").hasNextInt()




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

  • विकल्प # 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;
    }
    

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




बस आप इसे आजमा सकते हैं:

  • Integer.parseInt(your_string); उपयोग करें Integer.parseInt(your_string); String को int कनवर्ट करने के लिए
  • Double.parseDouble(your_string); उपयोग 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



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

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




मैं थोड़ा आश्चर्यचकित हूं कि किसी ने इंटीजर कन्स्ट्रक्टर का उल्लेख नहीं किया जो स्ट्रिंग को पैरामीटर के रूप में लेता है।
तो, यहां है:

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

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

बेशक, कन्स्ट्रक्टर टाइप Integer लौटाएगा, और अनबॉक्सिंग ऑपरेशन int को int

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

public Integer(String var1) throws NumberFormatException {
    this.value = parseInt(var1, 10);
}



Integer.parseInt () का उपयोग करें और इसे एक try...catch अंदर रखें try...catch किसी भी त्रुटि को संभालने के 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);
    }
 }



वैसे, ध्यान रखें कि यदि स्ट्रिंग शून्य है, तो कॉल:

int i = Integer.parseInt(null);

संख्या FormatException फेंकता है, नलपोइंटर अपवाद नहीं।






Related