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

3026

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.

Usuário desconhecido
fonte
1
A propósito, esteja ciente de que, se a sequência for nula, a chamada: int i = Integer.parseInt (null); lança NumberFormatException, não NullPointerException.
Pavel Molchanov
2
Estou um pouco surpreso que essa pergunta tenha uma classificação tão alta quando uma parte importante da especificação estiver ausente: o que aconteceria se a sequência NÃO contivesse apenas dígitos? Por exemplo, muitas das respostas analisam felizmente "-1" e retornam -1, mas não sabemos se isso é aceitável.
Michael Kay

Respostas:

4086
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)
Rob Hruska
fonte
23
Além de capturar uma NumberFormatException, o usuário também deve ter cuidado com o comprimento das strings pelas quais está passando; se tiverem tempo suficiente para estourar um número inteiro, convém usar Long :: parseLong.
Allison
6
@Allison, especialmente se estiver usando o campo BIGINT em um campo de chave primária com incremento automático do PostgreSQL, por exemplo. Muito mais seguro de usar por muito tempo
Letholdrus
7
Você pode verificar se a seqüência de caracteres é um número primeiro: stackoverflow.com/questions/1102891/…
JPRLCol
Esse método também gera exceção quando string não é um número inteiro analisável na base 10. Use o método sobrecarregado para trabalhar em outras bases. por exemplo, Integer.parseInt ("1001", 8); para a base 8. Fonte .
Lokesh
2
Além disso, embora o uso do Guava em combinação com o opcional do Java 8 possa ser poderoso, provavelmente é um exagero e não é tão conciso quanto o uso de NumberUtils.toInt (String str, int defaultValue) da biblioteca Apache commons-lang :int foo = NumberUtils.toInt(myString, 0);
Kunda
681

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.

lukastymo
fonte
80
Para as diferenças entre os dois métodos, consulte esta pergunta
Hertzsprung
19
valueOfo método é justo #return valueOf(parseInt(string));
913 Paul Verest
@PaulVerest eu não entendo ... valueOfchama-se recursivamente?
Idclev 463035818
1
@ user463035818 valueOf tem duas sobrecargas - para int e String. valueOf(String)é implementado analisando primeiro a String para um int usando parseInt(String)e depois agrupando esse int em um número inteiro usando valueOf(int). Nenhuma recursão aqui porque valueOf(String)e valueOf(int)são duas funções completamente diferentes, mesmo que tenham o mesmo nome.
PhilipRoman
244

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.

Ali Akdurak
fonte
como posso analisar "26263Olá"? Eu quero extrair 26263 nesse caso
idclev 463035818 16/05
1
@ user463035818 - Consulte docs.oracle.com/javase/8/docs/api/java/util/regex/… - um padrão de expressão regular de "([0-9]+)""captura" a primeira sequência de um ou mais dígitos de um a nove. Veja a Matcherclasse nesse pacote.
Mark Stewart
83

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;
}
Billz
fonte
22
E se a entrada for maior que 2 ^ 32? E se a entrada contiver caracteres não numéricos?
Yohm
87
Uma das coisas que um programador deve aprender ao ingressar na força de trabalho, se não antes, é nunca reinventar as rodas. Pode ser um exercício divertido, mas não espere que seu código seja aprovado na revisão de código se você fizer esse tipo de coisa em uma configuração comercial.
Dawood ibn Kareem
43
-1 Desculpe, mas este é um algoritmo bastante ruim, com muitas limitações, sem manipulação de erros e algumas anomalias estranhas (por exemplo, "" dá uma exceção "" - "produzirá 0 e" + "produzirá -5). Por que alguém escolheria isso Integer.parseInt(s)? - Entendo que essa é uma pergunta de entrevista, mas a) não implica que você faça dessa maneira (que é o que o questionador perguntou) eb) essa resposta é um exemplo muito ruim de qualquer maneira.
SusanW
1
-1 porque e se eu quiser analisar uma base 31 int? Integer.parseInt (str, 31) é um liner para fazer isso. Comentário levemente ridículo, mas questão séria por baixo. Nunca re-inventar rodas quando alguém já colocar o trabalho
Nathan Adams
1
Esse código parece ter sido adaptado de uma biblioteca conhecida para E / S rápida em concursos de programação competitiva. Nesse contexto, é garantido que os dados de entrada são válidos e as soluções são classificadas em velocidade. Deve ser mais rápido do que Integer.parseInt porque não faz validação.
kaya3
53

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

Ryboflavin
fonte
34
Você raramente deseja que 0 seja usado quando um número inválido é analisado.
Wnoise 22/03
4
Zero é o que o java usa como padrão se um campo int em um objeto não estiver definido. Então, a esse respeito, faz sentido.
Ryboflavin
15
@Ryboflavin Não, não faz. Uma delas é a semântica linguagem bem definida, eo outro é uma exceção
etherous
43

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
Carvalho
fonte
8
Usar o tipo double para analisar um número inteiro não é apenas uma má ideia em termos de desempenho. Valores como 0,2 são números periódicos na representação de ponto flutuante e não podem ser representados com precisão. Tente System.out.println (0.1 + 0.2) para ver o ponto - o resultado não será 0,3! É melhor ficar com o código da biblioteca sempre que possível, neste caso, Integer.parseInt ().
ChrisB
10
Não está claro que tipo de problema essa resposta tenta resolver: primeiro, por que alguém deveria ter essa restrição que você descreve; segundo, por que você precisa olhar para uma tabela ASCII, pois pode simplesmente usar '0'o personagem em vez de 48nunca precisar se preocupe com seu valor numérico real. Terceiro, todo o desvio de doublevalores não faz sentido, pois você está dividindo por dez, apenas para multiplicar com dez depois. O resultado simplesmente é semilastdigit * 10 + lastdigitcomo aprendemos na escola primária, quando o sistema decimal foi introduzido ...
Holger
2
@ Holger Recebi pessoalmente essa restrição ao iniciar a programação e também quando tive que escrever (caneta / papel) interações semelhantes em um teste. É incomum, mas é um método que é facilmente compreendido e, embora não seja o mais eficiente em milhas, é um método que funciona decentemente o suficiente para pequenos projetos. SO.SE destina-se a ajudar todos, não apenas alguns. Forneci um método alternativo para quem está começando a aprender como criar um pseudo-algoritmo e transformá-lo em um algoritmo, em vez de usar expressões java pré-fabricadas. Embora eu tenha esquecido que '0' é legal
Oak
2
Esta não é uma boa resposta. A pergunta é "Como converter uma String em um int em Java?" não, "Como eu resolvo esse problema de lição de casa com restrições arbitrárias?" É StackOverflow, não HomeworkOverflow.
Davids
1
Você deixou muito claro o motivo de usar essa nova abordagem, de modo que isso não é uma preocupação. No entanto, você enfatiza que sua abordagem usa "sem ciclos repetitivos" , mas seu exemplo específico ignora esse problema completamente, codificando a solução (para um número de dois dígitos) para usar somente semilastdigite lastdigit. Como você codificaria sua solução para evitar "ciclos repetitivos" se eu fornecesse uma sequência numérica válida de tamanho arbitrário (por exemplo, qualquer valor entre "-2147483648" e "2147483647"?)
skomisa
38

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();
ROMANIA_engineer
fonte
Finalmente! Alguém que realmente se preocupa em postar os resultados / saída das conversões! Você também pode adicionar alguns com sinais "-"?
precisa saber é o seguinte
29

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.

Stefan Dollase
fonte
24

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?
Dennis Ahaus
fonte
1
Sim - e há um caso de borda desagradável em torno de -2 ^ 31. Se você tentar negando 2 ^ 31, você pode executar em dificuldades ......
SusanW
24

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 .

Dmytro Shvechikov
fonte
22

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);
Giridhar Kumar
fonte
22

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

