it-swarm-id.com

Bagaimana cara mengonversi String ke int di Java?

Bagaimana saya bisa mengonversi String menjadi int di Jawa?

String saya hanya berisi angka, dan saya ingin mengembalikan nomor yang diwakilinya.

Misalnya, mengingat string "1234" hasilnya harus berupa angka 1234.

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

Jika Anda melihat Java Documentation Anda akan melihat "tangkapan" adalah bahwa fungsi ini dapat membuang NumberFormatException, yang tentu saja harus Anda tangani:

int foo;
try {
   foo = Integer.parseInt(myString);
}
catch (NumberFormatException e)
{
   foo = 0;
}

(Perawatan ini default nomor cacat ke 0, tetapi Anda dapat melakukan sesuatu yang lain jika Anda suka.)

Atau, Anda dapat menggunakan metode Ints dari perpustakaan Guava, yang dikombinasikan dengan Optional Java 8, membuat cara yang kuat dan ringkas untuk mengubah string menjadi int:

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)
3787
Rob Hruska

Sebagai contoh, berikut adalah dua cara:

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

Ada sedikit perbedaan antara metode ini: 

  • valueOf mengembalikan instance Java.lang.Integer yang baru atau di-cache
  • parseInt mengembalikan primitif int

Hal yang sama berlaku untuk semua kasus: Short.valueOf/parseShort, Long.valueOf/parseLong, dll.

629
smas

Nah, poin yang sangat penting untuk dipertimbangkan adalah bahwa parser Integer melempar NumberFormatException seperti yang dinyatakan dalam 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.
}

Penting untuk menangani pengecualian ini ketika mencoba untuk mendapatkan nilai integer dari argumen split atau mengurai sesuatu secara dinamis.

230
Ali Akdurak

Lakukan secara manual:

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

Saat ini saya sedang mengerjakan tugas untuk kuliah, di mana saya tidak bisa menggunakan ekspresi tertentu, seperti yang di atas, dan dengan melihat tabel ASCII, saya berhasil melakukannya. Ini kode yang jauh lebih kompleks, tetapi bisa membantu orang lain yang dibatasi seperti saya.

Hal pertama yang harus dilakukan adalah menerima input, dalam hal ini, serangkaian digit; Saya akan menyebutnya String number, dan dalam hal ini, saya akan mencontohkannya menggunakan angka 12, oleh karena itu String number = "12";

Keterbatasan lain adalah kenyataan bahwa saya tidak dapat menggunakan siklus berulang, oleh karena itu, siklus for (yang seharusnya sempurna) tidak dapat digunakan juga. Ini membatasi kita sedikit, tetapi sekali lagi, itulah tujuannya. Karena saya hanya membutuhkan dua digit (mengambil dua digit terakhir), charAt sederhana menyelesaikannya:

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

Memiliki kode, kita hanya perlu melihat ke tabel, dan melakukan penyesuaian yang diperlukan:

 double semilastdigit = semilastdigitASCII - 48;  //A quick look, and -48 is the key
 double lastdigit = lastdigitASCII - 48;

Sekarang, mengapa ganda? Ya, karena langkah yang benar-benar "aneh". Saat ini kami memiliki dua ganda, 1 dan 2, tetapi kita perlu mengubahnya menjadi 12, tidak ada operasi matematika yang bisa kita lakukan.

Kami membagi yang terakhir (digit terakhir) dengan 10 dalam mode 2/10 = 0.2 (karenanya mengapa ganda) seperti ini:

 lastdigit = lastdigit/10;

Ini hanya bermain dengan angka. Kami mengubah digit terakhir menjadi desimal. Tapi sekarang, lihat apa yang terjadi:

 double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2

Tanpa terlalu banyak menghitung, kita hanya mengisolasi unit angka-angka. Anda tahu, karena kami hanya mempertimbangkan 0-9, membaginya dengan kelipatan 10 adalah seperti membuat "kotak" tempat Anda menyimpannya (pikirkan kembali ketika guru kelas satu Anda menjelaskan kepada Anda berapa satuan dan seratus satuan). Begitu:

 int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"

Dan begitulah. Anda mengubah sebuah String digit (dalam hal ini, dua digit), menjadi integer yang terdiri dari dua digit tersebut, dengan mempertimbangkan batasan berikut:

  • Tidak ada siklus berulang
  • Tidak ada Ekspresi "Ajaib" seperti parseInt
