Java Language
Convertir hacia y desde cuerdas

Convertir otros tipos de datos a String

• Puede obtener el valor de otros tipos de datos primitivos como una cadena utilizando uno de los métodos valueOf la clase String.

  Por ejemplo:

  int i = 42;
  String string = String.valueOf(i);
  //string now equals "42”.
  

  Este método también está sobrecargado para otros tipos de datos, como float , double , boolean e incluso Object .

• También puede obtener cualquier otro Objeto (cualquier instancia de cualquier clase) como una Cadena llamando a .toString en él. Para que esto dé un resultado útil, la clase debe anular toString() . La mayoría de las clases estándar de la biblioteca de Java lo hacen, como Date y otras.

  Por ejemplo:

  Foo foo = new Foo(); //Any class.
  String stringifiedFoo = foo.toString().
  

  Aquí stringifiedFoo contiene una representación de foo como una cadena.

También puede convertir cualquier tipo de número a Cadena con una notación corta como la que se muestra a continuación.

int i = 10;
String str = i + "";

O simplemente una forma simple es

String str = 10 + "";

Conversión a / desde bytes

Para codificar una cadena en una matriz de bytes, simplemente puede usar el método String#getBytes() , con uno de los juegos de caracteres estándar disponibles en cualquier tiempo de ejecución de Java:

byte[] bytes = "test".getBytes(StandardCharsets.UTF_8);

y para decodificar:

String testString = new String(bytes, StandardCharsets.UTF_8);

Puede simplificar aún más la llamada utilizando una importación estática:

import static java.nio.charset.StandardCharsets.UTF_8;
...
byte[] bytes = "test".getBytes(UTF_8);

Para conjuntos de caracteres menos comunes, puede indicar el conjunto de caracteres con una cadena:

byte[] bytes = "test".getBytes("UTF-8");

y al revés:

String testString = new String (bytes, "UTF-8");

sin embargo, esto significa que debe manejar la excepción UnsupportedCharsetException .

La siguiente llamada utilizará el conjunto de caracteres predeterminado. El conjunto de caracteres predeterminado es específico de la plataforma y generalmente difiere entre las plataformas Windows, Mac y Linux.

byte[] bytes = "test".getBytes();

y al revés:

String testString = new String(bytes);

Tenga en cuenta que los caracteres y los bytes no válidos pueden ser reemplazados o omitidos por estos métodos. Para obtener más control, por ejemplo para validar la entrada, se recomienda utilizar las clases CharsetEncoder y CharsetDecoder .

Codificación / decodificación de Base64

Ocasionalmente encontrará la necesidad de codificar datos binarios como una cadena codificada en base64 .

Para esto podemos usar la clase DatatypeConverter del paquete javax.xml.bind :

import javax.xml.bind.DatatypeConverter;
import java.util.Arrays;

// arbitrary binary data specified as a byte array
byte[] binaryData = "some arbitrary data".getBytes("UTF-8");

// convert the binary data to the base64-encoded string
String encodedData = DatatypeConverter.printBase64Binary(binaryData);
// encodedData is now "c29tZSBhcmJpdHJhcnkgZGF0YQ=="

// convert the base64-encoded string back to a byte array
byte[] decodedData = DatatypeConverter.parseBase64Binary(encodedData);

// assert that the original data and the decoded data are equal
assert Arrays.equals(binaryData, decodedData);

Apache commons-codec

Alternativamente, podemos usar Base64 de Apache commons-codec .

import org.apache.commons.codec.binary.Base64;

// your blob of binary as a byte array
byte[] blob = "someBinaryData".getBytes();

// use the Base64 class to encode
String binaryAsAString = Base64.encodeBase64String(blob);

// use the Base64 class to decode
byte[] blob2 = Base64.decodeBase64(binaryAsAString);

// assert that the two blobs are equal
System.out.println("Equal : " + Boolean.toString(Arrays.equals(blob, blob2)));

Si inspecciona este programa mientras se ejecuta, verá que someBinaryData codifica para c29tZUJpbmFyeURhdGE= , un objeto de cadena UTF-8 muy c29tZUJpbmFyeURhdGE= .

