Java Language
Konvertieren in und aus Strings

Konvertieren anderer Datentypen in String

• Sie können den Wert anderer primitiver Datentypen als String valueOf indem Sie eine der valueOf Methoden der String-Klasse verwenden.

  Zum Beispiel:

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

  Diese Methode ist auch für andere Datentypen wie float , double , boolean und sogar Object überladen.

• Sie können auch jedes andere Objekt (jede Instanz einer beliebigen Klasse) als String erhalten, indem Sie .toString aufrufen. Damit dies eine nützliche Ausgabe ergibt, muss die Klasse toString() überschreiben. Die meisten Standard-Java-Bibliotheksklassen wie Date und andere.

  Zum Beispiel:

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

  Hier enthält stringifiedFoo eine Darstellung von foo als String.

Sie können auch einen beliebigen Zahlentyp in eine kurze Notation wie folgt konvertieren.

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

Oder einfach auf einfache Weise

String str = 10 + "";

Umwandlung in / von Bytes

Um eine Zeichenfolge in ein Byte-Array zu kodieren, können Sie einfach die Methode String#getBytes() mit einem der Standardzeichensätze verwenden, die in jeder Java-Laufzeitumgebung verfügbar sind:

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

und zu entschlüsseln:

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

Sie können den Aufruf weiter vereinfachen, indem Sie einen statischen Import verwenden:

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

Bei weniger gebräuchlichen Zeichensätzen können Sie den Zeichensatz mit einer Zeichenfolge angeben:

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

und umgekehrt:

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

Dies bedeutet jedoch, dass Sie die geprüfte UnsupportedCharsetException .

Der folgende Aufruf verwendet den Standardzeichensatz. Der Standardzeichensatz ist plattformspezifisch und unterscheidet sich im Allgemeinen zwischen Windows-, Mac- und Linux-Plattformen.

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

und umgekehrt:

String testString = new String(bytes);

Beachten Sie, dass ungültige Zeichen und Bytes durch diese Methoden ersetzt oder übersprungen werden können. Für mehr Kontrolle - zum Beispiel zur Überprüfung der Eingabe - sollten Sie die Klassen CharsetEncoder und CharsetDecoder verwenden.

Base64-Kodierung / Dekodierung

Gelegentlich müssen Sie binäre Daten als Base64- kodierte Zeichenfolge codieren.

Dazu können wir die DatatypeConverter Klasse aus dem Paket 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

Alternativ können wir Base64 von Apache Commons-Codec verwenden .

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

Wenn Sie dieses Programm bei laufendem Betrieb prüfen, werden Sie someBinaryData dass someBinaryData für c29tZUJpbmFyeURhdGE= kodiert, ein sehr verwaltbares UTF-8- String-Objekt.

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

Analysieren von Zeichenfolgen mit einem numerischen Wert

Zeichenfolge für einen primitiven numerischen Typ oder einen numerischen Wrapper-Typ:

Jede numerische Wrapper-Klasse stellt eine parseXxx Methode parseXxx , die einen String in den entsprechenden parseXxx konvertiert. Der folgende Code konvertiert einen String mit der Integer.parseInt Methode in ein int :

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

Um einen String in eine Instanz einer numerischen Wrapper-Klasse zu konvertieren, können Sie entweder eine Überladung der valueOf Methode der Wrapper-Klassen verwenden:

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

oder verlassen Sie sich auf das automatische Boxen (Java 5 und höher):

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

Das obige Muster funktioniert für byte , short , int , long , float und double und die entsprechenden Wrapper-Klassen ( Byte , Short , Integer , Long , Float und Double ).

Zeichenfolge in Ganzzahl mit 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 

Ausnahmen

Die nicht geprüfte NumberFormatException- Ausnahme wird ausgelöst, wenn eine numerische valueOf(String) oder parseXxx(...) -Methode für eine Zeichenfolge aufgerufen wird, die keine akzeptable numerische Darstellung ist oder einen Wert außerhalb des Bereichs darstellt.

Einen String aus einem InputStream holen

Ein String kann mit dem Byte-Array-Konstruktor aus einem InputStream gelesen werden.

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

Dies verwendet den Standard-Zeichensatz des Systems, obwohl ein alternativer Zeichensatz angegeben werden kann:

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

String in andere Datentypen konvertieren.

Sie können eine numerische Zeichenfolge folgendermaßen in verschiedene numerische Java-Typen konvertieren:

String nach int:

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

Zeichenfolge zu schweben:

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

Zeichenfolge zu verdoppeln:

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

Zeichenfolge nach Boolean:

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

Zeichenfolge zu lang:

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

String zu BigInteger:

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

Zeichenfolge zu BigDecimal:

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

Konvertierungsausnahmen:

Die obigen numerischen Konvertierungen NumberFormatException alle eine (ungeprüfte) NumberFormatException wenn Sie versuchen, eine Zeichenfolge zu analysieren, die keine geeignet formatierte Zahl ist oder für den NumberFormatException außerhalb des NumberFormatException Bereichs liegt. Das Thema Ausnahmen behandelt den Umgang mit solchen Ausnahmen.

Wenn Sie testen tryParse... dass Sie eine Zeichenfolge analysieren können, können Sie eine tryParse... Methode wie tryParse... implementieren:

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

Das Aufrufen dieser tryParse... -Methode unmittelbar vor dem Parsen ist jedoch (vermutlich) schlechte Praxis. Es wäre besser, einfach die Methode parse... aufzurufen und mit der Ausnahme fertig zu werden.