string convertir - ¿Cómo convierto una cadena a un int en Java?




netbeans c# (25)

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

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

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


Answers

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

Vea la documentación de Java para más información.


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

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


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.


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


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

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

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

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

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


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 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, asegúrese de hacer un str = str.trim() antes de seguir procesando.


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


Podemos usar el método parseInt(String str) de la clase envoltura 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 la clase de utilidad NumberUtils para la conversión:

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

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

Aquí vamos

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

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

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

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; 

Solo por diversión: Puedes usar el Optional Java 8 para convertir una String en un 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í solo 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);

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 ser usado. 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 simple característica 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 (de ahí 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 entero compuesto por esos dos dígitos, teniendo en cuenta las siguientes limitaciones:

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

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
  }

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

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 el gran artículo sobre la conversión here .


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

int i = Integer.parseInt(null);

lanza la excepción NumberFormatException, no NullPointerException.


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

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

La utilidad Apache es buena 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


Este es el programa completo con todas las condiciones positivas, negativas 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;
     }
    }

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


Las funciones toLocaleUpperCase () o en minúsculas no se comportan como deberían.

Por ejemplo, en mi sistema, Safari 4, Chrome 4 Beta, Firefox 3.5.x convierte cadenas con caracteres turcos incorrectamente.

Los navegadores responden a navigator.language como "en-US", "tr", "en-US" respectivamente.

Pero no hay forma de obtener la configuración Accept-Lang del usuario en el navegador, por lo que pude encontrar.

Solo Chrome me causa problemas, aunque he configurado todos los navegadores con la configuración regional tr-TR preferida.

Creo que esta configuración solo afecta al encabezado HTTP, pero no podemos acceder a esta configuración a través de JS.

En la documentación de Mozilla dice "Los caracteres dentro de una cadena se convierten a ... respetando la configuración regional actual.

Para la mayoría de los idiomas, esto devolverá lo mismo que ... ".

Creo que es válido para el turco, no difiere, está configurado como en o tr.

En turco debe convertir "DİNÇ" a "dinç" y "DINÇ" a "dınç" o viceversa.





java string int type-conversion