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

Como posso converter uma String para um int em Java?

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

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

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

Veja a Documentação Java para mais informações.

Por exemplo, aqui estão duas maneiras:

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

Existe uma ligeira diferença entre estes methods:

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

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

Bem, um ponto muito importante a ser considerado é que o analisador Integer lança NumberFormatException conforme declarado no 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 manipular essa exceção ao tentar obter valores inteiros de argumentos divididos ou analisar dinamicamente algo.

Faça isso 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; } 

Atualmente estou fazendo uma tarefa para a faculdade, onde não posso usar certas expressões, como as acima, e olhando para a tabela ASCII, consegui fazer isso. É um código muito mais complexo, mas pode ajudar outros que são restritos como eu.

A primeira coisa a fazer é receber a input, neste caso, uma cadeia de dígitos; Vou chamá-lo de String number e, neste caso, exemplificarei usando o número 12, portanto String number = "12";

Outra limitação foi o fato de que eu não poderia usar ciclos repetitivos, portanto, um ciclo (que seria perfeito) também não pode ser usado. Isso nos limita um pouco, mas, novamente, esse é o objective. Como eu só precisava de dois dígitos (pegando os dois últimos dígitos), um simples caractere resolveu:

  // 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, só precisamos olhar para a mesa 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 muito “estranho”. Atualmente temos dois duplos, 1 e 2, mas precisamos transformá-lo em 12, não há nenhuma operação matemática que possamos fazer.

Estamos dividindo o último (lastdigit) por 10 na moda 2/10 = 0.2 (daí porque duplo) assim:

  lastdigit = lastdigit/10; 

Isso é meramente brincar com números. Nós estávamos transformando o último dígito em um decimal. Mas agora, olhe o que acontece:

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

Sem entrar muito na matemática, estamos simplesmente isolando as unidades dos dígitos de um número. Você vê, já que consideramos apenas 0-9, dividir por um múltiplo de 10 é como criar uma “checkbox” onde você a armazena (pense em quando seu professor da primeira série lhe explicou o que era uma unidade e uma centena). Assim:

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

E ai você vai. Você transformou uma cadeia de dígitos (nesse caso, dois dígitos) em um inteiro composto desses dois dígitos, considerando as seguintes limitações:

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

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. Por isso, poupando-lhe o bloco try catch.

Apache NumberUtils API versão 3.4

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 int vez de Integer você pode usar:

  1. Unboxing:

     int val = Integer.decode("12"); 
  2. intValue() :

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

Sempre que houver a menor possibilidade de que a String fornecida não contenha um Integer, você terá que lidar com esse caso especial. Infelizmente, os methods Java padrão Integer::parseInt e Integer::valueOf lançam um NumberFormatException para sinalizar este caso especial. Assim, você tem que usar exceções para o controle de stream, que geralmente é considerado um estilo de codificação incorreto.

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

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

Uso:

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

Embora isso ainda esteja usando exceções para o controle de stream internamente, o código de uso fica muito limpo.

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

  • A cadeia contém apenas números 0-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 string for 99999999999999999999? A máquina pode tratar essa string como um int?

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

Por exemplo:

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

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

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

Também podemos usar toInt(String strValue) da class de utilitários NumberUtils para a conversão:

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

Eu tenho uma solução, mas não sei quão eficaz é. Mas funciona bem e acho que você poderia melhorar. Por outro lado, fiz alguns testes com o JUnit, passo correto. Eu anexei a function 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 o 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)); } } } 

Use Integer.parseInt(yourString)

Lembre-se de seguir as coisas:

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

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

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

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

Integer.parseInt("2147483648"); // Exception (Integer está 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)

Existe apenas um tipo de exceção: NumberFormatException

Apenas por diversão: Você pode usar o Optional do Java 8 para converter uma String em um 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. 

Aqui nós apenas combinamos Integer.valueOf e Optinal . Provavelmente, pode haver situações em que isso é útil – por exemplo, quando você deseja evitar verificações de nulos. O código pré-Java 8 será parecido com isto:

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

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 object Integer, todos os outros methods – int primitivo.

Últimos 2 methods do commons-lang3 e grande artigo sobre a conversão aqui .

Guava tem tryParse (String) , que retorna null se 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 depois analisando o int:

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

Mas esteja avisado que isso só funciona para números não negativos.

Além dessas respostas acima, gostaria de adicionar várias funções:

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

E aqui estão os resultados enquanto você os executa:

  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 } 

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

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

  • Opção nº 1: manipule a exceção explicitamente, por exemplo, mostrando um diálogo de mensagem e, em seguida, pare a execução do stream 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 stream de execução puder continuar em caso de uma exceção. Por exemplo, com algumas modificações no bloco catch

     catch (NumberFormatException ex) { integerValue = 0; } 

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

Como mencionado, o Apache Commons NumberUtils pode fazer isso. Que retornam 0 se não puder converter string em 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; 

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

  1. Para um inteiro positivo válido:

     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 

  3. Se você está esperando um espaço em branco antes ou depois desses números, certifique-se de fazer um str = str.trim() antes de processar mais.

Simplesmente você pode tentar isto:

  • Use Integer.parseInt(your_string); converter uma String para int
  • Use Double.parseDouble(your_string); converter uma String em double

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 string normal, você pode usar:

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

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

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

Certifique-se de que não haja dados não numéricos na string.

Aqui vamos nós

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

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) retorna um novo object Integer ().

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

Use Integer.parseInt () e coloque-o dentro de um bloco try...catch para manipular quaisquer erros apenas para o caso de um caractere não numérico ser 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); } } 

Este é o programa completo com todas as condições positivas, negativas sem usar 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; } } 

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 – Integer (String) .

Naturalmente, o construtor retornará o tipo Integer e a operação de unboxing será convertida automaticamente para int .


É importante mencionar
Esse construtor chama o método parseInt .

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

By the way, esteja ciente de que, se a cadeia é nula, a chamada:

 int i = Integer.parseInt(null); 

lança NumberFormatException, não NullPointerException.