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




string type-conversion (20)

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

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

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

https://code.i-harness.com


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();
    

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

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

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

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


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

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

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


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

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

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

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

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

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

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


एक स्ट्रिंग को एक 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 परिवर्तित करने के बारे में बड़े लेख।


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

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

जब भी थोड़ी सी संभावना होती है कि दिए गए स्ट्रिंग में इंटीजर नहीं होता है, तो आपको इस विशेष मामले को संभालना होगा। अफसोस की बात है, मानक जावा विधियों 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));

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


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

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


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

  • 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

मेरे पास समाधान है, लेकिन मुझे नहीं पता कि यह कितना प्रभावी है। लेकिन यह अच्छी तरह से काम करता है, और मुझे लगता है कि आप इसे सुधार सकते हैं। दूसरी तरफ, मैंने 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));
        }
    }
}

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

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

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

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

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

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

वर्तमान में मैं कॉलेज के लिए एक असाइनमेंट कर रहा हूं, जहां मैं ऊपर दिए गए कुछ अभिव्यक्तियों का उपयोग नहीं कर सकता, और 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

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

int i = Integer.parseInt(null);

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


हम एक स्ट्रिंग मान को एक पूर्णांक मान में परिवर्तित करने के लिए 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 अपवाद


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

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






type-conversion