it-swarm-es.tech

¿Cómo convierto un String a un int en Java?

¿Cómo puedo convertir un String en un int en Java?

Mi cadena contiene solo números y quiero devolver el número que representa.

Por ejemplo, dada la cadena "1234" el resultado debe ser el número 1234.

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

Si observa la Documentación Java notará que la "captura" es que esta función puede lanzar una NumberFormatException, que por supuesto tiene que manejar:

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

(Este tratamiento establece por defecto un número con formato incorrecto en 0, pero puede hacer otra cosa si lo desea).

Alternativamente, puede usar un método Ints de la biblioteca Guava, que en combinación con la Optional de Java 8, constituye una forma potente y concisa de convertir una cadena en un int:

import com.google.common.primitives.Ints;

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

Por ejemplo, aquí hay dos maneras:

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

Hay una ligera diferencia entre estos métodos: 

  • valueOf devuelve una instancia nueva o en caché de Java.lang.Integer
  • parseInt devuelve primitiva int

Lo mismo es para todos los casos: Short.valueOf/parseShort, Long.valueOf/parseLong, etc.

629
smas

Bueno, un punto muy importante a considerar es que el analizador de enteros arroja la excepción NumberFormatException como se indica en 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.
}

Es importante manejar esta excepción cuando se intenta obtener valores enteros de argumentos divididos o analizar dinámicamente algo.

230
Ali Akdurak

Hazlo 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;
}
83
Billz

Actualmente estoy haciendo una tarea para la universidad, donde no puedo usar ciertas expresiones, como las de arriba, y al mirar la tabla ASCII, logré hacerlo. Es un código mucho más complejo, pero podría ayudar a otros que están restringidos como lo estaba yo.

Lo primero que debe hacer es recibir la entrada, en este caso, una cadena de dígitos; Lo llamaré String number, y en este caso, lo ejemplificaré usando el número 12, por lo tanto String number = "12";

Otra limitación fue el hecho de que no podía usar ciclos repetitivos, por lo tanto, un ciclo for (que hubiera sido perfecto) tampoco puede usarse. Esto nos limita un poco, pero, de nuevo, ese es el objetivo. Como solo necesitaba dos dígitos (tomando los últimos dos dígitos), una charAt simple lo resolvió:

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

Teniendo los códigos, solo necesitamos mirar la tabla y hacer los ajustes necesarios:

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

Ahora, ¿por qué doble? Bueno, debido a un paso realmente "extraño". Actualmente tenemos dos dobles, 1 y 2, pero necesitamos convertirlo en 12, no hay ninguna operación matemática que podamos hacer.

Estamos dividiendo el último (último dígito) por 10 en la moda 2/10 = 0.2 (por lo tanto, el doble) de esta manera:

 lastdigit = lastdigit/10;

Esto es simplemente jugar con números. Estábamos convirtiendo el último dígito en un decimal. Pero ahora, mira lo que pasa:

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

Sin entrar demasiado en las matemáticas, simplemente estamos aislando las unidades de los dígitos de un número. Verá, ya que solo consideramos 0-9, dividir por un múltiplo de 10 es como crear una "caja" donde la guarda (recuerde cuando su maestro de primer grado le explicó qué eran una unidad y cien). Asi que:

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

Y ahí tienes. Convirtió una cadena de dígitos (en este caso, dos dígitos), en un número entero compuesto por esos dos dígitos, teniendo en cuenta las siguientes limitaciones:

  • Sin ciclos repetitivos
  • No hay expresiones "mágicas" como parseInt
42
Oak

Una solución alternativa es usar Apache Commons ' NumberUtils:

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

La utilidad Apache es agradable porque si la cadena tiene un formato de número no válido, 0 siempre se devuelve. Por lo tanto, le ahorra el bloque try catch.

Apache NumberUtils API Versión 3.4

40
Ryboflavin

Integer.decode

También puedes usar public static Integer decode(String nm) throws NumberFormatException.

También funciona para base 8 y 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

Si desea obtener int en lugar de Integer puede usar:

  1. Unboxing:

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

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

