Bagaimana cara mengonversi String ke int di Java?

Bagaimana saya bisa mengonversi a Stringke intdalam Java?

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

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

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

Jika Anda melihat Dokumentasi Java Anda akan melihat "menangkap" adalah bahwa fungsi ini dapat melempar NumberFormatException, yang tentu saja Anda harus menangani:

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

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

Atau, Anda dapat menggunakan Intsmetode dari perpustakaan Guava, yang dikombinasikan dengan Java 8's Optional, 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)

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 baru atau dalam cache dari java.lang.Integer
• parseIntmengembalikan primitif int.

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

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 secara dinamis menguraikan sesuatu.

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

Solusi alternatif adalah menggunakan NumberUtils Apache Commons ' :

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

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 meneleponnya String number, dan dalam hal ini, saya akan mencontohkannya menggunakan nomor 12, oleh karena ituString number = "12";

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

 // 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 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 satuan 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 itu). Begitu:

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

Dan begitulah. Anda mengubah serangkaian digit (dalam hal ini, dua digit), menjadi bilangan bulat yang terdiri dari dua digit tersebut, dengan mempertimbangkan batasan berikut:

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

Integer.decode

Anda juga bisa menggunakan public static Integer decode(String nm) throws NumberFormatException.

Ini juga berfungsi untuk basis 8 dan 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

Jika Anda ingin mendapatkan intbukannya IntegerAnda dapat menggunakan:

1. Menghapus kotak:

   int val = Integer.decode("12"); 

2. intValue():

   Integer.decode("12").intValue();

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::parseIntdan Integer::valueOfmelempar NumberFormatExceptionuntuk 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 yang kosong 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();
    }
}

Contoh penggunaan:

// prints "12"
System.out.println(tryParseInteger("12").map(i -> i.toString()).orElse("invalid"));
// prints "-1"
System.out.println(tryParseInteger("-1").map(i -> i.toString()).orElse("invalid"));
// prints "invalid"
System.out.println(tryParseInteger("ab").map(i -> i.toString()).orElse("invalid"));

Meskipun ini masih menggunakan pengecualian untuk kontrol aliran secara internal, kode penggunaan menjadi sangat bersih. Selain itu, Anda dapat dengan jelas membedakan case -1yang diuraikan sebagai nilai yang valid dan case di mana String yang tidak valid tidak dapat diuraikan.

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?

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 di sini .

Kita bisa menggunakan parseInt(String str)metode Integerkelas wrapper untuk mengubah nilai String ke nilai integer.

Sebagai contoh:

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

The Integerkelas juga menyediakan valueOf(String str)metode:

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

Kita juga bisa menggunakan toInt(String strValue)dari NumberUtils Utilitas Kelas untuk konversi:

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

Gunakan Integer.parseInt(yourString).

Ingatlah hal-hal berikut:

Integer.parseInt("1"); // baik

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

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

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

Integer.parseInt("2147483648");// Pengecualian (Integer terbatas pada nilai maksimum 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

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

Google Guava memiliki tryParse (String) , yang kembali nulljika string tidak dapat diuraikan, misalnya:

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

Anda juga bisa mulai dengan menghapus semua karakter non-numerik dan kemudian menguraikan integer:

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

Tetapi berhati-hatilah karena ini hanya berfungsi untuk angka yang tidak negatif

Terlepas dari jawaban sebelumnya, saya ingin menambahkan beberapa fungsi. Ini adalah hasil saat Anda menggunakannya:

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
}

Penerapan:

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

Seperti yang disebutkan, Apache Commons NumberUtilsdapat melakukannya. Ia kembali0 jika tidak dapat mengkonversi 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;

Anda dapat menggunakan kode ini juga, 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: Setel 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 konstanta tidak pernah mengembalikan nilai nol.

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

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, maka pastikan untuk melakukan str = str.trim()sebelum memproses lebih lanjut.

Cukup Anda bisa mencoba ini:

• Gunakan Integer.parseInt(your_string);untuk mengonversi a Stringmenjadiint
• Gunakan Double.parseDouble(your_string);untuk mengonversi a Stringmenjadidouble

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

Untuk string normal, Anda dapat menggunakan:

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

Untuk pembuat String dan buffer String Anda dapat menggunakan:

Integer.parseInt(myBuilderOrBuffer.toString());

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

Pastikan tidak ada data non-numerik di string.

Saya sedikit terkejut bahwa tidak ada yang menyebutkan konstruktor Integer yang mengambil String sebagai parameter.

Jadi begini:

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 disebutkan : Konstruktor ini memanggil parseIntmetode.

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

Gunakan Integer.parseInt () dan letakkan di dalam try...catchblok untuk menangani kesalahan jika-kalau 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);
    }
 }

Kita mulai

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

Itu dapat dilakukan dengan tujuh cara:

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

String number = "999";

1) Menggunakan Ints.tryParse:

int result = Ints.tryParse(number);

2) Menggunakan NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) Menggunakan NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) Menggunakan Integer.valueOf:

Integer result = Integer.valueOf(number);

5) Menggunakan Integer.parseInt:

int result = Integer.parseInt(number);

6) Menggunakan Integer.decode:

int result = Integer.decode(number);

7) Menggunakan Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

Salah satu metode adalah parseInt (String). Ia mengembalikan int primitif:

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

Metode kedua adalah valueOf (String), dan mengembalikan objek Integer () baru:

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

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)

Ini adalah program lengkap dengan semua kondisi positif dan 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;
    }
}