42
Oak

Solusi alternatif adalah dengan menggunakan Apache Commons ' NumberUtils:

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

Utilitas Apache bagus karena jika string adalah format angka yang tidak valid maka 0 selalu dikembalikan. Oleh karena itu menghemat blok coba tangkap.

Apache NumberUtils API Versi 3.4

40
Ryboflavin

Setiap kali ada kemungkinan sekecil apa pun bahwa String yang diberikan tidak mengandung Integer, Anda harus menangani kasing khusus ini. Sayangnya, metode Java standar Integer::parseInt dan Integer::valueOf melempar NumberFormatException untuk memberi sinyal kasus khusus ini. Dengan demikian, Anda harus menggunakan pengecualian untuk kontrol aliran, yang umumnya dianggap gaya pengkodean yang buruk.

Menurut pendapat saya, kasus khusus ini harus ditangani dengan mengembalikan Optional<Integer>. Karena Java tidak menawarkan metode seperti itu, saya menggunakan pembungkus berikut:

private Optional<Integer> tryParseInteger(String string) {
    try {
        return Optional.of(Integer.valueOf(string));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

Pemakaian:

// prints 1234
System.out.println(tryParseInteger("1234").orElse(-1));
// prints -1
System.out.println(tryParseInteger("foobar").orElse(-1));

Meskipun ini masih menggunakan pengecualian untuk kontrol aliran secara internal, kode penggunaan menjadi sangat bersih.

25
Stefan Dollase

Mengubah string ke int lebih rumit daripada hanya mengonversi angka. Anda telah memikirkan masalah-masalah berikut:

  • Apakah string hanya berisi angka 0-9?
  • Ada apa dengan -/+ sebelum atau setelah string? Apakah itu mungkin (mengacu pada nomor akuntansi)?
  • Ada apa dengan MAX _-/MIN_INFINITY? Apa yang akan terjadi jika stringnya adalah 99999999999999999999? Bisakah mesin memperlakukan string ini sebagai int?
23
Dennis Ahaus

Metode untuk melakukannya:

 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 menghasilkan objek Integer, semua metode lain - primitif int.

2 metode terakhir dari commons-lang3 dan artikel besar tentang konversi sini .

22

Kita dapat menggunakan metode parseInt(String str) dari kelas wrapper Integer untuk mengonversi nilai String ke nilai integer.

Sebagai contoh:

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

Kelas Integer juga menyediakan metode valueOf(String str):

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

Kita juga dapat menggunakan toInt(String strValue) dari NumberUtils Utility Class untuk konversi:

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

Gunakan Integer.parseInt(yourString)

Ingat hal-hal berikut:

Integer.parseInt("1");/ ok

Integer.parseInt("-1"); // ok

Integer.parseInt("+1"); // ok

Integer.parseInt(" 1"); // Pengecualian (ruang kosong)

Integer.parseInt("2147483648"); // Pengecualian (Integer terbatas pada nilai maksimum dari 2.147.483.647)

Integer.parseInt("1.1"); // Pengecualian (_ /. atau , atau apa pun yang tidak diizinkan)

Integer.parseInt(""); // Pengecualian (bukan 0 atau sesuatu)

Hanya ada satu jenis pengecualian: NumberFormatException

19
Lukas Bauer

Saya punya solusi, tetapi saya tidak tahu seberapa efektif itu. Tapi itu bekerja dengan baik, dan saya pikir Anda bisa memperbaikinya. Di sisi lain, saya melakukan beberapa tes dengan JUnit yang langkahnya benar. Saya lampirkan fungsi dan pengujian:

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

Pengujian dengan 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));
        }
    }
}
19
fitorec

Hanya untuk bersenang-senang: Anda dapat menggunakan Java 8's Optional untuk mengubah String menjadi 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.

Di sini kita hanya menggabungkan Integer.valueOf dan Optinal. Mungkin ada situasi saat ini berguna - misalnya ketika Anda ingin menghindari cek nol. Kode Pre Java 8 akan terlihat seperti ini:

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

Guava memiliki tryParse (String) , yang mengembalikan null jika string tidak dapat diuraikan, misalnya:

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

Anda juga dapat mulai dengan menghapus semua karakter non-numerik dan kemudian menguraikan int:

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