Siempre que exista la más mínima posibilidad de que la cadena dada no contenga un entero, debe manejar este caso especial. Lamentablemente, los métodos estándar de Java Integer::parseInt y Integer::valueOf lanzan una NumberFormatException para señalar este caso especial. Por lo tanto, tiene que usar excepciones para el control de flujo, que generalmente se considera un estilo de codificación incorrecto.

En mi opinión, este caso especial debe manejarse devolviendo un Optional<Integer>. Ya que Java no ofrece tal método, uso el siguiente envoltorio:

private Optional<Integer> 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));

Si bien esto sigue utilizando excepciones para el control de flujo internamente, el código de uso se vuelve muy limpio.

25
Stefan Dollase

Convertir una cadena en un int es más complicado que simplemente convertir un número. Has pensado en los siguientes temas:

  • ¿La cadena solo contiene números 0-9 ?
  • ¿Qué pasa con -/+ antes o después de la cadena? ¿Es eso posible (refiriéndose a los números contables)?
  • ¿Qué pasa con MAX _-/MIN_INFINITY? ¿Qué pasará si la cadena es 9999999999999999999999? ¿Puede la máquina tratar esta cadena como un int?
23
Dennis Ahaus

Métodos para hacer eso:

 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 produce un objeto Integer, todos los demás métodos - primitivo int.

Los últimos 2 métodos de commons-lang3 y un gran artículo sobre la conversión de aquí .

22

Podemos usar el método parseInt(String str) de la clase de contenedor Integer para convertir un valor de String en un valor entero.

Por ejemplo:

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

La clase Integer también proporciona el método valueOf(String str):

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

También podemos usar toInt(String strValue) de NumberUtils Utility Class para la conversión:

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

Utilice Integer.parseInt(yourString)

Recuerda lo siguiente:

Integer.parseInt("1"); // ok

Integer.parseInt("-1"); // ok

Integer.parseInt("+1"); // ok

Integer.parseInt(" 1"); // Exception (espacio en blanco)

Integer.parseInt("2147483648"); // Exception (El entero está limitado a valor máximo de 2,147,483,647)

Integer.parseInt("1.1"); // Exception (. or, o lo que no esté permitido)

Integer.parseInt(""); // Exception (no 0 o algo así)

Solo hay un tipo de excepción: NumberFormatException

19
Lukas Bauer

Tengo una solución, pero no sé cuán efectiva es. Pero funciona bien, y creo que podrías mejorarlo. Por otro lado, hice un par de pruebas con JUnit que paso correctamente. Adjunto la función y pruebas:

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

Pruebas con 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));
        }
    }
}
19
fitorec

Solo por diversión: Puedes usar la Optional de Java 8 para convertir una String en una 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.

Aquí simplemente combinamos Integer.valueOf y Optinal. Probablemente podría haber situaciones en las que esto sea útil, por ejemplo, cuando quiera evitar las comprobaciones nulas. El código Pre Java 8 se verá así:

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

Guava tiene tryParse (String) , que devuelve null si no se pudo analizar la cadena, por ejemplo:

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

También puede comenzar eliminando todos los caracteres no numéricos y luego analizando el int:

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

Pero ten en cuenta que esto solo funciona para números no negativos. 

14
Thijser

Aparte de estas respuestas anteriores, me gustaría agregar varias funciones: 

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

Y aquí están los resultados mientras los ejecutas: 

  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
  }
12
nxhoaf

En las competiciones de programación, donde está seguro de que el número siempre será un número entero válido, entonces puede escribir su propio método para analizar la entrada. Esto omitirá todo el código relacionado con la validación (ya que no necesita nada de eso) y será un poco más eficiente.

  1. Para un entero positivo valido:

    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 enteros positivos y 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. Si está esperando un espacio en blanco antes o después de estos números, Luego asegúrese de hacer una str = str.trim() antes de continuar con el proceso.

9
Raman Sahasi

Como se mencionó, Apache Commons NumberUtils puede hacerlo. Que devuelve 0 si no puede convertir la cadena a int.

También puede definir su propio valor por defecto.

NumberUtils.toInt(String str, int defaultValue)

ejemplo:

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

