string convert - كيف أقوم بتحويل سلسلة إلى int في Java؟




to c# (25)

كلما كان هناك أدنى احتمال بأن السلسلة المعطاة لا تحتوي على عدد صحيح ، يجب عليك التعامل مع هذه الحالة الخاصة. للأسف ، أساليب Java القياسية Integer::parseInt و Integer::valueOf رمي NumberFormatException للإشارة إلى هذه الحالة الخاصة. وبالتالي ، يجب عليك استخدام استثناءات للتحكم في التدفق ، والتي تعتبر بشكل عام أسلوبًا سيئًا للتشفير.

في رأيي ، ينبغي التعامل مع هذه الحالة الخاصة عن طريق إرجاع Optional<Integer> . بما أن Java لا تقدم مثل هذه الطريقة ، أستخدم الغلاف التالي:

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

بينما لا يزال هذا يستخدم استثناءات للتحكم في التدفق داخليًا ، يصبح رمز الاستخدام نظيفًا جدًا.

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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


للمتعة فقط: يمكنك استخدام Java 8's Optional لتحويل String إلى Integer :

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 و Integer.valueOf . ربما تكون هناك حالات يكون فيها هذا مفيدًا - على سبيل المثال عندما تريد تجنب عمليات الفحص الفارغة. سيبدو رمز Java 8 المسبق كما يلي:

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

ها نحن ذا

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

أنا مندهش بعض الشيء أن لا أحد ذكرنا منشئ 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);
}

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

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


بصرف النظر عن الإجابات المذكورة أعلاه ، أود إضافة وظائف عديدة:

    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
  }

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

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:

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

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


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

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

يمكنك استخدام new Scanner("1244").nextInt() . أو أسأل ما إذا كان حتى int موجود: new Scanner("1244").hasNextInt()


أنا حاليا أقوم بمهمة للكلية ، حيث لا يمكنني استخدام تعبيرات معينة ، مثل تلك المذكورة أعلاه ، وبالنظر إلى جدول ASCII ، تمكنت من القيام بذلك. إنه رمز أكثر تعقيدًا بكثير ، ولكنه قد يساعد الآخرين الذين تم تقييدهم مثلما كنت.

أول شيء يجب القيام به هو الحصول على مدخلات ، في هذه الحالة ، سلسلة من الأرقام ؛ سوف أسميها String number ، وفي هذه الحالة ، سأقوم بإثبات ذلك باستخدام الرقم 12 ، لذلك String number = "12";

هناك قيد آخر كان حقيقة أنه لا يمكنني استخدام الدورات المتكررة ، لذلك ، لا يمكن استخدام دورة (التي كانت مثالية). هذا يحدّنا قليلاً ، لكن مرةً أخرى ، هذا هو الهدف. نظرًا لأنني احتجت فقط إلى رقمين (أخذ الرقمين الأخيرين) ، charAt حلها أحد 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 ، ولا توجد أي عملية رياضيات يمكننا القيام بها.

نحن نقسم الأخير (lastdigit) على 10 في الموضة 2/10 = 0.2 (لهذا السبب المزدوج):

 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

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

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


طرق للقيام بذلك:

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

آخر 2 طريقة من commons-lang3 كبيرة حول التحويل here .


كما ذكر أباتشي كومنز 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 foo=Integer.parseInt("1234");

تأكد من عدم وجود بيانات غير رقمية في السلسلة.


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

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

tryParse(String) ، والتي تُرجع null إذا تعذّر تحليل السلسلة ، على سبيل المثال:

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

import java.io.*;

public class BreakString {

  public static void main(String args[]) {

    String string = "004-034556-1234-2341";
    String[] parts = string.split("-");

    for(int i=0;i<parts.length;i++) {
      System.out.println(parts[i]);
    }
  }
}




java string int type-conversion