// encode with padding
String encoded = Base64.getEncoder().encodeToString(someByteArray);

// encode without padding
String encoded = Base64.getEncoder().withoutPadding().encodeToString(someByteArray);

// decode a String
byte [] barr = Base64.getDecoder().decode(encoded); 

Analizar cadenas a un valor numérico

Cadena a un tipo numérico primitivo o un tipo de contenedor numérico:

Cada clase envoltura numérica proporciona un método parseXxx que convierte una String al tipo primitivo correspondiente. El siguiente código convierte una String en un int usando el método Integer.parseInt :

String string = "59";
int primitive = Integer.parseInteger(string);

Para convertir a una String a una instancia de una clase de envoltura numérica, puede utilizar una sobrecarga del método valueOf clases de envoltorio:

String string = "59";
Integer wrapper = Integer.valueOf(string);

o confiar en el boxeo automático (Java 5 y posterior):

String string = "59";
Integer wrapper = Integer.parseInteger(string);  // 'int' result is autoboxed

El patrón anterior funciona para byte , short , int , long , float y double y las clases de envoltorio correspondientes ( Byte , Short , Integer , Long , Float y Double ).

Cadena a entero usando radix:

String integerAsString = "0101"; // binary representation
int parseInt = Integer.parseInt(integerAsString,2);
Integer valueOfInteger = Integer.valueOf(integerAsString,2);
System.out.println(valueOfInteger); // prints 5 
System.out.println(parseInt); // prints 5 

Excepciones

La excepción NumberFormatException no marcada se lanzará si se llama a un método numérico valueOf(String) o parseXxx(...) para una cadena que no es una representación numérica aceptable, o que representa un valor fuera de rango.

Obteniendo un `String` de un` InputStream`

Una String se puede leer desde un InputStream usando el constructor de matriz de bytes.

import java.io.*;

public String readString(InputStream input) throws IOException {
    byte[] bytes = new byte[50]; // supply the length of the string in bytes here
    input.read(bytes);
    return new String(bytes);
}

Esto utiliza el conjunto de caracteres predeterminado del sistema, aunque se puede especificar un conjunto de caracteres alternativo:

return new String(bytes, Charset.forName("UTF-8"));

Convertir cadena a otros tipos de datos.

Puede convertir una cadena numérica a varios tipos numéricos de Java de la siguiente manera:

Cadena a int:

String number = "12";
int num = Integer.parseInt(number);

Cadena para flotar:

String number = "12.0";
float num = Float.parseFloat(number);

Cadena para doblar:

String double = "1.47";
double num = Double.parseDouble(double);

Cadena a booleano:

String falseString = "False";
boolean falseBool = Boolean.parseBoolean(falseString);   // falseBool = false 
    
String trueString = "True";
boolean trueBool = Boolean.parseBoolean(trueString);     // trueBool = true

Cadena a largo:

String number = "47";
long num = Long.parseLong(number);

Cadena a BigInteger:

String bigNumber = "21";
BigInteger reallyBig = new BigInteger(bigNumber);

Cadena a BigDecimal:

String bigFraction = "17.21455";
BigDecimal reallyBig = new BigDecimal(bigFraction);

Excepciones de conversión:

Las conversiones numéricas anteriores arrojarán una NumberFormatException (sin NumberFormatException ) si intenta analizar una cadena que no es un número con formato adecuado, o está fuera del rango para el tipo de destino. El tema de Excepciones discute cómo lidiar con tales excepciones.

Si desea probar que puede analizar una cadena, podría implementar un método tryParse... como este:

boolean tryParseInt (String value) {  
    try {  
        String somechar = Integer.parseInt(value);
        return true;  
     } catch (NumberFormatException e) { 
        return false;  
     }  
}

Sin embargo, llamar a este método tryParse... inmediatamente antes de analizar es (posiblemente) una mala práctica. Sería mejor simplemente llamar al método parse... y lidiar con la excepción.