Tetapi berhati-hatilah karena ini hanya berfungsi untuk angka non-negatif. 

14
Thijser

Terlepas dari jawaban di atas, saya ingin menambahkan beberapa fungsi: 

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

Dan berikut ini adalah hasil saat Anda menjalankannya: 

  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
  }
12
nxhoaf

Dalam kompetisi pemrograman, di mana Anda yakin bahwa angka akan selalu bilangan bulat yang valid, maka Anda dapat menulis metode Anda sendiri untuk mengurai input. Ini akan melewati semua kode terkait validasi (karena Anda tidak memerlukan semua itu) dan akan sedikit lebih efisien.

  1. Untuk bilangan bulat positif yang valid:

    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. Untuk bilangan bulat positif dan negatif:

    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. Jika Anda mengharapkan spasi putih sebelum atau setelah angka-angka ini, Lalu pastikan untuk melakukan str = str.trim() sebelum memproses lebih lanjut.

9
Raman Sahasi

Seperti disebutkan Apache Commons NumberUtils dapat melakukannya. Yang mengembalikan 0 jika tidak dapat mengubah string ke int.

Anda juga dapat menentukan nilai default Anda sendiri.

NumberUtils.toInt(String str, int defaultValue)

contoh:

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; 
9
Alireza Fattahi

Anda juga dapat menggunakan kode ini, dengan beberapa tindakan pencegahan.

  • Opsi # 1: Tangani pengecualian secara eksplisit, misalnya, menampilkan dialog pesan dan kemudian hentikan eksekusi alur kerja saat ini. Sebagai contoh:

    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;
    }
    
  • Opsi # 2: Atur ulang variabel yang terpengaruh jika aliran eksekusi dapat dilanjutkan jika ada pengecualian. Misalnya, dengan beberapa modifikasi pada catch catch block

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

Menggunakan string konstan untuk perbandingan atau segala jenis komputasi selalu merupakan ide yang baik, karena sebuah konstanta tidak pernah mengembalikan nilai nol.

9
manikant gautam

Anda dapat menggunakan new Scanner("1244").nextInt(). Atau tanyakan apakah ada int: new Scanner("1244").hasNextInt()

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

Pastikan tidak ada data non-numerik di string.

7
iKing

Untuk string normal, Anda dapat menggunakan:

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

Untuk pembuat String dan buffer String Anda dapat menggunakan:

Integer.parseInt(myBuilderOrBuffer.toString());
7
Aditya

Cukup Anda bisa mencoba ini:

  • Gunakan Integer.parseInt(your_string); untuk mengonversi String menjadi int
  • Gunakan Double.parseDouble(your_string); untuk mengonversi String menjadi double

Contoh

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
7
Vishal Yadav

Kita mulai

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

Saya sedikit terkejut bahwa tidak ada yang tidak menyebutkan konstruktor Integer yang mengambil String sebagai parameter.
Jadi, ini adalah: 

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

Java 8 - Integer (String)

Tentu saja, konstruktor akan mengembalikan tipe Integer, dan operasi unboxing mengubah nilai menjadi int


Penting untuk menyebutkan
Konstruktor ini memanggil metode parseInt

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

Gunakan Integer.parseInt () dan letakkan di dalam blok try...catch untuk menangani kesalahan jika saja karakter non-numerik dimasukkan, misalnya,

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

Salah satu metode adalah parseInt (String) mengembalikan int primitif

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

Metode kedua adalah valueOf (String) mengembalikan objek Integer () baru.

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

Ini adalah program Lengkap dengan semua kondisi positif, negatif tanpa menggunakan perpustakaan  

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;
     }
    }
4
Anup Gupta

Integer.parseInt(myString); - menggunakan kelas wrapper

3
Phani Kumar

Dapat dilakukan dalam 5 cara:

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

1) Menggunakan Ints.tryParse:

String number = "999";
int result = Ints.tryParse(number);

2) Menggunakan NumberUtils.createInteger:

String number = "999";
Integer result = NumberUtils.createInteger(number);

3) Menggunakan NumberUtils.toInt:

String number = "999";
int result = NumberUtils.toInt(number);

4) Menggunakan Integer.valueOf:

String number = "999";
Integer result = Integer.valueOf(number);

5) Menggunakan Integer.parseInt:

String number = "999";
int result = Integer.parseInt(number);
3
Santosh Jadi

