java - studio - converter string para int php




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

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

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 .


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