Puedes usar este código también, con algunas precauciones.

  • Opción # 1: maneje la excepción explícitamente, por ejemplo, mostrando un diálogo de mensaje y luego detenga la ejecución del flujo de trabajo actual. Por ejemplo:

    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;
    }
    
  • Opción # 2: reinicie la variable afectada si el flujo de ejecución puede continuar en caso de una excepción. Por ejemplo, con algunas modificaciones en el bloque catch.

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

Usar una cadena constante para comparación o cualquier tipo de computación siempre es una buena idea, porque una constante nunca devuelve un valor nulo.

9
manikant gautam

Puedes usar new Scanner("1244").nextInt(). O pregunte si existe incluso un int: new Scanner("1244").hasNextInt()

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

Asegúrese de que no haya datos no numéricos en la cadena.

7
iKing

Para una cuerda normal puedes usar:

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

Para el generador de cadenas y el búfer de cadenas puede usar:

Integer.parseInt(myBuilderOrBuffer.toString());
7
Aditya

Simplemente puedes probar esto:

  • Usa Integer.parseInt(your_string); para convertir una String a int
  • Usa Double.parseDouble(your_string); para convertir una String a double

Ejemplo

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
7
Vishal Yadav

Aquí vamos

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

Estoy un poco sorprendido de que nadie haya mencionado el constructor Integer que toma String como parámetro.
Entonces, aquí está: 

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

Java 8 - Entero (String)

Por supuesto, el constructor devolverá el tipo Integer, y la operación unboxing convierte el valor en int


Es importante mencionar
Este constructor llama al método parseInt

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

Use Integer.parseInt () y colóquelo dentro de un bloque try...catch para manejar cualquier error en caso de que se ingrese un carácter no numérico, por ejemplo,

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

Un método es parseInt (String) devuelve un int primitivo

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

El segundo método es valueOf (String) devuelve un nuevo objeto Integer ().

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

Este es un programa completo con todas las condiciones positiva, negativa sin usar la 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;
     }
    }
4
Anup Gupta

Integer.parseInt(myString); - usando la clase wrapper

3
Phani Kumar

Se puede hacer de 5 maneras:

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

1) Usando Ints.tryParse:

String number = "999";
int result = Ints.tryParse(number);

2) Usando NumberUtils.createInteger:

String number = "999";
Integer result = NumberUtils.createInteger(number);

3) Usando NumberUtils.toInt:

String number = "999";
int result = NumberUtils.toInt(number);

4) Usando Integer.valueOf:

String number = "999";
Integer result = Integer.valueOf(number);

5) Usando Integer.parseInt:

String number = "999";
int result = Integer.parseInt(number);
3
Santosh Jadi

Por cierto, tenga en cuenta que si la cadena es nula, la llamada:

int i = Integer.parseInt(null);

lanza la excepción NumberFormatException, no NullPointerException.

3
Pavel Molchanov

Puede utilizar cualquiera de los siguientes: 

  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)
2
Rajeev Ranjan

importar Java.util. *;

clase pública strToint {

    public static void main(String[] args){

            String str = "123";

            byte barr[] = str.getBytes();

            System.out.println(Arrays.toString(barr));
            int result=0;
            for(int i=0;i<barr.length;i++){
                    //System.out.print(barr[i]+" ");
                    int ii = barr[i];
                    char a = (char)ii;
                    int no = Character.getNumericValue(a);
                    result=result*10+no;
                    System.out.println(result);

            }
            System.out.println("result:"+result);
    }

}

2
Abhijeet Kale

public static int parseInt (String s) lanza NumberFormatException

puede usar Integer.parseInt() para convertir una cadena a int.

convertir un String 20 en un int primitivo.

    String n = "20";
    int r = Integer.parseInt(n);//returns a primitive int       
    System.out.println(r);

Salida-20

si la cadena no contiene un entero parsable. se lanzará NumberFormatException

String n = "20I";// throwns NumberFormatException
int r = Integer.parseInt(n);
System.out.println(r);

public static Integer valueOf (String s) lanza NumberFormatException

puedes usar Integer.valueOf(), en esto devolverá un objeto Integer.

