¿Cómo convierto una cadena en un int en Java?

¿Cómo puedo convertir un String a una 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.

preguntado el 07 de abril de 11 a las 15:04

Por cierto, tenga en cuenta que si la cadena es nula, la llamada: int i = Integer.parseInt (null); lanza NumberFormatException, no NullPointerException. -

Me sorprende un poco que esta pregunta deba tener una calificación tan alta cuando falta una parte importante de la especificación: ¿qué debería suceder si la cadena NO contiene solo dígitos? Por ejemplo, muchas de las respuestas analizarán felizmente "-1" y devolverán -1, pero no sabemos si eso es aceptable. -

30 Respuestas

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

Si nos fijamos en el Documentación de Java notará que el "problema" es que esta función puede lanzar un NumberFormatException, que por supuesto tienes que manejar:

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

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

Alternativamente, puede utilizar un Ints método de la biblioteca de Guava, que en combinación con Java 8's Optional, lo convierte en una forma poderosa 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)

Respondido 21 ago 20, 16:08

Además de detectar una NumberFormatException, el usuario también debe tener cuidado con la longitud de las cadenas que están pasando; si son lo suficientemente largos como para desbordar un número entero, es posible que quieran considerar usar Long :: parseLong en su lugar. - Allison

Por ejemplo, aquí hay dos formas:

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 primitivo int.

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

Respondido el 30 de junio de 15 a las 21:06

Para conocer las diferencias entre los dos métodos, consulte esta pregunta - Hertzsprung

valueOf el método es solo return valueOf(parseInt(string)); - Pablo Verest

Bueno, un punto muy importante a considerar es que el analizador de enteros lanza 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 al intentar obtener valores enteros a partir de argumentos divididos o al analizar algo dinámicamente.

Respondido 16 Feb 16, 23:02

¿Cómo puedo analizar "26263Hello"? Quiero extraer 26263 en ese caso - 463035818_no_es_un_número

@ user463035818 - Ver docs.oracle.com/javase/8/docs/api/java/util/regex/… - un patrón de expresión regular de "([0-9]+)" "capturará" la primera secuencia de uno o más dígitos del uno al nueve. Mira el Matcher clase en ese paquete. - marco stewart

Hágalo 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;
}

Respondido 21 ago 20, 16:08

¿Qué pasa si la entrada es mayor que 2 ^ 32? ¿Qué pasa si la entrada contiene caracteres no numéricos? - yohmio

Una de las cosas que un programador debe aprender al unirse a la fuerza laboral, si no antes, es nunca reinventar las ruedas. Este puede ser un ejercicio divertido, pero no espere que su código pase la revisión del código si hace este tipo de cosas en un entorno comercial. - Dawud ibn Karim

-1 Lo siento, pero este es un algoritmo bastante pobre, con muchas limitaciones, sin manejo de errores y algunas anomalías extrañas (por ejemplo, "" da una excepción, "-" producirá 0 y "+" producirá -5). ¿Por qué alguien elegiría esto en lugar de Integer.parseInt(s)? - Veo el sentido de que se trata de una pregunta de entrevista, pero a) eso no implica que lo harías de esta manera (que es lo que preguntó el interlocutor), yb) esta respuesta es un ejemplo bastante malo de todos modos. - susanaw

-1 porque ¿qué pasa si quiero analizar una base 31 int? Integer.parseInt (str, 31) es un trazador de líneas para hacer eso. Comentario un poco gracioso, pero un punto serio debajo. Nunca reinvente ruedas cuando alguien más ya haya puesto el trabajo en - Nathan Adams

Este código parece que fue adaptado de una biblioteca conocida para IO rápido en concursos de programación competitivos. En ese contexto, se garantiza que los datos de entrada son válidos y las soluciones se clasifican según la velocidad. Debería ser más rápido que Integer.parseInt porque no hace ninguna validación. - kayaxnumx

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

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

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

API de Apache NumberUtils versión 3.4

