Java Language
Konwertowanie do i z ciągów

Konwertowanie innych typów danych na String

• Możesz uzyskać wartość innych pierwotnych typów danych jako ciąg znaków, używając jednej z metod valueOf klasy valueOf .

  Na przykład:

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

  Ta metoda jest również przeciążona dla innych typów danych, takich jak float , double , boolean , a nawet Object .

• Możesz także pobrać dowolny inny Obiekt (dowolną instancję dowolnej klasy) jako Ciąg, wywołując na nim .toString . Aby uzyskać użyteczne dane wyjściowe, klasa musi zastąpić toString() . Tak jest w przypadku większości standardowych klas bibliotek Java, takich jak Date i inne.

  Na przykład:

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

  Tutaj stringifiedFoo zawiera reprezentację foo jako String.

Możesz także przekonwertować dowolny typ liczby na ciąg znaków za pomocą krótkiej notacji, jak poniżej.

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

Lub po prostu prosty sposób

String str = 10 + "";

Konwersja do / z bajtów

Aby zakodować ciąg znaków w tablicy bajtów, możesz po prostu użyć metody String#getBytes() z jednym ze standardowych zestawów znaków dostępnych w dowolnym środowisku wykonawczym Java:

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

i dekodować:

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

możesz dodatkowo uprościć połączenie, używając importu statycznego:

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

W przypadku mniej popularnych zestawów znaków możesz wskazać zestaw znaków za pomocą łańcucha:

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

i na odwrót:

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

oznacza to jednak, że musisz obsłużyć zaznaczony UnsupportedCharsetException .

W poniższym wywołaniu zostanie użyty domyślny zestaw znaków. Domyślny zestaw znaków jest specyficzny dla platformy i ogólnie różni się między platformami Windows, Mac i Linux.

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

i odwrotnie:

String testString = new String(bytes);

Zauważ, że te metody mogą zostać zastąpione lub pominięte nieprawidłowe znaki i bajty. Aby uzyskać większą kontrolę - na przykład do sprawdzania poprawności danych wejściowych - zachęcamy do korzystania z klas CharsetEncoder i CharsetDecoder .

Kodowanie / dekodowanie Base64

Czasami pojawia się potrzeba kodowania danych binarnych jako łańcucha zakodowanego w standardzie base64 .

W tym celu możemy użyć klasy DatatypeConverter z pakietu 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);

Kodek wspólny Apache

Alternatywnie możemy użyć Base64 z kodera-dekodera Apache .

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

Jeśli sprawdzisz, czy ten program działa, zobaczysz, że someBinaryData koduje do c29tZUJpbmFyeURhdGE= , bardzo zarządzalnego obiektu UTF-8 String.

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

Parsowanie ciągów do wartości liczbowej

Ciąg znaków do prymitywnego typu numerycznego lub numerycznego typu opakowania:

Każda numeryczna klasa opakowania zapewnia metodę parseXxx , która konwertuje String parseXxx na odpowiedni typ pierwotny. Poniższy kod konwertuje String na int przy użyciu metody Integer.parseInt :

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

Przekonwertować na String do wystąpienia numerycznej klasy otoki można użyć przeciążenie klas Wrapper valueOf metody:

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

lub polegaj na automatycznym boxowaniu (Java 5 i nowsze):

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

Powyższy wzór działa na byte , short , int , long , float i double i odpowiednie otoki klas ( Byte , Short , Integer , Long , Float i Double ).

Ciąg do liczby całkowitej za pomocą podstawki:

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 

Wyjątki

Niezaznaczony wyjątek NumberFormatException zostanie parseXxx(...) zostanie wywołana metoda numeryczna valueOf(String) lub parseXxx(...) dla ciągu, który nie jest akceptowalną reprezentacją numeryczną lub reprezentuje wartość spoza zakresu.

Uzyskiwanie „String” z „InputStream”

String można odczytać z InputStream przy użyciu konstruktora tablicy bajtów.

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

Używa domyślnego zestawu znaków systemowych, chociaż można określić alternatywny zestaw znaków:

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

Konwertowanie ciągu znaków na inne typy danych.

Możesz przekonwertować ciąg liczbowy na różne typy liczbowe Java w następujący sposób:

Ciąg do int:

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

Łańcuch do pływaka:

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

Ciąg do podwojenia:

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

Ciąg znaków logicznych:

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

Ciąg do długiego:

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

Ciąg do BigInteger:

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

Ciąg do BigDecimal:

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

Wyjątki konwersji:

Powyższe konwersje numeryczne spowodują wygenerowanie (niezaznaczonego) NumberFormatException jeśli spróbujesz parsować ciąg, który nie jest odpowiednio sformatowaną liczbą lub jest poza zakresem dla typu docelowego. Temat wyjątków omawia sposób radzenia sobie z takimi wyjątkami.

Jeśli chcesz przetestować, czy możesz tryParse... ciąg, możesz zaimplementować metodę tryParse... sposób:

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

Jednak wywołanie tej metody tryParse... bezpośrednio przed analizą jest (prawdopodobnie) słabą praktyką. Lepiej byłoby po prostu wywołać metodę parse... i zająć się wyjątkiem.