Bir String'i Java'da int'e nasıl dönüştürebilirim?

Nasıl dönüştürebilirsiniz Stringbir etmek intJava?

Dizem yalnızca sayılar içeriyor ve temsil ettiği sayıyı döndürmek istiyorum.

Örneğin, dize "1234"verildiğinde sonuç sayı olmalıdır 1234.

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

Java Belgelerine bakarsanız , "yakala" nın bu işlevin a atabildiğini fark edersiniz, ki bu NumberFormatExceptionelbette ele almanız gerekir:

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

(Bu tedavi varsayılan olarak hatalı biçimlendirilmiş bir sayıdır 0, ancak isterseniz başka bir şey yapabilirsiniz.)

Alternatif olarak, IntsJava 8'lerle birlikte Optionalbir dizeyi int'ye dönüştürmek için güçlü ve özlü bir yol sağlayan Guava kütüphanesinden bir yöntem kullanabilirsiniz :

import com.google.common.primitives.Ints;

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

Örneğin, işte iki yol:

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

Bu yöntemler arasında küçük bir fark vardır:

• valueOf yeni veya önbelleğe alınmış bir örneğini döndürür java.lang.Integer
• parseIntilkel döner int.

Aynı durum tüm durumlar için geçerlidir: Short.valueOf/ parseShort, Long.valueOf/ parseLong, vb.

Dikkate alınması gereken çok önemli bir nokta, Tamsayı ayrıştırıcısının Javadoc'da belirtildiği gibi NumberFormatException öğesini atmasıdır .

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

Bölünmüş bağımsız değişkenlerden tamsayı değerleri almaya çalışırken veya bir şeyi dinamik olarak ayrıştırırken bu istisnayı ele almak önemlidir.

Manuel olarak yapın:

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

Alternatif bir çözüm, Apache Commons ' NumberUtils ' i kullanmaktır :

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

Apache yardımcı programı iyidir çünkü dize geçersiz bir sayı biçimindeyse 0 her zaman döndürülür. Böylece try catch bloğunu kurtarırsınız.

Apache NumberUtils API Sürüm 3.4

Şu anda kolej için bir görev yapıyorum, yukarıdaki gibi bazı ifadeleri kullanamıyorum ve ASCII tablosuna bakarak bunu başardım. Çok daha karmaşık bir kod, ama benim gibi kısıtlanmış başkalarına yardımcı olabilir.

Yapılacak ilk şey, girdiyi, bu durumda bir basamak dizisini almaktır; Onu arayacağım String numberve bu durumda, 12 sayısını kullanarak örnekleyeceğim, bu nedenleString number = "12";

Başka bir sınırlama, tekrarlayan döngüler kullanamadığımdı, bu nedenle for(mükemmel olurdu) bir döngü de kullanılamaz. Bu bizi biraz sınırlıyor, ama yine de amaç bu. Sadece iki basamağa ihtiyacım olduğu için (son iki basamağı alarak), basit bir charAtçözüldü:

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

Kodlara sahip olmak için, sadece masaya bakmamız ve gerekli ayarlamaları yapmamız gerekiyor:

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

Şimdi neden iki katına çıktınız? Gerçekten "tuhaf" bir adım yüzünden. Şu anda 1 ve 2 olmak üzere iki katına sahibiz, ancak 12'ye çevirmemiz gerekiyor, yapabileceğimiz herhangi bir matematik işlemi yok.

İkincisini (son basamak) şu şekilde 10'a böleriz 2/10 = 0.2(bu yüzden neden iki katına çıkar):

 lastdigit = lastdigit/10;

Bu sadece sayılarla oynuyor. Son basamağı ondalık sayıya çeviriyorduk. Ama şimdi, neler olduğuna bakın:

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

Matematiğe fazla girmeden, bir sayının hanelerini birimleri izole ediyoruz. Gördüğünüz gibi, sadece 0-9'u düşündüğümüz için, 10'un katlarına bölmek, onu sakladığınız bir "kutu" oluşturmak gibidir (birinci sınıf öğretmeninizin size bir birimin ve yüzün ne olduğunu açıkladığını düşünün). Yani:

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

