Java Language
Conversion vers et à partir de chaînes

Conversion d'autres types de données en chaîne

• Vous pouvez obtenir la valeur d'autres types de données primitifs en tant que chaîne en utilisant l'une des méthodes valueOf la classe String.

  Par exemple:

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

  Cette méthode est également surchargée pour d'autres types de données, tels que float , double , boolean et même Object .

• Vous pouvez également obtenir tout autre objet (toute instance de n'importe quelle classe) en tant que chaîne en appelant .toString dessus. Pour que cela donne des résultats utiles, la classe doit remplacer toString() . La plupart des classes de bibliothèques Java standard le font, telles que Date et autres.

  Par exemple:

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

  Ici stringifiedFoo contient une représentation de foo tant que chaîne.

Vous pouvez également convertir n'importe quel type de nombre en chaîne avec une notation courte comme ci-dessous.

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

Ou simplement simple est

String str = 10 + "";

Conversion en / des octets

Pour encoder une chaîne dans un tableau d'octets, vous pouvez simplement utiliser la méthode String#getBytes() , avec l'un des jeux de caractères standard disponibles sur tout environnement d'exécution Java:

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

et décoder:

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

vous pouvez simplifier davantage l'appel en utilisant une importation statique:

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

Pour les jeux de caractères moins courants, vous pouvez indiquer le jeu de caractères avec une chaîne:

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

et l'inverse:

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

Cela signifie toutefois que vous devez gérer l'exception UnsupportedCharsetException vérifiée.

L'appel suivant utilisera le jeu de caractères par défaut. Le jeu de caractères par défaut est spécifique à la plate-forme et diffère généralement entre les plates-formes Windows, Mac et Linux.

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

et l'inverse:

String testString = new String(bytes);

Notez que les caractères et octets invalides peuvent être remplacés ou ignorés par ces méthodes. Pour plus de contrôle, par exemple pour valider les entrées, vous êtes invité à utiliser les classes CharsetEncoder et CharsetDecoder .

Base64 Encoding / Decoding

Parfois, vous aurez besoin d'encoder des données binaires sous la forme d'une chaîne codée en base64 .

Pour cela , nous pouvons utiliser la DatatypeConverter classe du javax.xml.bind package:

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

Alternativement, nous pouvons utiliser Base64 d' 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 vous inspectez ce programme en cours d'exécution, vous verrez que someBinaryData encode vers c29tZUJpbmFyeURhdGE= , un objet String UTF-8 très c29tZUJpbmFyeURhdGE= à 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); 

Analyse de chaînes à une valeur numérique

Chaîne à un type numérique primitif ou un type d'encapsuleur numérique:

Chaque classe d'encapsuleur numérique fournit une méthode parseXxx qui convertit une String dans le type primitif correspondant. Le code suivant convertit un String en int à l'aide de la méthode Integer.parseInt :

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

Pour convertir en une String une instance d'une classe d'encapsuleur numérique, vous pouvez soit utiliser une surcharge de la méthode des classes wrapper valueOf :

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

ou compter sur la boxe automatique (Java 5 et versions ultérieures):

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

Le modèle ci-dessus fonctionne pour les byte , les short , les int , les long , les float et les double et les classes de wrappers correspondantes ( Byte , Short , Integer , Long , Float et Double ).

Chaîne à Entier à l'aide de 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 

Des exceptions

L'exception NumberFormatException non vérifiée sera déclenchée si une méthode valueOf(String) ou parseXxx(...) numérique est appelée pour une chaîne qui n'est pas une représentation numérique acceptable ou qui représente une valeur hors limites.

Obtenir un `String` à partir d'un` InputStream`

Une String peut être lue depuis un InputStream à l'aide du constructeur de tableau d'octets.

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

Cela utilise le jeu de caractères par défaut du système, bien qu'un autre jeu de caractères puisse être spécifié:

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

Conversion d'une chaîne en d'autres types de données

Vous pouvez convertir une chaîne numérique en divers types numériques Java comme suit:

String à int:

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

Chaîne à flotter:

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

Chaîne à doubler:

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

Chaîne à booléen:

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

String à long:

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

Chaîne à BigInteger:

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

Chaîne à BigDecimal:

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

Exceptions à la conversion:

Les conversions numériques ci-dessus NumberFormatException toutes une NumberFormatException (non contrôlée) si vous tentez d'analyser une chaîne qui n'est pas un nombre correctement formaté ou qui est hors de portée pour le type cible. La rubrique Exceptions explique comment gérer ces exceptions.

Si vous voulez tester que vous pouvez analyser une chaîne, vous pouvez implémenter une méthode tryParse... comme ceci:

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

Cependant, appeler cette méthode tryParse... immédiatement avant l'analyse est (sans doute) une mauvaise pratique. Il serait préférable d'appeler la méthode parse... et de traiter l'exception.