java - studio - converter string para int php




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

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 .


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

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
  }

Aqui vamos nós

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

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 entrada, 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 objetivo. 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 "caixa" 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

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; 

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?

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

Obviamente, o construtor retornará o tipo Integer e a operação de unboxing converterá o valor em int .

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

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

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

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

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 Integer, todos os outros métodos - int primitivo.

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


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

Por exemplo:

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

A classe 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 classe de utilitários NumberUtils para a conversão:

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

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 métodos:

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


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

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

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

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


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

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


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.


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

int i = Integer.parseInt(null);

lança NumberFormatException, não NullPointerException.


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

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







type-conversion