respondido 05 mar '16, 22:03

Rara vez desea que se utilice 0 cuando se analiza un número no válido. - ruido

@Ryboflavin No, no es así. Uno de ellos es una semántica de lenguaje bien definida, y el otro es una excepción: etéreo

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 puedes usar:

  1. Contenido de la caja:

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

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

respondido 07 mar '16, 00:03

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 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 for ciclo (que habría sido perfecto) tampoco se puede utilizar. Esto nos limita un poco, pero, de nuevo, ese es el objetivo. Como solo necesitaba dos dígitos (tomando los dos últimos dígitos), un simple charAtresuelto:

 // 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 tenemos que 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é el doble? Bueno, por 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 este último (último dígito) por 10 de la manera 2/10 = 0.2 (de ahí por qué el doble) así:

 lastdigit = lastdigit / 10;

Esto es simplemente jugar con números. Convirtíamos el último dígito en decimal. Pero ahora, mira lo que sucede:

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

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

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

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

  • Sin ciclos repetitivos
  • Sin expresiones "mágicas" como parseInt

Respondido 21 ago 20, 16:08

No está claro qué tipo de problema intenta resolver esta respuesta, primero, por qué alguien debería tener esa restricción que usted describe, segundo, por qué tiene que mirar una tabla ASCII ya que simplemente puede usar '0' para el personaje en lugar de 48 y nunca tendrá que preocuparse por su valor numérico real. En tercer lugar, todo el desvío con double valores no tiene ningún sentido ya que está dividiendo por diez, solo para multiplicar por diez después. El resultado simplemente es semilastdigit * 10 + lastdigit como se aprendió en la escuela primaria, cuando se introdujo el sistema decimal ... - Holger

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 tira un NumberFormatException para señalar este caso especial. Por lo tanto, debe 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>. Dado que Java no ofrece dicho método, utilizo el siguiente contenedor:

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

Ejemplo 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"));

Si bien esto todavía usa excepciones para el control de flujo internamente, el código de uso se vuelve muy limpio. Además, puede distinguir claramente el caso en el que -1 se analiza como un valor válido y el caso en el que no se pudo analizar una cadena no válida.

Respondido 12 Abr '20, 18:04

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 y todos los demás métodos un int primitivo.

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

Respondido 21 ago 20, 16:08

Utilizan Integer.parseInt(yourString).

Recuerda las siguientes cosas:

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

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

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

Integer.parseInt(" 1"); // Excepción (espacio en blanco)

Integer.parseInt("2147483648"); // Excepción (el número entero está limitado a valor máximo de 2,147,483,647)

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

Integer.parseInt(""); // Excepción (no 0 o algo así)

Solo hay un tipo de excepción: NumberFormatException

Respondido el 02 de Septiembre de 19 a las 23:09

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

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

Respondido 21 ago 20, 16:08

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

Por ejemplo:

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

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

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

También podemos usar toInt(String strValue) of Clase de utilidad NumberUtils para la conversión:

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

Respondido 16 Feb 16, 23:02

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

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

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

respondido 29 nov., 14:08

Google Guayaba tiene tryParse (Cadena), que regresa null si la cadena no se pudo analizar, por ejemplo:

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

Respondido el 03 de Septiembre de 19 a las 00:09

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

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

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

respondido 24 nov., 19:16

Esto causará -42 para ser analizado como 42. - usuario289086

Aparte de las respuestas anteriores, me gustaría agregar varias funciones. Estos son los resultados mientras los usa:

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
}

Implementación:

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

Respondido el 03 de Septiembre de 19 a las 00:09

Como se mencionó, Apache Commons ' NumberUtils lo puede hacer. Vuelve 0 si no puede convertir una cadena en un int.

También puede definir su propio valor predeterminado:

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;

Respondido el 03 de Septiembre de 19 a las 00:09

También puede utilizar este código, 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: Restablezca 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 de captura

    catch (NumberFormatException ex) {
        integerValue = 0;
    }
    

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

