Java Language
Converteren naar en van strings

Andere datatypes omzetten naar String

• U kunt de waarde van de andere primitieve typen gegevens op te halen als een string met behulp van één van de String klasse valueOf methoden.

  Bijvoorbeeld:

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

  Deze methode is ook overbelast voor andere gegevenstypen, zoals float , double , boolean en zelfs Object .

• Je kunt ook elk ander object (elke instantie van een klasse) als een string krijgen door er .toString op aan te roepen. Om bruikbare uitvoer te geven, moet de klasse overschrijven toString() . De meeste standaard Java-bibliotheekklassen doen dat, zoals Date en andere.

  Bijvoorbeeld:

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

  Hier stringifiedFoo bevat een weergave van foo als een String.

Je kunt ook elk type nummer naar String converteren met een korte notatie zoals hieronder.

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

Of gewoon een simpele manier is

String str = 10 + "";

Conversie naar / van bytes

Om een string in een byte-array te coderen, kunt u eenvoudig de methode String#getBytes() gebruiken, met een van de standaard tekensets die beschikbaar zijn op elke Java-runtime:

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

en om te decoderen:

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

u kunt het gesprek verder vereenvoudigen door een statische import te gebruiken:

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

Voor minder gebruikelijke tekensets kunt u de tekenset met een string aangeven:

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

en omgekeerd:

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

dit betekent echter wel dat u de aangevinkte UnsupportedCharsetException moet verwerken.

De volgende aanroep gebruikt de standaard tekenset. De standaardtekenset is platformspecifiek en verschilt over het algemeen tussen Windows-, Mac- en Linux-platforms.

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

en omgekeerd:

String testString = new String(bytes);

Merk op dat ongeldige tekens en bytes door deze methoden kunnen worden vervangen of overgeslagen. Voor meer controle - bijvoorbeeld voor het valideren van invoer - wordt u aangemoedigd om de klassen CharsetEncoder en CharsetDecoder te gebruiken.

Base64 Codering / decodering

Af en toe zul je de behoefte vinden om binaire gegevens te coderen als een base64- gecodeerde string.

Hiervoor kunnen we de DatatypeConverter klasse uit het pakket 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);

Commache-codec

Als alternatief kunnen we Base64 van Apache commons-codec gebruiken .

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

Als u dit programma tijdens het uitvoeren inspecteert, ziet u dat someBinaryData codeert voor c29tZUJpbmFyeURhdGE= , een zeer beheersbaar UTF-8 String-object.

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

Tekenreeksen parseren naar een numerieke waarde

String naar een primitief numeriek type of een numeriek wrapper-type:

Elke numerieke wrapper-klasse biedt een parseXxx methode die een String converteert naar het overeenkomstige primitieve type. De volgende code converteert een String naar een int met behulp van de methode Integer.parseInt :

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

Om een String naar een instantie van een numerieke wrapper-klasse te converteren, kunt u een overbelasting van de methode valueOf van de wrapper-klassen gebruiken:

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

of vertrouw op automatisch boksen (Java 5 en hoger):

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

Het bovenstaande patroon werkt voor byte , short , int , long , float en double en de bijbehorende wrapper-klassen ( Byte , Short , Integer , Long , Float en Double ).

String naar geheel getal met 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 

Uitzonderingen

De niet- aangevinkte uitzondering NumberFormatException wordt gegenereerd als een numerieke waarde van valueOf(String) of parseXxx(...) methode wordt aangeroepen voor een string die geen acceptabele numerieke weergave is, of die een waarde vertegenwoordigt die buiten bereik is.

Een `String` krijgen van een` InputStream`

Een String kan worden gelezen van een InputStream met behulp van de byte array-constructor.

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

Dit maakt gebruik van de standaardtekenset van het systeem, hoewel een alternatieve tekenset kan worden opgegeven:

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

String naar andere datatypes omzetten.

U kunt een numerieke reeks als volgt converteren naar verschillende Java-numerieke typen:

String naar int:

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

String om te zweven:

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

String om te verdubbelen:

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

String naar boolean:

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

String te lang:

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

String naar BigInteger:

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

String naar BigDecimal:

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

Conversie uitzonderingen:

De bovenstaande numerieke conversies NumberFormatException allemaal een (niet aangevinkt) NumberFormatException als u probeert een string te parseren die geen geschikt opgemaakt nummer is of buiten bereik is voor het doeltype. Het onderwerp Uitzonderingen bespreekt hoe om te gaan met dergelijke uitzonderingen.

Als je wilt testen of je een string kunt ontleden, zou je een tryParse... -methode als volgt kunnen implementeren:

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

Het is echter (aantoonbaar) een slechte gewoonte om deze tryParse... -methode direct voor het parseren aan te roepen. Het zou beter zijn om de parse... -methode te gebruiken en de uitzondering af te handelen.