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



string type-conversion (25)

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

    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
  }

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

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

उदाहरण के लिए, स्ट्रिंग "1234" परिणाम दिया गया संख्या 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);
}

ये रहा

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

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

बस मस्ती के लिए: आप एक 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);

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

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


जैसा कि अपाचे कॉमन्स 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; 

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


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

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

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

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

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


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

  • 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

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

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


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

खैर, विचार करने के लिए एक बहुत ही महत्वपूर्ण बात यह है कि इंटीजर पार्सर जवाडोक में बताए गए 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.
}

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


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

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

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


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

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

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

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


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


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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());

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

int i = Integer.parseInt(null);

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


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

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

यहां दो तरीके हैं जो इसे प्राप्त करते हैं।

1 वैसे: जैसा कि आपको एक विशेष चरित्र द्वारा दो संख्याओं को विभाजित करना है, आप रेगेक्स का उपयोग कर सकते हैं

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TrialClass
{
    public static void main(String[] args)
    {
        Pattern p = Pattern.compile("[0-9]+");
        Matcher m = p.matcher("004-034556");

        while(m.find())
        {
            System.out.println(m.group());
        }
    }
}

रास्ता 2: स्ट्रिंग स्प्लिट विधि का उपयोग करना

public class TrialClass
{
    public static void main(String[] args)
    {
        String temp = "004-034556";
        String [] arrString = temp.split("-");
        for(String splitString:arrString)
        {
            System.out.println(splitString);
        }
    }
}




java string int type-conversion