Como faço para converter uma String em um int em Java?

Como posso converter um Stringpara um intem Java?

Minha String contém apenas números e eu quero retornar o número que representa.

Por exemplo, dada a string, "1234"o resultado deve ser o número 1234.

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

Se você olhar para a documentação em Java, perceberá que o "problema" é que essa função pode NumberFormatExceptiongerar um , que é claro que você precisa lidar com:

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

(Esse tratamento assume como padrão um número incorreto 0, mas você pode fazer outra coisa, se quiser.)

Como alternativa, você pode usar um Intsmétodo da biblioteca Guava, que em combinação com os Java 8 Optional, cria uma maneira poderosa e concisa de converter uma string em um int:

import com.google.common.primitives.Ints;

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

Por exemplo, aqui estão duas maneiras:

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

Há uma pequena diferença entre estes métodos:

• valueOf retorna uma instância nova ou em cache de java.lang.Integer
• parseIntretorna primitivo int.

O mesmo é para todos os casos: Short.valueOf/ parseShort, Long.valueOf/ parseLong, etc.

Bem, um ponto muito importante a considerar é que o analisador de números inteiros lança NumberFormatException conforme declarado em 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.
}

É importante lidar com essa exceção ao tentar obter valores inteiros a partir de argumentos de divisão ou analisar algo dinamicamente.

Faça manualmente:

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

Uma solução alternativa é usar o NumberUtils do Apache Commons :

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

O utilitário Apache é bom, porque se a string for um formato de número inválido, 0 será sempre retornado. Portanto, poupando o bloco try catch.

API do Apache NumberUtils versão 3.4

Atualmente, estou fazendo uma tarefa para a faculdade, onde não posso usar certas expressões, como as acima, e, olhando a tabela ASCII, consegui fazê-lo. É um código muito mais complexo, mas pode ajudar outras pessoas que são restritas como eu.

A primeira coisa a fazer é receber a entrada, neste caso, uma sequência de dígitos; Vou chamá-lo String numbere, neste caso, vou exemplificá-lo usando o número 12, portantoString number = "12";

Outra limitação foi o fato de eu não poder usar ciclos repetitivos; portanto, um forciclo (o que teria sido perfeito) também não pode ser usado. Isso nos limita um pouco, mas, novamente, esse é o objetivo. Como eu só precisava de dois dígitos (pegando os dois últimos), um simples charAtresolveu:

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

Tendo os códigos, precisamos apenas olhar para a tabela e fazer os ajustes necessários:

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

Agora, por que dobrar? Bem, por causa de um passo realmente "estranho". Atualmente, temos duas duplas, 1 e 2, mas precisamos transformá-la em 12, não há nenhuma operação matemática que possamos fazer.

Estamos dividindo o último (lastdigit) por 10 da maneira 2/10 = 0.2(daí o dobro) assim:

 lastdigit = lastdigit/10;

Isso é apenas brincar com números. Estávamos transformando o último dígito em um decimal. Mas agora, veja o que acontece:

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

Sem nos aprofundarmos na matemática, estamos simplesmente isolando as unidades com os dígitos de um número. Veja bem, uma vez que consideramos apenas 0-9, dividir por um múltiplo de 10 é como criar uma "caixa" onde você a armazena (pense em quando seu professor da primeira série explicou como uma unidade e uma centena eram). Assim:

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

E lá vai você. Você transformou uma String de dígitos (neste caso, dois dígitos) em um número inteiro composto por esses dois dígitos, considerando as seguintes limitações:

• Sem ciclos repetitivos
• Nenhuma expressão "mágica", como parseInt

Integer.decode

Você também pode usar public static Integer decode(String nm) throws NumberFormatException.

Também funciona para as bases 8 e 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

Se você deseja obter em intvez de, Integerpode usar:

1. Desembalagem:

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

2. intValue():

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

Sempre que houver a menor possibilidade de que a String especificada não contenha um Número Inteiro, você deve lidar com esse caso especial. Infelizmente, os métodos Java padrão Integer::parseInte Integer::valueOflançamos um NumberFormatExceptionpara sinalizar esse caso especial. Portanto, você deve usar exceções para controle de fluxo, que geralmente é considerado um estilo de codificação ruim.

Na minha opinião, este caso especial deve ser tratado retornando um vazio Optional<Integer>. Como o Java não oferece esse método, eu uso o seguinte wrapper:

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

Exemplo de uso:

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

Enquanto isso ainda usa exceções para controle de fluxo internamente, o código de uso fica muito limpo. Além disso, é possível distinguir claramente o caso em que -1é analisado como um valor válido e o caso em que uma String inválida não pôde ser analisada.

Converter uma string em um int é mais complicado do que apenas converter um número. Você pensou nos seguintes problemas:

• A cadeia contém apenas os números de 0 a 9 ?
• O que há com - / + antes ou depois da string? Isso é possível (referindo-se a números contábeis)?
• O que há com MAX _- / MIN_INFINITY? O que acontecerá se a sequência for 99999999999999999999? A máquina pode tratar essa string como um int?

