convert - string to double java




كيف أقوم بتحويل سلسلة إلى int في Java؟ (20)

كيف يمكنني تحويل String إلى int في Java؟

يحتوي My String على أرقام فقط ، وأريد إرجاع الرقم الذي يمثله.

على سبيل المثال ، في ضوء السلسلة "1234" ، يجب أن تكون النتيجة الرقم 1234 .

https://code.i-harness.com


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

أسلوب واحد هو parseInt (String) بإرجاع int int

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

الأسلوب الثاني هو القيمة (سلسلة) إرجاع كائن عدد صحيح جديد ().

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

أنا مندهش بعض الشيء أن لا أحد ذكرنا منشئ Integer الذي يأخذ String كمعلمة.
إذن ، ها هو:

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

جافا 8 - عدد صحيح (سلسلة) .

وبطبيعة الحال ، سيقوم المُنشئ بإرجاع Type Integer ، وتقوم عملية unboxing بتحويل القيمة إلى int .

من المهم أن أذكر
يستدعي هذا المنشئ أسلوب parseInt .

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

استخدم 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


افعلها يدويًا:

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 ' NumberUtils:

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

تعتبر الأداة المساعدة Apache رائعة لأنه إذا كانت السلسلة بتنسيق رقمي غير صالح ، فسيتم إرجاع 0 دائمًا. ومن ثم توفير لكم كتلة محاولة الصيد.

Apache NumberUtils API Version 3.4


بالنسبة إلى السلسلة العادية ، يمكنك استخدام:

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

من أجل String builder و String buffer يمكنك استخدام:

Integer.parseInt(myBuilderOrBuffer.toString());

ببساطة يمكنك تجربة هذا:

  • استخدم 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

تحويل سلسلة إلى int هو أكثر تعقيدًا من مجرد تحويل رقم. لديك التفكير في المشكلات التالية:

  • هل تحتوي السلسلة فقط على أرقام من 0 إلى 9 ؟
  • ما الأمر مع - / + قبل أو بعد السلسلة؟ هل هذا ممكن (في اشارة الى الارقام المحاسبية)؟
  • ما الأمر مع MAX _- / MIN_INFINITY؟ ماذا سيحدث إذا كانت السلسلة 99999999999999999999؟ هل يمكن للجهاز التعامل مع هذه السلسلة كمساهمة؟

حسنًا ، هناك نقطة مهمة يجب وضعها في الاعتبار وهي أن محلل عدد صحيح يلقي NumberFormatException كما هو مذكور في 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.
}

من المهم التعامل مع هذا الاستثناء عند محاولة الحصول على قيم عددية من وسيطات مقسمة أو تحليل ديناميكي لشيء ما.


على سبيل المثال ، إليك طريقتان:

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

يوجد اختلاف بسيط بين هذه الطرق:

  • إرجاع valueOf مثيل جديد أو تخزين مؤقت من java.lang.Integer
  • parseInt يعود int .

وينطبق الشيء نفسه على جميع الحالات: Short.valueOf / parseShort ، Long.valueOf / parseLong ، إلخ.


في مسابقات البرمجة ، حيث تضمن لك أن الرقم سيكون دائمًا عددًا صحيحًا صحيحًا ، يمكنك كتابة أسلوبك الخاص لتحليل الإدخال. سيؤدي ذلك إلى تخطي جميع التعليمات البرمجية ذات الصلة بالتحقق (بما أنك لست بحاجة إلى أي من ذلك) وستكون أكثر كفاءة.

  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 يمكن أن تفعل ذلك. التي ترجع 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; 

لدي حل ، لكني لا أعرف مدى فعالية ذلك. لكنها تعمل بشكل جيد ، وأعتقد أنه يمكنك تحسينها. من ناحية أخرى ، قمت JUnit مع 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;
}

اختبار مع 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));
        }
    }
}

ها نحن ذا

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

يمكنك أيضًا البدء بإزالة جميع الأحرف غير العددية ومن ثم تحليل int:

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

لكن كن حذرًا من أن هذا يعمل فقط مع الأرقام غير السالبة.


يمكنك استخدام هذا الرمز أيضًا ، مع بعض الاحتياطات.

  • الخيار الأول: التعامل مع الاستثناء بشكل صريح ، على سبيل المثال ، إظهار مربع حوار رسالة ثم إيقاف تنفيذ سير العمل الحالي. فمثلا:

    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

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

إن استخدام ثابت سلسلة للمقارنة أو أي نوع من الحوسبة هو دائمًا فكرة جيدة ، لأن ثابتًا لا يعرض قيمة خالية مطلقًا.


يمكننا استخدام الأسلوب parseInt(String str) لفئة المجمّع Integer لتحويل قيمة String إلى قيمة عدد صحيح.

فمثلا:

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

يوفر فئة Integer أيضاً القيمة valueOf(String str) :

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

يمكننا أيضًا استخدام toInt(String strValue) من فئة Utility المساعدة لـ NumberUtils للتحويل:

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

هذا هو البرنامج الكامل مع جميع الشروط الإيجابية والسلبية دون استخدام المكتبة

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

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

انظر وثائق جافا لمزيد من المعلومات.





type-conversion