Java Language
Konvertering till och från strängar

Konvertera andra datatyper till String

• Du kan få värdet på andra primitiva datatyper som en sträng med hjälp av valueOf metoder.

  Till exempel:

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

  Den här metoden är också överbelastad för andra datatyper, såsom float , double , boolean och even Object .

• Du kan också få alla andra objekt (alla instanser av valfri klass) som en sträng genom att ringa .toString på det. För att detta ska ge användbar utgång måste klassen åsidosätta toString() . De flesta vanliga Java-bibliotekskurser gör det, t.ex. Date och andra.

  Till exempel:

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

  Här innehåller stringifiedFoo en representation av foo som en sträng.

Du kan också konvertera valfri nummertyp till String med kort notation som nedan.

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

Eller bara ett enkelt sätt är

String str = 10 + "";

Konvertering till / från byte

För att koda en sträng i en byte-matris kan du helt enkelt använda metoden String#getBytes() med en av de standardteckenuppsättningar som finns tillgängliga på alla Java-runtime:

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

och att avkoda:

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

Du kan ytterligare förenkla samtalet genom att använda en statisk import:

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

För mindre vanliga teckenuppsättningar kan du ange teckenuppsättningen med en sträng:

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

och omvänt:

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

detta betyder dock att du måste hantera den markerade UnsupportedCharsetException .

Följande samtal använder standardteckenuppsättningen. Standardteckenuppsättningen är plattformspecifik och skiljer sig generellt mellan Windows, Mac och Linux-plattformar.

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

och omvänt:

String testString = new String(bytes);

Observera att ogiltiga tecken och byte kan ersättas eller hoppas över med dessa metoder. För mer kontroll - till exempel för validering av inmatningar - uppmuntras du att använda CharsetEncoder och CharsetDecoder .

Base64 Kodning / avkodning

Ibland hittar du behov av att koda binära data som Base64 -kodade sträng.

För detta kan vi använda DatatypeConverter klassen från paketet 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

Alternativt kan vi använda Base64 från 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)));

Om du inspekterar detta program kommer du att se att someBinaryData kodar till c29tZUJpbmFyeURhdGE= , ett mycket hanterbart UTF-8- strängobjekt.

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

Analysera strängar till ett numeriskt värde

Sträng till en primitiv numerisk typ eller en numerisk omslagstyp:

Varje numerisk omslagsklass tillhandahåller en parseXxx metod som konverterar en String till motsvarande primitivtyp. Följande kod konverterar en String till en int med metoden Integer.parseInt :

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

För att konvertera till en String till en instans av en numerisk omslagsklass kan du antingen använda en överbelastning av omslagsklassens valueOf metod:

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

eller lita på automatisk boxning (Java 5 och senare):

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

Ovanstående mönster fungerar för byte , short , int , long , float och double och motsvarande omslagsklasser ( Byte , Short , Integer , Long , Float och Double ).

Sträng till heltal med 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 

undantag

Det unchecked NumberFormatException- undantaget kastas om ett numeriskt valueOf(String) eller parseXxx(...) -metod kallas för en sträng som inte är en acceptabel numerisk representation eller som representerar ett värde som är utanför räckvidden.

Få en "sträng" från en "InputStream"

En String kan läsas från en InputStream hjälp av byte array-konstruktorn.

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

Detta använder systemets standardinställning, även om en alternativ charset kan anges:

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

Konvertera sträng till andra datatyper.

Du kan konvertera en numerisk sträng till olika Java-numeriska typer på följande sätt:

String till int:

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

Sträng att flyta:

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

Sträng till dubbla:

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

Sträng till booleska:

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

Sträng till lång:

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

Sträng till BigInteger:

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

Sträng till BigDecimal:

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

Undantag för konvertering:

De numeriska omvandlingarna ovan kommer alla att kasta ett (oavkryssat) NumberFormatException om du försöker analysera en sträng som inte är ett lämpligt formaterat nummer eller är utanför räckvidden för måttypen. Ämnet Undantag diskuterar hur man hanterar sådana undantag.

Om du ville testa att du kan analysera en sträng kan du implementera en tryParse... -metod som denna:

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

Men att kalla denna tryParse... -metod omedelbart innan analysering är (utan tvekan) dålig praxis. Det vore bättre att bara kalla parse... -metoden och hantera undantaget.