Ve işte gidiyorsun. Aşağıdaki sınırlamaları göz önünde bulundurarak bir dizi rakamı (bu örnekte iki rakam) bu iki rakamdan oluşan bir tam sayıya dönüştürdünüz:

• Tekrarlanan döngü yok
• ParseInt gibi "Sihirli" İfadeler Yok

Integer.decode

Ayrıca kullanabilirsiniz public static Integer decode(String nm) throws NumberFormatException.

Ayrıca taban 8 ve 16 için de çalışır:

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

intBunun yerine almak Integeristiyorsanız şunları kullanabilirsiniz:

1. Unboxing:

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

2. intValue():

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

Verilen Dize'nin bir Tamsayı içermemesi ihtimali en düşük olduğunda, bu özel durumu ele almanız gerekir. Ne yazık ki, standart Java yöntemleri Integer::parseIntve a Integer::valueOfatmak için NumberFormatExceptionbu özel durum sinyali. Bu nedenle, genellikle kötü kodlama stili olarak kabul edilen akış kontrolü için istisnalar kullanmanız gerekir.

Kanımca, bu özel durum boş bir iade edilerek ele alınmalıdır Optional<Integer>. Java böyle bir yöntem sunmadığından, aşağıdaki sarmalayıcıyı kullanıyorum:

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

Örnek kullanım:

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

Bu, dahili olarak akış kontrolü için istisnalar kullanırken, kullanım kodu çok temiz hale gelir. Ayrıca, -1geçerli bir değer olarak ayrıştırıldığı durumu ve geçersiz bir Dizenin ayrıştırılamadığı durumu açıkça ayırt edebilirsiniz .

Bir dizgiyi int'ye dönüştürmek, bir sayıyı dönüştürmekten daha karmaşıktır. Aşağıdaki konuları düşünüyorsunuz:

• Dize yalnızca 0-9 arası sayılar içeriyor mu?
• Dizeden önce veya sonra - / + ile ilgili neler var ? Bu mümkün mü (muhasebe numaralarına atıfla)?
• MAX _- / MIN_INFINITY ile ilgili neler var ? Dize 99999999999999999999 ise ne olur? Makine bu dizgeyi int olarak değerlendirebilir mi?

Bunu yapmak için yöntemler:

 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, diğer tüm yöntemler - ilkel int.

Commons-lang3'ten son 2 yöntem ve buraya dönüştürmeyle ilgili büyük makale .

Bir String değerini bir tamsayı değerine dönüştürmek parseInt(String str)için Integerwrapper sınıfının yöntemini kullanabiliriz .

Örneğin:

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

IntegerSınıf ayrıca aşağıdakileri sağlar valueOf(String str): yöntemi

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

Ayrıca kullanabilirsiniz toInt(String strValue)ait NumberUtils Utility Sınıf dönüşüm için:

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

Kullanın Integer.parseInt(yourString).

Aşağıdakileri hatırlayın:

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

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

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

Integer.parseInt(" 1"); // İstisna (boşluk)

Integer.parseInt("2147483648");// İstisna (Tamsayı maksimum 2.147.483.647 değerle sınırlıdır )

Integer.parseInt("1.1");// İstisna ( . Veya , veya izin verilmeyen her şey)

Integer.parseInt(""); // İstisna (0 değil falan)

Yalnızca bir tür istisna vardır: NumberFormatException

Bir çözümüm var, ama ne kadar etkili olduğunu bilmiyorum. Ama iyi çalışıyor ve bence geliştirebilirsin. Öte yandan, JUnit ile doğru adım atan birkaç test yaptım . Ben fonksiyonu ve test ekledi:

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 ile test:

@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 sahiptir TryParse (String) dönerse, nulldize örneğin ayrıştırılamadı eğer:

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

Ayrıca, sayısal olmayan tüm karakterleri kaldırarak ve ardından tamsayıyı ayrıştırarak da başlayabilirsiniz:

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

