Java Language
Conversione da e verso le stringhe

Conversione di altri tipi di dati in String

• È possibile ottenere il valore di altri tipi di dati primitivi come String utilizzando uno dei metodi valueOf della classe String.

  Per esempio:

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

  Questo metodo è anche sovraccaricato per altri tipi di dati, come float , double , boolean e anche Object .

• Puoi anche ottenere qualsiasi altro oggetto (qualsiasi istanza di qualsiasi classe) come stringa chiamando su .toString . Affinché questo fornisca un output utile, la classe deve eseguire l'override di toString() . La maggior parte delle classi di librerie Java standard, come Date e altri.

  Per esempio:

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

  Qui stringifiedFoo contiene una rappresentazione di foo come una stringa.

Puoi anche convertire qualsiasi tipo di numero in String con notazione breve come sotto.

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

O semplicemente il modo semplice è

String str = 10 + "";

Conversione da / a byte

Per codificare una stringa in un array di byte, puoi semplicemente utilizzare il metodo String#getBytes() , con uno dei set di caratteri standard disponibili su qualsiasi runtime Java:

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

e per decodificare:

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

puoi semplificare ulteriormente la chiamata utilizzando un'importazione statica:

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

Per set di caratteri meno comuni puoi indicare il set di caratteri con una stringa:

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

e il contrario:

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

questo tuttavia significa che devi gestire l' UnsupportedCharsetException controllato.

La seguente chiamata utilizzerà il set di caratteri predefinito. Il set di caratteri predefinito è specifico per piattaforma e generalmente differisce tra piattaforme Windows, Mac e Linux.

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

e il contrario:

String testString = new String(bytes);

Si noti che caratteri e byte non validi possono essere sostituiti o saltati con questi metodi. Per un maggiore controllo, ad esempio per la convalida dell'input, sei incoraggiato a utilizzare le classi CharsetEncoder e CharsetDecoder .

Codifica / decodifica Base64

Occasionalmente troverai la necessità di codificare i dati binari come una stringa con codifica base64 .

Per questo siamo in grado di utilizzare la DatatypeConverter classe dal javax.xml.bind pacchetto:

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

In alternativa, possiamo usare Base64 da 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)));

Se si ispeziona questo programma wile, si vedrà che someBinaryData codificano in c29tZUJpbmFyeURhdGE= , un oggetto String UTF-8 molto 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); 

Analisi delle stringhe su un valore numerico

Stringa con un tipo numerico primitivo o un tipo di wrapper numerico:

Ogni classe di wrapper numerico fornisce un metodo parseXxx che converte una String nel tipo primitivo corrispondente. Il codice seguente converte una String in un int utilizzando il metodo Integer.parseInt :

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

Per convertire una String in un'istanza di una classe wrapper numerica è possibile utilizzare un overload del metodo valueOf classi wrapper:

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

o fare affidamento sul box automatico (Java 5 e versioni successive):

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

Il modello precedente funziona per byte , short , int , long , float e double e le corrispondenti classi wrapper ( Byte , Short , Integer , Long , Float e Double ).

Da String a Integer usando 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 

eccezioni

L'eccezione NumberFormatException deselezionata verrà generata se viene chiamato un metodo numerico valueOf(String) o parseXxx(...) per una stringa che non è una rappresentazione numerica accettabile o che rappresenta un valore non compreso nell'intervallo.

Ottenere un `String` da un` InputStream`

Una String può essere letta da un InputStream utilizzando il costruttore di array di byte.

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

Questo utilizza il set di caratteri predefinito del sistema, sebbene possa essere specificato un set di caratteri alternativo:

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

Conversione di stringhe in altri tipi di dati.

È possibile convertire una stringa numerica in vari tipi numerici Java come segue:

String to int:

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

String to float:

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

Stringa da raddoppiare:

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

Da stringa a booleana:

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

Stringa a lungo:

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

Stringa a BigInteger:

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

String to BigDecimal:

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

Eccezioni di conversione:

Le conversioni numerico sopra saranno tutti lanciare un (selezionata) NumberFormatException se si tenta di analizzare una stringa che non è un numero opportunamente formattato, o è fuori portata per il tipo di bersaglio. L'argomento Eccezioni illustra come gestire tali eccezioni.

Se vuoi testare che puoi analizzare una stringa, puoi implementare un metodo tryParse... questo modo:

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

Tuttavia, chiamare questo metodo tryParse... immediatamente prima dell'analisi è (discutibilmente) una cattiva pratica. Sarebbe meglio chiamare il metodo parse... e gestire l'eccezione.