respondido 05 mar '16, 04:03

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

Respondido 28 Feb 17, 20:02

En los concursos de programación, donde está seguro de que el número siempre será un 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 entero positivo válido:

    private static int parseInt(String str) {
        int i, n = 0;
    
        for (i = 0; i < str.length(); i++) {
            n *= 10;
            n += str.charAt(i) - 48;
        }
        return n;
    }
    
  2. Tanto para números enteros positivos como 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 espera un espacio en blanco antes o después de estos números, asegúrese de hacer un str = str.trim() antes de seguir procesando.

Respondido el 02 de Septiembre de 19 a las 23:09

Simplemente puedes probar esto:

  • Utilizan Integer.parseInt(your_string); convertir un String a int
  • Utilizan Double.parseDouble(your_string); convertir un 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

Respondido el 20 de junio de 20 a las 10:06

Para una cadena normal, puede usar:

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

Para un generador de cadenas y un búfer de cadenas, puede usar:

Integer.parseInt(myBuilderOrBuffer.toString());

Respondido el 03 de Septiembre de 19 a las 00:09

Estoy un poco sorprendido de que nadie haya mencionado el constructor Integer que toma String como parámetro.

Así que, aquí está:

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

Java 8: entero (cadena).

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


Nota 1: Es importante mencionar: Este constructor llama al parseInt método.

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

Nota 2: está en desuso: @Deprecated(since="9") - Javoc.

Respondido 28 ago 20, 11:08

Use Integer.parseInt () y colóquelo dentro de un try...catch bloque 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);
    }
 }

Respondido 21 Feb 18, 22:02

Se puede realizar de siete formas:

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

String number = "999";
  1. Ints.tryParse:

    int resultado = Ints.tryParse (número);

  2. NumberUtils.createInteger:

    Resultado entero = NumberUtils.createInteger (número);

  3. NumberUtils.toInt:

    int resultado = NumberUtils.toInt (número);

  4. Integer.valueOf:

    Resultado entero = Integer.valueOf (number);

  5. Integer.parseInt:

    int resultado = Integer.parseInt (número);

  6. Integer.decode:

    int result = Integer.decode (número);

  7. Integer.parseUnsignedInt:

    int resultado = Integer.parseUnsignedInt (número);

Respondido 11 ago 20, 05:08

NumberUtils también maneja escenarios nulos y vacíos. - Sundararaj Govindasamy

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

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

Respondido 21 ago 20, 16:08

Esta es exactamente la misma que la respuesta seleccionada. - Steve Smith

El sitio no tiene ningún valor en repetir una respuesta que alguien más publicó CINCO AÑOS antes que usted. - Dawud ibn Karim

Esto ya está cubierto en la respuesta aceptada (publicado unos 5 años antes). - Pedro Mortensen

Esto es una completar programa con todas las condiciones positivas y negativas sin usar una 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;
    }
}

Respondido el 02 de Septiembre de 19 a las 23:09

No es necesario reinventar la rueda, solo use Integer.parseInt. - Dorian Gray

@TobiasWeimer sí, podemos hacerlo, pero esto es sin usar la biblioteca - Anup Gupta

@TobiasWeimer, algunas personas necesitan esta forma de hacerlo sin usar la Biblioteca. - Anup Gupta

No, nadie lo necesita porque es una función dentro del JDK, no un complemento de terceros. - Dorian Gray

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) y devuelve un nuevo objeto Integer ():

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

Respondido el 02 de Septiembre de 19 a las 23:09

¿No está esto cubierto en respuestas anteriores? - Pedro Mortensen

Aquí vamos

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

Respondido 21 ago 20, 16:08

Esto ya está cubierto en la respuesta aceptada (publicado unos 5 años antes). - Pedro Mortensen

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)

Respondido 21 ago 20, 16:08

Este planteamiento de « aparece ser plagiado de La respuesta de Dmytro Shvechikov (desde 2017). - Pedro Mortensen

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.