Métodos para fazer isso:

 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 produz o objeto Inteiro, todos os outros métodos - int primitivo.

Últimos 2 métodos de commons-lang3 e grande artigo sobre a conversão aqui .

Podemos usar o parseInt(String str)método da Integerclasse wrapper para converter um valor String em um valor inteiro.

Por exemplo:

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

A Integerclasse também fornece o valueOf(String str)método:

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

Podemos também usar toInt(String strValue)de NumberUtils Utility Classe para a conversão:

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

Use Integer.parseInt(yourString).

Lembre-se do seguinte:

Integer.parseInt("1"); // Está bem

Integer.parseInt("-1"); // Está bem

Integer.parseInt("+1"); // Está bem

Integer.parseInt(" 1"); // Exceção (espaço em branco)

Integer.parseInt("2147483648");// Exceção (número inteiro é limitado a um valor máximo de 2.147.483.647)

Integer.parseInt("1.1");// Exceção ( . Ou , ou o que não for permitido)

Integer.parseInt(""); // Exceção (não 0 ou algo assim)

Há apenas um tipo de exceção: NumberFormatException

Eu tenho uma solução, mas não sei como é eficaz. Mas funciona bem, e acho que você poderia melhorá-lo. Por outro lado, fiz alguns testes com o JUnit, que foram executados corretamente. Anexei a função e teste:

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

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

O Google Guava possui tryParse (String) , que retorna nullse a string não puder ser analisada, por exemplo:

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

Você também pode começar removendo todos os caracteres não numéricos e analisando o número inteiro:

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

Mas lembre-se de que isso funciona apenas para números não negativos.

Além das respostas anteriores, gostaria de adicionar várias funções. Estes são os resultados enquanto você os utiliza:

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
}

Implementação:

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

Como mencionado, o Apache Commons ' NumberUtilspode fazê-lo. Retorna 0se não puder converter uma string em um int.

Você também pode definir seu próprio valor padrão:

NumberUtils.toInt(String str, int defaultValue)

Exemplo:

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;

Você também pode usar esse código, com algumas precauções.

• Opção 1: manipule explicitamente a exceção, por exemplo, mostrando uma caixa de diálogo de mensagem e pare a execução do fluxo de trabalho atual. Por exemplo:

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

• Opção 2: redefina a variável afetada se o fluxo de execução puder continuar no caso de uma exceção. Por exemplo, com algumas modificações no bloco catch

  catch (NumberFormatException ex) {
      integerValue = 0;
  }

Usar uma constante de string para comparação ou qualquer tipo de computação é sempre uma boa idéia, porque uma constante nunca retorna um valor nulo.

Você pode usar new Scanner("1244").nextInt(). Ou pergunte se existe um int:new Scanner("1244").hasNextInt()

Nas competições de programação, onde você tem certeza de que o número sempre será um número inteiro válido, você pode escrever seu próprio método para analisar a entrada. Isso ignorará todo o código relacionado à validação (já que você não precisa disso) e será um pouco mais eficiente.

1. Para um número inteiro positivo positivo:

   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. Para números inteiros positivos e negativos:

   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. Se você espera um espaço em branco antes ou depois desses números, faça um str = str.trim()antes de processar mais.

Simplesmente você pode tentar isso:

• Use Integer.parseInt(your_string);para converter um Stringparaint
• Use Double.parseDouble(your_string);para converter um Stringparadouble

Exemplo

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

Para uma sequência normal, você pode usar:

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

Para um construtor String e um buffer String, você pode usar:

Integer.parseInt(myBuilderOrBuffer.toString());

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

Verifique se não há dados não numéricos na sequência.

Estou um pouco surpreso que ninguém tenha mencionado o construtor Integer que usa String como parâmetro.

Então aqui está:

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

Java 8 - Inteiro (String) .

Obviamente, o construtor retornará o tipo Integere uma operação de unboxing converte o valor em int.

É importante mencionar : Este construtor chama o parseIntmétodo.

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

Use Integer.parseInt () e coloque-o dentro de um try...catchbloco para manipular quaisquer erros, caso um caractere não numérico seja inserido, por exemplo,

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

Aqui vamos nós

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

Isso pode ser feito de sete maneiras:

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

String number = "999";

1) Usando Ints.tryParse:

int result = Ints.tryParse(number);

2) Usando NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) Usando NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) Usando Integer.valueOf:

Integer result = Integer.valueOf(number);

5) Usando Integer.parseInt:

int result = Integer.parseInt(number);

6) Usando Integer.decode:

int result = Integer.decode(number);

7) Usando Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

Um método é parseInt (String). Retorna um int primitivo:

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

O segundo método é valueOf (String) e retorna um novo objeto Integer ():

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

Você pode usar qualquer um dos seguintes:

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)

Este é um programa completo com todas as condições positivas e negativas sem usar uma biblioteca

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