Java Byte Array su String to Byte Array

Sto cercando di capire un byte [] in stringa, rappresentazione in stringa di conversione byte [] in byte [] ... Converto il mio byte [] in una stringa da inviare, quindi mi aspetto il mio servizio web (scritto in Python) per eseguire l'eco dei dati direttamente al client.

Quando invio i dati dalla mia applicazione Java ...

Arrays.toString(data.toByteArray())

Byte da inviare ..

[B@405217f8

Invia (Questo è il risultato di Arrays.toString () che dovrebbe essere una rappresentazione in formato stringa dei miei dati byte, questi dati verranno inviati attraverso il filo):

[-47, 1, 16, 84, 2, 101, 110, 83, 111, 109, 101, 32, 78, 70, 67, 32, 68, 97, 116, 97]

Sul lato python, il server python restituisce una stringa al chiamante (che posso vedere è la stessa della stringa che ho inviato al server

[-47, 1, 16, 84, 2, 101, 110, 83, 111, 109, 101, 32, 78, 70, 67, 32, 68, 97, 116, 97]

Il server dovrebbe restituire questi dati al client, dove possono essere verificati.

La risposta che il mio cliente riceve (come una stringa) è simile

[-47, 1, 16, 84, 2, 101, 110, 83, 111, 109, 101, 32, 78, 70, 67, 32, 68, 97, 116, 97]

Non riesco a capire come riportare la stringa ricevuta in un byte []

Qualunque cosa sembri provare, finisco per ottenere un array di byte che appare come segue ...

[91, 45, 52, 55, 44, 32, 49, 44, 32, 49, 54, 44, 32, 56, 52, 44, 32, 50, 44, 32, 49, 48, 49, 44, 32, 49, 49, 48, 44, 32, 56, 51, 44, 32, 49, 49, 49, 44, 32, 49, 48, 57, 44, 32, 49, 48, 49, 44, 32, 51, 50, 44, 32, 55, 56, 44, 32, 55, 48, 44, 32, 54, 55, 44, 32, 51, 50, 44, 32, 54, 56, 44, 32, 57, 55, 44, 32, 49, 49, 54, 44, 32, 57, 55, 93]

oppure posso ottenere una rappresentazione in byte che è la seguente:

B@2a80d889

Entrambi sono diversi dai miei dati inviati ... Sono sicuro che mi manca qualcosa di veramente semplice ....

Qualsiasi aiuto?!

Non puoi semplicemente prendere la stringa restituita e costruirne una stringa ... non è più un byte[]tipo di dati, è già una stringa; devi analizzarlo. Per esempio :

String response = "[-47, 1, 16, 84, 2, 101, 110, 83, 111, 109, 101, 32, 78, 70, 67, 32, 68, 97, 116, 97]";      // response from the Python script

String[] byteValues = response.substring(1, response.length() - 1).split(",");
byte[] bytes = new byte[byteValues.length];

for (int i=0, len=bytes.length; i<len; i++) {
   bytes[i] = Byte.parseByte(byteValues[i].trim());     
}

String str = new String(bytes);

** MODIFICA **

Ottieni un suggerimento del tuo problema nella tua domanda, in cui dici " Whatever I seem to try I end up getting a byte array which looks as follows... [91, 45, ...", perché 91è il valore byte per [, così [91, 45, ...come l'array di byte della stringa " [-45, 1, 16, ..." stringa.

Il metodo Arrays.toString()restituirà una Stringrappresentazione dell'array specificato; significa che il valore restituito non sarà più un array. Per esempio :

byte[] b1 = new byte[] {97, 98, 99};

String s1 = Arrays.toString(b1);
String s2 = new String(b1);

System.out.println(s1);        // -> "[97, 98, 99]"
System.out.println(s2);        // -> "abc";

Come puoi vedere, s1contiene la rappresentazione in formato stringa dell'array b1 , mentre s2contiene la rappresentazione in formato stringa dei byte contenuti in b1.

Ora, nel tuo problema, il tuo server restituisce una stringa simile a s1, quindi per recuperare la rappresentazione dell'array, hai bisogno del metodo del costruttore opposto. Se s2.getBytes()è l'opposto di new String(b1), devi trovare l'opposto di Arrays.toString(b1), quindi il codice che ho incollato nel primo frammento di questa risposta.

String coolString = "cool string";

byte[] byteArray = coolString.getBytes();

String reconstitutedString = new String(byteArray);

System.out.println(reconstitutedString);

Questo genera "cool string" sulla console.

È dannatamente facile.

Cosa ho fatto:

ritorno ai clienti:

byte[] result = ****encrypted data****;

String str = Base64.encodeBase64String(result);

return str;

ricevere dai clienti:

 byte[] bytes = Base64.decodeBase64(str);

i tuoi dati saranno trasferiti in questo formato:

OpfyN9paAouZ2Pw+gDgGsDWzjIphmaZbUyFx5oRIN1kkQ1tDbgoi84dRfklf1OZVdpAV7TonlTDHBOr93EXIEBoY1vuQnKXaG+CJyIfrCWbEENJ0gOVBr9W3OlFcGsZW5Cf9uirSmx/JLLxTrejZzbgq3lpToYc3vkyPy5Y/oFWYljy/3OcC/S458uZFOc/FfDqWGtT9pTUdxLDOwQ6EMe0oJBlMXm8J2tGnRja4F/aVHfQddha2nUMi6zlvAm8i9KnsWmQG//ok25EHDbrFBP2Ia/6Bx/SGS4skk/0couKwcPVXtTq8qpNh/aYK1mclg7TBKHfF+DHppwd30VULpA== 

Quello che Arrays.toString()fa è creare una rappresentazione in forma di stringa di ogni singolo byte nel tuo byteArray.

Controlla la documentazione API API Array

Per riconvertire la stringa di risposta nell'array di byte originale, è necessario utilizzare split(",")qualcosa o qualcosa e convertirla in una raccolta e quindi convertire ogni singolo elemento in esso contenuto in un byte per ricreare l'array di byte.

È semplice convertire array di byte in stringa e tornare in array di byte in Java. dobbiamo sapere quando usare "nuovo" nel modo giusto. Può essere fatto come segue:

conversione da array di byte a stringa:

byte[] bytes = initializeByteArray();
String str = new String(bytes);

Conversione da stringa a array di byte:

String str = "Hello"
byte[] bytes = str.getBytes();

Per maggiori dettagli, guarda: http://evverythingatonce.blogspot.in/2014/01/tech-talkbyte-array-and-string.html

Il tipo di output visualizzato dall'array di byte ( [B@405217f8) è anche un output per un array di byte di lunghezza zero (ovvero new byte[0]). Sembra che questa stringa sia un riferimento all'array piuttosto che una descrizione del contenuto dell'array come ci si potrebbe aspettare da un normale toString()metodo di raccolta .

Come per gli altri intervistati, vorrei indirizzarti ai Stringcostruttori che accettano un byte[]parametro per costruire una stringa dal contenuto di una matrice di byte. Dovresti essere in grado di leggere byte non elaborati da un socket InputStreamse desideri ottenere byte da una connessione TCP.

Se hai già letto quei byte come String(usando un InputStreamReader), la stringa può essere convertita in byte usando la getBytes()funzione. Assicurati di passare il set di caratteri desiderato sia al costruttore String sia alle getBytes()funzioni, e questo funzionerà solo se i dati byte possono essere convertiti in caratteri dal InputStreamReader.

Se si desidera gestire byte non elaborati, è necessario evitare di utilizzare questo livello di lettore di stream.

Non puoi semplicemente inviare i byte come byte o convertire ogni byte in un carattere e inviarlo come stringa? Se lo fai come sei, occuperai un minimo di 85 caratteri nella stringa, quando hai solo 11 byte da inviare. Potresti creare una rappresentazione in formato stringa dei byte, quindi sarebbe "[B @ 405217f8", che può essere facilmente convertito in un oggetto byteso bytearrayin Python. In caso contrario, potresti rappresentarli come una serie di cifre esadecimali ("5b42403430353231376638") che occupano 22 caratteri, che possono essere facilmente decodificati sul lato Python usando binascii.unhexlify().

[JDK8]

import java.util.Base64;

Accordare:

String str = Base64.getEncoder().encode(new byte[]{ -47, 1, 16, ... });

Per array di byte:

byte[] bytes = Base64.getDecoder().decode("JVBERi0xLjQKMyAwIG9iago8P...");

Se si desidera riconvertire la stringa in un array di byte, sarà necessario utilizzare String.getBytes()(o una funzione Python equivalente) e ciò consentirà di stampare l'array di byte originale.

Utilizzare l'API di codice seguente per convertire bytecode come stringa in array di byte.

 byte[] byteArray = DatatypeConverter.parseBase64Binary("JVBERi0xLjQKMyAwIG9iago8P...");

[JAVA 8]

import java.util.Base64;

String dummy= "dummy string";
byte[] byteArray = dummy.getBytes();

byte[] salt = new byte[]{ -47, 1, 16, ... }
String encoded = Base64.getEncoder().encodeToString(salt);