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




15 Answers

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

अधिक जानकारी के लिए जावा दस्तावेज़ीकरण देखें।

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

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

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




खैर, विचार करने के लिए एक बहुत ही महत्वपूर्ण बात यह है कि इंटीजर पार्सर जवाडोक में बताए गए Javadoc अपवाद को फेंकता है।

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

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




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

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

एक और सीमा यह तथ्य थी कि मैं दोहराव चक्र का उपयोग नहीं कर सका, इसलिए चक्र के लिए (जो कि सही होता) का उपयोग नहीं किया जा सकता है। यह हमें थोड़ा सा सीमित करता है, लेकिन फिर, यह लक्ष्य है। चूंकि मुझे केवल दो अंकों की आवश्यकता है (अंतिम दो अंक लेना), एक साधारण 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 (इसलिए क्यों डबल) में बाद वाले (lastdigit) को 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 "()"

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

  • कोई दोहराव चक्र नहीं
  • कोई "जादू" अभिव्यक्ति जैसे parseInt



Integer.decode

आप public static Integer decode(String nm) throws NumberFormatException का भी उपयोग कर सकते हैं 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

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

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

    int val = Integer.decode("12"); 
    
  2. intValue() :

    Integer.decode("12").intValue();
    



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

  • क्या स्ट्रिंग में केवल 0-9 संख्याएं हैं?
  • स्ट्रिंग से पहले या उसके बाद क्या हो रहा है? क्या यह संभव है (लेखांकन संख्याओं का जिक्र करते हुए)?
  • MAX _- / MIN_INFINITY के साथ क्या हो रहा है ? क्या होगा यदि स्ट्रिंग 99 99 99 99 99 99 99 99 99 99 है? क्या मशीन इस स्ट्रिंग को int के रूप में देख सकती है?



ऐसा करने के तरीके:

 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 इंटीजर ऑब्जेक्ट, अन्य सभी तरीकों का उत्पादन करता है - आदिम int।

commons-lang3 3 से अंतिम 2 विधियां और here परिवर्तित करने के बारे में बड़े लेख।




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

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

जुनीट के साथ परीक्षण:

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



गुवा ने tryParse(String) है tryParse(String) , जो स्ट्रिंग को पार्स नहीं किया जा सकता है, उदाहरण के लिए:

Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
  ...
}



इन उपरोक्त उत्तरों के अलावा, मैं कई कार्यों को जोड़ना चाहता हूं:

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

और यहां आप परिणाम चलाते समय परिणाम हैं:

  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
  }



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

  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() करना सुनिश्चित करें।




जैसा कि अपाचे कॉमन्स NumberUtils उल्लेख किया गया है, NumberUtils उपयोग कर सकते हैं। कौन सा वापसी 0 अगर यह स्ट्रिंग को int में परिवर्तित नहीं कर सकता है।

आप अपना खुद का डिफ़ॉल्ट मान भी परिभाषित कर सकते हैं।

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; 



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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());



ये रहा

String str="1234";
int number = Integer.parseInt(str);
print number;//1234



एक विधि 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);



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

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



Related

java string int type-conversion