String n = "20";
Integer r = Integer.valueOf(n); //returns a new Integer() object.   
System.out.println(r);

Salida-20

Referencias https://docs.Oracle.com/en/

1

Algunas de las maneras de convertir String en Int son las siguientes:

  1. puedes usar Integer.parseInt():

    String test = "4568"; int new = Integer.parseInt(test);

  2. también puedes usar Integer.valueOf():

    String test = "4568"; int new =Integer.parseInt(test);

0

Convierta una cadena en un entero con el método parseInt de la clase Integer de Java. El método parseInt es convertir la cadena en un int y lanza una NumberFormatException si la cadena no se puede convertir en un tipo int.

Con vistas a la excepción que puede lanzar, usa esto:

int i = Integer.parseInt(myString);

Si la cadena representada por la variable myString es un entero válido como “1234”, “200”, “1”, y se convertirá en un int de Java. Si falla por alguna razón, el cambio puede arrojar una NumberFormatException, por lo que el código debería ser un poco más largo para tenerlo en cuenta.

Ex. Java String a int método de conversión, control para un posible NumberFormatException

public class JavaStringToIntExample
{
  public static void main (String[] args)
  {
    // String s = "test";  // use this if you want to test the exception below
    String s = "1234";

    try
    {
      // the String to int conversion happens here
      int i = Integer.parseInt(s.trim());

      // print out the value after the conversion
      System.out.println("int i = " + i);
    }
    catch (NumberFormatException nfe)
    {
      System.out.println("NumberFormatException: " + nfe.getMessage());
    }
  }
}

Si el intento de cambio falla, en caso de que intente convertir la prueba de String de Java en un int, el proceso parseInt Integer lanzará una NumberFormatException, que debe manejar en un bloque try/catch.

0
Nisarg

Puedes usar el método parseInt  

  String SrNumber="5790";
int extractNumber = Integer.parseInt(SrNumber);
System.out.println(extractNumber);//Result will be --5790
0
Sunil Dhappadhule

