كيف يمكنني تحويل سلسلة إلى int في جافا؟

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

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

هناك اختلاف بسيط بين هذه الطرق:

• valueOf بإرجاع مثيل جديد أو نسخة مخبأة مؤقتًا من Java.lang.Integer
• parseInt بإرجاع int.

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

حسنًا ، هناك نقطة مهمة يجب مراعاتها وهي أن المحلل اللغوي Integer يلقي 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 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;
}

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

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

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

الحل البديل هو استخدام Apache Commons ' NumberUtils:

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

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

Apache NumberUtils API Version 3.4

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

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

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

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

 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 كائنًا صحيحًا ، وجميع الطرق الأخرى - كثافة العمليات البدائية.

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

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

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

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

فمثلا:

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

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

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

يمكننا أيضًا استخدام toInt(String strValue) of NumberUtils Utility Class للتحويل:

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

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

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

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

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

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

بصرف النظر عن هذه الإجابات أعلاه ، أود أن أضيف العديد من الوظائف. هذه هي النتائج أثناء استخدامها:

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

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

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

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

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

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; 

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

• الخيار رقم 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

  catch (NumberFormatException ex) {
      integerValue = 0;
  }
  

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

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

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

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

للسلسلة العادية يمكنك استخدام:

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

ها نحن ذا

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

لقد اندهشت قليلاً من عدم ذكر أي منشئ Integer الذي يأخذ String كمعلمة.
لذلك ، هنا:

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

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

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

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

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

استخدم Integer.parseInt () ووضعه داخل كتلة 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);
    }
 }

طريقة واحدة هي parseInt (سلسلة) بإرجاع int بدائية

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

الطريقة الثانية هي valueOf (String) بإرجاع كائن Integer () جديد.

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

يمكن القيام به في 7 طرق:

import com.google.common.primitives.Ints;
import org.Apache.commons.lang.math.NumberUtils;

String number = "999";

1) باستخدام Ints.tryParse:

int result = Ints.tryParse(number);

2) باستخدام NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) باستخدام NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) باستخدام Integer.valueOf:

Integer result = Integer.valueOf(number);

5) باستخدام Integer.parseInt:

int result = Integer.parseInt(number);

6) باستخدام Integer.decode:

int result = Integer.decode(number);

7) باستخدام Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

يمكنك استخدام أي مما يلي:

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)

بالمناسبة ، كن على علم أنه إذا كانت السلسلة خالية ، فستكون المكالمة:

int i = Integer.parseInt(null);

يلقي NumberFormatException ، وليس NullPointerException.

import Java.util.*;

public class strToint {

    public static void main(String[] args) {

        String str = "123";
        byte barr[] = str.getBytes();

        System.out.println(Arrays.toString(barr));
        int result = 0;

        for(int i = 0; i < barr.length; i++) {
            //System.out.print(barr[i]+" ");
            int ii = barr[i];
            char a = (char) ii;
            int no = Character.getNumericValue(a);
            result = result * 10 + no;
            System.out.println(result);
        }

        System.out.println("result:"+result);
    }
}

Integer.parseInt(myString); - باستخدام فئة المجمع

العامة ثابت ثابت parseInt (سلسلة) يلقي NumberFormatException

يمكنك استخدام Integer.parseInt() لتحويل سلسلة إلى int.

تحويل سلسلة 20 إلى كثافة العمليات البدائية.

    String n = "20";
    int r = Integer.parseInt(n);//returns a primitive int       
    System.out.println(r);

انتاج 20

إذا كانت السلسلة لا تحتوي على عدد صحيح قابل للتحليل. سيتم طرحه NumberFormatException

String n = "20I";// throwns NumberFormatException
int r = Integer.parseInt(n);
System.out.println(r);

قيمة عدد صحيح ثابت ثابت (سلسلة) يلقي NumberFormatException

يمكنك استخدام Integer.valueOf() ، حيث تقوم بإرجاع كائن عدد صحيح.

String n = "20";
Integer r = Integer.valueOf(n); //returns a new Integer() object.   
System.out.println(r);

انتاج 20

المراجع https://docs.Oracle.com/en/

فيما يلي بعض الطرق لتحويل String إلى Int:

1. يمكنك استخدام Integer.parseInt():

   String test = "4568"; int new = Integer.parseInt(test);

2. كما يمكنك استخدام Integer.valueOf():

   String test = "4568"; int new =Integer.parseInt(test);

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

تطل على الاستثناء الذي يمكنها رميه ، استخدم هذا:

int i = Integer.parseInt(myString);

إذا كانت السلسلة التي يشير إليها المتغير myString هي عدد صحيح صالح مثل “1234”, “200”, “1”, وسيتم تحويله إلى int Java. إذا فشلت لأي سبب ، يمكن أن يلقي التغيير NumberFormatException ، لذلك يجب أن يكون الرمز أطول قليلاً في حساب هذا.

السابق. جافا String إلى int طريقة التحويل ، والتحكم في NumberFormatException ممكن

public class JavaStringToIntExample
{
  public static void main (String[] args)
  {
    // String s = "test";  // use this if you want to test the exception below
    String s = "1234";

    try
    {
      // the String to int conversion happens here
      int i = Integer.parseInt(s.trim());

      // print out the value after the conversion
      System.out.println("int i = " + i);
    }
    catch (NumberFormatException nfe)
    {
      System.out.println("NumberFormatException: " + nfe.getMessage());
    }
  }
}

إذا فشلت محاولة التغيير - في حالة ، إذا كان يمكنك محاولة تحويل اختبار Java String إلى int - ستؤدي عملية Integer parseInt إلى NumberFormatException ، والتي يجب عليك التعامل معها في كتلة try/catch.

يمكنك استخدامInteger.parseInt()الطريقة

مثال:

String strNumber = "5790";
int extractNumber = Integer.parseInt(strNumber);

//Result will be --5790
System.out.println(extractNumber);