Ancak bunun yalnızca negatif olmayan sayılar için geçerli olduğuna dikkat edin.

Önceki cevapların dışında, birkaç fonksiyon eklemek istiyorum. Bunlar, bunları kullanırken elde edilen sonuçlardır:

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
}

Uygulama:

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

Belirtildiği gibi, Apache Commons NumberUtilsbunu yapabilir. 0Bir dizgiyi int biçimine dönüştüremezse döner .

Kendi varsayılan değerinizi de tanımlayabilirsiniz:

NumberUtils.toInt(String str, int defaultValue)

Misal:

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;

Bu kodu bazı önlemlerle de kullanabilirsiniz.

• Seçenek # 1: Örneğin, bir ileti iletişim kutusu göstererek istisnayı açıkça kullanın ve ardından geçerli iş akışının yürütülmesini durdurun. Örneğin:

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

• Seçenek # 2: İstisna durumunda yürütme akışı devam ederse etkilenen değişkeni sıfırlayın. Örneğin, catch bloğundaki bazı değişikliklerle

  catch (NumberFormatException ex) {
      integerValue = 0;
  }

Karşılaştırma veya herhangi bir bilgi işlem için bir dize sabiti kullanmak her zaman iyi bir fikirdir, çünkü sabit hiçbir zaman boş değer döndürmez.

Kullanabilirsiniz new Scanner("1244").nextInt(). Veya bir int var olup olmadığını sorun:new Scanner("1244").hasNextInt()

Bu sayının her zaman geçerli bir tamsayı olacağından emin olduğunuz programlama yarışmalarında, girdiyi ayrıştırmak için kendi yönteminizi yazabilirsiniz. Bu, doğrulama ile ilgili tüm kodu atlayacaktır (bunlardan herhangi birine ihtiyacınız olmadığından) ve biraz daha verimli olacaktır.

1. Geçerli pozitif tamsayı için:

   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. Hem pozitif hem de negatif tamsayılar için:

   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. Bu sayılardan önce veya sonra bir boşluk bekliyorsanız, daha str = str.trim()fazla işlem yapmadan önce bir boşluk yaptığınızdan emin olun .

Bunu basitçe deneyebilirsiniz:

• A Integer.parseInt(your_string);dönüştürmek için Stringkullanınint
• A Double.parseDouble(your_string);dönüştürmek için Stringkullanındouble

Misal

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

Normal bir dize için şunları kullanabilirsiniz:

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

Bir String oluşturucu ve String buffer için şunları kullanabilirsiniz:

Integer.parseInt(myBuilderOrBuffer.toString());

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

Dizede sayısal olmayan veri olmadığından emin olun.

Kimsenin String'i parametre olarak alan Integer yapıcısından bahsetmediğine biraz şaşırdım.

İşte burada:

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

Java 8 - Tamsayı (Dize) .

Tabii ki, yapıcı türü döndürür Integerve bir kutudan çıkarma işlemi değeri olarak dönüştürür int.

Bahsetmek önemlidir : Bu kurucu parseIntyöntemi çağırır .

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

Integer.parseInt () kullanın ve try...catchsayısal olmayan bir karakter girilmesi durumunda hataları işlemek için bir bloğun içine yerleştirin.

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

İşte başlıyoruz

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

Yedi şekilde yapılabilir:

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

String number = "999";

1) kullanma Ints.tryParse:

int result = Ints.tryParse(number);

2) kullanma NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) kullanma NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) kullanma Integer.valueOf:

Integer result = Integer.valueOf(number);

5) kullanma Integer.parseInt:

int result = Integer.parseInt(number);

6) kullanma Integer.decode:

int result = Integer.decode(number);

7) kullanma Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

Bir yöntem parseInt (String) yöntemidir. İlkel bir int döndürür:

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

İkinci yöntem valueOf (String) 'dir ve yeni bir Integer () nesnesi döndürür:

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

Aşağıdakilerden herhangi birini kullanabilirsiniz:

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)

Bu, kütüphane kullanmadan tüm koşulların olumlu ve olumsuz olduğu eksiksiz bir programdır

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