Omong-omong, ketahuilah bahwa jika stringnya null, panggilan:

int i = Integer.parseInt(null);

melempar NumberFormatException, bukan NullPointerException.

3
Pavel Molchanov

Anda dapat menggunakan salah satu dari yang berikut: 

  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)
2
Rajeev Ranjan

import Java.util. *;

strToint kelas publik {

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

}

2
Abhijeet Kale

public static int parseInt (String s) melempar NumberFormatException

anda dapat menggunakan Integer.parseInt() untuk mengonversi String ke int.

mengkonversi String 20 ke int primitif.

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

Output-20

jika string tidak mengandung integer parsable. itu akan dibuang NumberFormatException

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

public Integer valueOf (String s) melempar NumberFormatException

anda dapat menggunakan Integer.valueOf(), dalam hal ini ia akan mengembalikan objek Integer.

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

Output-20

Referensi https://docs.Oracle.com/en/

1

Beberapa cara untuk mengonversi String menjadi Int adalah sebagai berikut:

  1. anda dapat menggunakan Integer.parseInt():

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

  2. anda juga dapat menggunakan Integer.valueOf():

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

0

Konversikan string ke integer dengan metode parseInt dari kelas Java Integer. Metode parseInt adalah untuk mengonversi String ke int dan melempar NumberFormatException jika string tidak dapat dikonversi ke tipe int.

Menghadap pengecualian yang dapat dilemparkan, gunakan ini:

int i = Integer.parseInt(myString);

Jika String yang ditandai oleh variabel myString adalah bilangan bulat yang valid seperti “1234”, “200”, “1”, dan itu akan dikonversi ke int Java. Jika gagal karena alasan apa pun, perubahan tersebut dapat menyebabkan NumberFormatException, sehingga kode harus sedikit lebih lama untuk menjelaskan hal ini.

Ex. Java String ke int metode konversi, kontrol untuk kemungkinan 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());
    }
  }
}

Jika upaya perubahan gagal - dalam kasus, jika Anda dapat mencoba mengonversi uji Java String ke int - proses Integer parseInt akan melempar NumberFormatException, yang harus Anda tangani dalam blok try/catch.

0
Nisarg

Anda dapat menggunakan metode parseInt  

  String SrNumber="5790";
int extractNumber = Integer.parseInt(SrNumber);
System.out.println(extractNumber);//Result will be --5790
0

Algoritma khusus:

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

solusi lain: (gunakan string charAt metode alih-alih konversi string ke byte array):

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

Contoh:

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());
}
0
nabeghe

Menggunakan metode: Integer.parseInt(String s)

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

Gunakan Integer.parseInt(), ini akan membantu Anda dalam mengurai nilai string Anda ke int.

Contoh:

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

output: 2017

0
Alekya

Gunakan metode ini:

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;
}
0
mohamad sheikhi

Coba kode ini dengan input String berbeda:

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();
    }
}
0
Ram Chhabra

Saya menulis metode cepat ini untuk mem-parsing input string ke int atau panjang. Ini lebih cepat daripada JDK 11 Integer.parseInt atau Long.parseLong saat ini. Meskipun, Anda hanya meminta int, saya juga menyertakan pengurai panjang. Kode parser di bawah ini mengharuskan metode parser harus kecil agar dapat beroperasi dengan cepat. Versi alternatif ada di bawah kode uji. Versi alternatifnya cukup cepat dan tidak tergantung pada ukuran kelas.

Kelas ini memeriksa luapan dan Anda dapat menyesuaikan kode untuk menyesuaikan dengan kebutuhan Anda. String kosong akan menghasilkan 0 dengan metode saya tapi itu disengaja. Anda dapat mengubahnya untuk mengadaptasi case atau digunakan apa adanya. 

Ini hanya bagian dari kelas di mana parseInt dan parseLong diperlukan. Perhatikan bahwa ini hanya berurusan dengan angka dasar 10.

Kode tes untuk pengurai int di bawah kode di bawah ini. 

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

Bagian Kode Uji. Ini akan memakan waktu sekitar 200 detik atau lebih.

// 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 */

Metode alternatif yang juga sangat cepat. Perhatikan bahwa array pow int tidak digunakan tetapi optimasi matematis dari kalikan dengan 10 oleh sedikit bergeser.

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;
}
0
Kevin Ng