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
.
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)
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-cacheparseInt
mengembalikan primitif int
. Hal yang sama berlaku 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 mengurai sesuatu secara dinamis.
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;
}
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:
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.
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.
Mengubah string ke int lebih rumit daripada hanya mengonversi angka. Anda telah memikirkan masalah-masalah berikut:
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 .
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);
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
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));
}
}
}
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);
Guava memiliki tryParse (String) , yang mengembalikan null
jika string tidak dapat diuraikan, misalnya:
Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
...
}
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.
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
}
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.
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;
}
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;
}
Jika Anda mengharapkan spasi putih sebelum atau setelah angka-angka ini, Lalu pastikan untuk melakukan str = str.trim()
sebelum memproses lebih lanjut.
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;
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.
Anda dapat menggunakan new Scanner("1244").nextInt()
. Atau tanyakan apakah ada int: new Scanner("1244").hasNextInt()
int foo=Integer.parseInt("1234");
Pastikan tidak ada data non-numerik di string.
Untuk string normal, Anda dapat menggunakan:
int number = Integer.parseInt("1234");
Untuk pembuat String dan buffer String Anda dapat menggunakan:
Integer.parseInt(myBuilderOrBuffer.toString());
Cukup Anda bisa mencoba ini:
Integer.parseInt(your_string);
untuk mengonversi String
menjadi int
Double.parseDouble(your_string);
untuk mengonversi String
menjadi 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
Kita mulai
String str="1234";
int number = Integer.parseInt(str);
print number;//1234
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);
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);
}
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);
}
}
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);
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;
}
}
Integer.parseInt(myString);
- menggunakan kelas wrapper
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);
Omong-omong, ketahuilah bahwa jika stringnya null, panggilan:
int i = Integer.parseInt(null);
melempar NumberFormatException, bukan NullPointerException.
Anda dapat menggunakan salah satu dari yang berikut:
Integer.parseInt(s)
Integer.parseInt(s, radix)
Integer.parseInt(s, beginIndex, endIndex, radix)
Integer.parseUnsignedInt(s)
Integer.parseUnsignedInt(s, radix)
Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
Integer.valueOf(s)
Integer.valueOf(s, radix)
Integer.decode(s)
NumberUtils.toInt(s)
NumberUtils.toInt(s, defaultValue)
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);
}
}
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/
Beberapa cara untuk mengonversi String
menjadi Int
adalah sebagai berikut:
anda dapat menggunakan Integer.parseInt()
:
String test = "4568"; int new = Integer.parseInt(test);
anda juga dapat menggunakan Integer.valueOf()
:
String test = "4568"; int new =Integer.parseInt(test);
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.
Anda dapat menggunakan metode parseInt
String SrNumber="5790";
int extractNumber = Integer.parseInt(SrNumber);
System.out.println(extractNumber);//Result will be --5790
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());
}
Menggunakan metode: Integer.parseInt(String s)
String s = "123";
int n = Integer.parseInt(s);
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
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;
}
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();
}
}
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;
}