Algoritmo personalizado:

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  byte bytes[] = value.getBytes();
  for (int i = 0; i < bytes.length; i++) {
    char c = (char) bytes[i];
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

otra solución: (use la cadena charAt method en lugar de convertir una cadena a una matriz de bytes)

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  for (int i = 0; i < value.length(); i++) {
    char c = value.charAt(i);
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

Ejemplos:

int number1 = toInt("20");
int number2 = toInt("-20");
int number3 = toInt("+20");
System.out.println("Numbers = " + number1 + ", " + number2 + ", " + number3);

try {
  toInt("20 Hadi");
} catch (NumberFormatException e) {
  System.out.println("Error: " + e.getMessage());
}
0
nabeghe

Utilizando el método: Integer.parseInt(String s)

String s = "123";
int n = Integer.parseInt(s);
0
karthik_varma_k

Use Integer.parseInt(), esto le ayudará a analizar su valor de cadena a int.

Ejemplo:

String str = "2017";
int i = Integer.parseInt(str);
System.out.println(i);

salida: 2017

0
Alekya

Utilice este método:

public int ConvertStringToInt(String number)
{
 int num = 0;
 try
 {
   int newNumber = Integer.ParseInt(number);
   num = newNumber;
 }
 catch(Exception ex)
 {
   num = 0;
   Log.i("Console",ex.toString);
 }
   return num;
}
0
mohamad sheikhi

Pruebe este código con diferentes entradas de String:

String a = "10";  
String a = "10ssda";  
String a = null; 
String a = "12102";

if(null != a) {
    try {
        int x = Integer.ParseInt(a.trim()); 
        Integer y = Integer.valueOf(a.trim());
        //  It will throw a NumberFormatException in case of invalid string like ("10ssda" or "123 212") so, put this code into try catch
    } catch(NumberFormatException ex) {
        // ex.getMessage();
    }
}
0
Ram Chhabra

Escribí este método rápido para analizar una entrada de cadena en int o long. Es más rápido que el actual JDK 11 Integer.parseInt o Long.parseLong. Aunque, solo pediste int, también incluí el analizador largo. El analizador de código a continuación requiere que el método del analizador sea pequeño para que funcione rápidamente. Una versión alternativa está debajo del código de prueba. La versión alternativa es bastante rápida y no depende del tamaño de la clase.

Esta comprobación de clase para el desbordamiento y usted podría personalizar el código para adaptarse a sus necesidades. Una cadena vacía producirá 0 con mi método pero eso es intencional. Puedes cambiar eso para adaptar tu estuche o usarlo como está. 

Esta es solo la parte de la clase donde se necesitan parseInt y parseLong. Tenga en cuenta que esto sólo se ocupa de los números de base 10.

El código de prueba para el analizador int se encuentra debajo del código siguiente. 

/*
 * Copyright 2019 Khang Hoang Nguyen
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * @author: Khang Hoang Nguyen - [email protected]
 **/
final class faiNumber{        
    private static final long[] longpow = {0L, 1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L,
                                           10000000000L, 100000000000L, 1000000000000L, 10000000000000L, 100000000000000L,
                                           1000000000000000L, 10000000000000000L, 100000000000000000L, 1000000000000000000L,
                                           };

    private static final int[] intpow = { 0, 1, 10, 100, 1000, 10000,
                                          100000, 1000000, 10000000, 100000000, 1000000000 
                                        };

    /**
     * parseLong(String str) parse a String into Long. 
     * All errors throw by this method is NumberFormatException.
     * Better errors can be made to tailor to each use case.
     **/
    public static long parseLong(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0L;        

        char c1 = str.charAt(0); int start;

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }
        /*
         * Note: if length > 19, possible scenario is to run through the string 
         * to check whether the string contains only valid digits.
         * If the check had only valid digits then a negative sign meant underflow, else, overflow.
         */
        if ( length - start > 19 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );

        long c; 
        long out = 0L;

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            out += c * longpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1L;
            // if out > 0 number underflow(supposed to be negative).
            if ( out > 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            return out;
        }
        // if out < 0 number overflow(supposed to be positive).
        if ( out < 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
        return out;
    }

    /**
     * parseInt(String str) parse a string into an int.
     * return 0 if string is empty. 
     **/
    public static int parseInt(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0;        

        char c1 = str.charAt(0); int start; 

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }

        int out = 0; int c;
        int runlen = length - start;

        if ( runlen > 9 ) {
            if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

            c = (str.charAt(start) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start++];
        }

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1;
            if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            return out;
        }

        if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }
}

Sección de código de prueba. Esto debería tomar alrededor de 200 segundos o menos.

// Int Number Parser Test;
long start = System.currentTimeMillis();    
System.out.println("INT PARSER TEST");
for (int i = Integer.MIN_VALUE; i != Integer.MAX_VALUE; i++){
   if( faiNumber.parseInt(""+i) != i ) System.out.println("Wrong");
   if ( i == 0 ) System.out.println("HalfWay Done");
}

if( faiNumber.parseInt(""+Integer.MAX_VALUE) != Integer.MAX_VALUE ) System.out.println("Wrong");
long end = System.currentTimeMillis();
long result = (end - start);
System.out.println(result);        
// INT PARSER END */

Un método alternativo que también es muy rápido. Tenga en cuenta que la matriz de int pow no se utiliza, sino una optimización matemática de multiplicar por 10 mediante el desplazamiento de bits.

public static int parseInt(final String str) { 
    final int length = str.length();
    if ( length == 0 ) return 0;        

    char c1 = str.charAt(0); int start; 

    if ( c1 == '-' || c1 == '+' ){
        if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
        start = 1;
    } else {
        start = 0;
    }

    int out = 0; int c;
    while( start < length && str.charAt(start) == '0' ) start++; // <-- This to disregard leading 0, can be removed if you know exactly your source does not have leading zeroes.
    int runlen = length - start;

    if ( runlen > 9 ) {
        if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

        c = (str.charAt(start++) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; // <- alternatively this can just be out = c or c above can just be out;
    }

    for ( ; start < length; start++){
        c = (str.charAt(start) ^ '0');
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; 
    }

    if ( c1 == '-' ){
        out = ~out + 1;
        if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }

    if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
    return out;
}
0
Kevin Ng