خوارزمية مخصصة:

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  byte bytes[] = value.getBytes();
  for (int i = 0; i < bytes.length; i++) {
    char c = (char) bytes[i];
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

حل آخر: (استخدم السلسلة charAt الطريقة بدلاً من تحويل السلسلة إلى صفيف بايت):

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  for (int i = 0; i < value.length(); i++) {
    char c = value.charAt(i);
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

أمثلة:

int number1 = toInt("20");
int number2 = toInt("-20");
int number3 = toInt("+20");
System.out.println("Numbers = " + number1 + ", " + number2 + ", " + number3);

try {
  toInt("20 Hadi");
} catch (NumberFormatException e) {
  System.out.println("Error: " + e.getMessage());
}

باستخدام الطريقة: Integer.parseInt(String s)

String s = "123";
int n = Integer.parseInt(s);

استخدم Integer.parseInt() ، سيساعدك ذلك في تحليل قيمة السلسلة إلى int.

مثال:

String str = "2017";
int i = Integer.parseInt(str);
System.out.println(i);

الإخراج: 2017

استخدم هذه الطريقة:

public int ConvertStringToInt(String number) {
    int num = 0;

    try {
        int newNumber = Integer.ParseInt(number);
        num = newNumber;
    } catch(Exception ex) {
        num = 0;
        Log.i("Console",ex.toString);
    }

    return num;
}

جرب هذا الرمز مع مدخلات مختلفة من String:

String a = "10";  
String a = "10ssda";  
String a = null; 
String a = "12102";

if(null != a) {
    try {
        int x = Integer.ParseInt(a.trim()); 
        Integer y = Integer.valueOf(a.trim());
        //  It will throw a NumberFormatException in case of invalid string like ("10ssda" or "123 212") so, put this code into try catch
    } catch(NumberFormatException ex) {
        // ex.getMessage();
    }
}

لقد كتبت هذه الطريقة السريعة لتحليل إدخال السلسلة إلى int أو طويلة. إنه أسرع من الإصدار الحالي JDK 11 Integer.parseInt أو Long.parseLong. على الرغم من أنك طلبت فقط الباحث int ، فقد قمت أيضًا بتضمين المحلل اللغوي الطويل. يتطلب محلل الشفرة أدناه أن تكون طريقة المحلل صغيرة بحيث تعمل بسرعة. إصدار بديل أقل من رمز الاختبار. النسخة البديلة سريعة جدًا ولا تعتمد على حجم الفصل.

تحقق هذه الفئة من التدفق الزائد ويمكنك تخصيص الكود للتكيف مع احتياجاتك. سوف تسفر سلسلة فارغة عن طريقتي لكن هذا عن قصد. يمكنك تغيير ذلك لتكييف قضيتك أو استخدامها كما هي.

هذا فقط جزء الفصل حيث هناك حاجة إلى parseInt و parseLong. لاحظ أن هذا يتعامل فقط مع أرقام 10 الأساسية.

رمز اختبار المحلل اللغوي int أسفل الرمز أدناه.

/*
 * Copyright 2019 Khang Hoang Nguyen
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * @author: Khang Hoang Nguyen - [email protected]
 **/
final class faiNumber{        
    private static final long[] longpow = {0L, 1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L,
                                           10000000000L, 100000000000L, 1000000000000L, 10000000000000L, 100000000000000L,
                                           1000000000000000L, 10000000000000000L, 100000000000000000L, 1000000000000000000L,
                                           };

    private static final int[] intpow = { 0, 1, 10, 100, 1000, 10000,
                                          100000, 1000000, 10000000, 100000000, 1000000000 
                                        };

    /**
     * parseLong(String str) parse a String into Long. 
     * All errors throw by this method is NumberFormatException.
     * Better errors can be made to tailor to each use case.
     **/
    public static long parseLong(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0L;        

        char c1 = str.charAt(0); int start;

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }
        /*
         * Note: if length > 19, possible scenario is to run through the string 
         * to check whether the string contains only valid digits.
         * If the check had only valid digits then a negative sign meant underflow, else, overflow.
         */
        if ( length - start > 19 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );

        long c; 
        long out = 0L;

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            out += c * longpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1L;
            // if out > 0 number underflow(supposed to be negative).
            if ( out > 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            return out;
        }
        // if out < 0 number overflow(supposed to be positive).
        if ( out < 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
        return out;
    }

    /**
     * parseInt(String str) parse a string into an int.
     * return 0 if string is empty. 
     **/
    public static int parseInt(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0;        

        char c1 = str.charAt(0); int start; 

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }

        int out = 0; int c;
        int runlen = length - start;

        if ( runlen > 9 ) {
            if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

            c = (str.charAt(start) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start++];
        }

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1;
            if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            return out;
        }

        if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }
}

قسم كود الاختبار. هذا يجب أن يستغرق حوالي 200 ثانية أو نحو ذلك.

// Int Number Parser Test;
long start = System.currentTimeMillis();    
System.out.println("INT PARSER TEST");
for (int i = Integer.MIN_VALUE; i != Integer.MAX_VALUE; i++){
   if( faiNumber.parseInt(""+i) != i ) System.out.println("Wrong");
   if ( i == 0 ) System.out.println("HalfWay Done");
}

if( faiNumber.parseInt(""+Integer.MAX_VALUE) != Integer.MAX_VALUE ) System.out.println("Wrong");
long end = System.currentTimeMillis();
long result = (end - start);
System.out.println(result);        
// INT PARSER END */

طريقة بديلة وهي أيضًا سريعة جدًا. لاحظ أنه لا يتم استخدام مجموعة من pow ولكن تحسين رياضي للضرب في 10 بت إزاحة بت.

public static int parseInt(final String str) { 
    final int length = str.length();
    if ( length == 0 ) return 0;        

    char c1 = str.charAt(0); int start; 

    if ( c1 == '-' || c1 == '+' ){
        if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
        start = 1;
    } else {
        start = 0;
    }

    int out = 0; int c;
    while( start < length && str.charAt(start) == '0' ) start++; // <-- This to disregard leading 0, can be removed if you know exactly your source does not have leading zeroes.
    int runlen = length - start;

    if ( runlen > 9 ) {
        if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

        c = (str.charAt(start++) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; // <- alternatively this can just be out = c or c above can just be out;
    }

    for ( ; start < length; start++){
        c = (str.charAt(start) ^ '0');
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; 
    }

    if ( c1 == '-' ){
        out = ~out + 1;
        if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }

    if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
    return out;
}