Lukas Bauer
fonte
O valor máximo int aqui também fornece NumberFormatException?
The Coding Wombat
Não, o valor máximo é stil bem
Lukas Bauer
19

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));
        }
    }
}
fitorec
fonte
Você pode fazer isso de maneira mais simples:(int) Double.parseDouble(input.replaceAll("[^0-9\\.\\-]", ""));
Dávid Horváth 13/11
18

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) {
  ...
}
Vitalii Fedorenko
fonte
17

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.

Thijser
fonte
18
Isso fará com -42que seja analisado como 42.
10
Sim, isso só funciona para números não negativos que são corretos para começar e, portanto, não precisam dessa etapa de substituição. Para todos os outros casos, essa tentativa de corrigi-lo automaticamente piorará as coisas (como quase todas as tentativas de corrigir algo automaticamente). Se eu for aprovado "4+2", terei 42como resultado, sem nenhuma dica, que o que tentei fazer foi equivocado. O usuário terá a impressão de que inserir expressões básicas como 4+2uma entrada válida, mas o aplicativo continua com um valor errado. Além disso, o tipo é String, não string...
Holger
Ou altere a primeira linha para -> string mystr = mystr.replaceAll ("[^ \\ d \\ -]", "");
apm
13

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;
}
nxhoaf
fonte
10

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;
Alireza Fattahi
fonte
9

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.

gautam manikant
fonte
4
Colocar JOptionPane.showMessageDialog()a resposta à pergunta sobre baunilha Java não faz sentido.
precisa saber é o seguinte
2
Integer.valueOf(String);não retorna o tipo int.
Php_coder_3809625
9

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

Christian Ullenboom
fonte
9

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.

Raman Sahasi
fonte
7

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
Vishal Yadav
fonte
Esta resposta parece não adicionar nada além das respostas recomendando Integer.parseInt postado alguns anos antes (converter String para o dobro seria uma pergunta diferente ).
Bernhard Barker
7

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());
Aditya
fonte
6
int foo=Integer.parseInt("1234");

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

iKing
fonte
5
É exatamente o mesmo que a resposta selecionada.
9788 Steve
5
Não há valor para o site, ao repetir uma resposta que outra pessoa postou CINCO ANOS antes de você.
Dawood ibn Kareem
Isso já está coberto na resposta aceita (postada cerca de 5 anos antes).
Peter Mortensen
6

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);
}
djm.im
fonte
5

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);
    }
 }
David
fonte
5

Aqui vamos nós

String str="1234";
int number = Integer.parseInt(str);
print number;//1234
Shiva
fonte
Isso já está coberto na resposta aceita (postada cerca de 5 anos antes).
Peter Mortensen
5

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);
Santosh Jadi
fonte
NumberUtils também lida com cenários nulos e vazios.
Sundararaj Govindasamy
5

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);
Pankaj Mandale
fonte
Isso não está coberto nas respostas anteriores?
Peter Mortensen
4

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)
Rajeev Ranjan
fonte
4

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;
    }
}
Anup Gupta
fonte
2
Não há necessidade de reinventar a roda, basta usar Integer.parseInt.
Dorian Gray
@TobiasWeimer sim, nós podemos fazer, mas este é sem usar biblioteca
Anup Gupta
@TobiasWeimer, algumas pessoas precisam disso sem usar a Library.
Anup Gupta
5
Não, ninguém precisa disso porque é uma função dentro do JDK, não um plug-in de terceiros.
Dorian Gray