Come convertire una matrice di stringhe in una matrice di byte? (java)

Question

Ho un array di stringhe unidimensionale che voglio convertire in un array di byte unidimensionale. Come faccio a fare questo? Questo richiede ByteBuffer? Come posso fare questo? (Le stringhe possono essere di qualsiasi lunghezza, voglio solo sapere come fare per fare un atto del genere. E dopo aver convertito in un array di byte come potrei riconvertirlo in un array di stringhe?

-Dan

Answer 1

Array di Array si dovrebbe convertire manualmente con l'analisi in entrambi i lati, ma se avete solo una stringa è possibile String.getBytes() e new String(byte[] data);. come questo

public static void main(String[] args) { 
    String[] strings = new String[]{"first", "second"}; 
    System.out.println(Arrays.toString(strings)); 
    byte[][] byteStrings = convertToBytes(strings); 
    strings = convertToStrings(byteStrings); 
    System.out.println(Arrays.toString(strings)); 

} 

private static String[] convertToStrings(byte[][] byteStrings) { 
    String[] data = new String[byteStrings.length]; 
    for (int i = 0; i < byteStrings.length; i++) { 
     data[i] = new String(byteStrings[i], Charset.defaultCharset()); 

    } 
    return data; 
} 


private static byte[][] convertToBytes(String[] strings) { 
    byte[][] data = new byte[strings.length][]; 
    for (int i = 0; i < strings.length; i++) { 
     String string = strings[i]; 
     data[i] = string.getBytes(Charset.defaultCharset()); // you can chose charset 
    } 
    return data; 
} 

---

per un byte [] dal string [] si deve:

• a ByteArray array concat byte da ogni stringa utilizzando alcuni delimitatore
• da Spalato ByteArray da te stesso delimitatore e creare String come I descritto sopra.

Answer 2

?

String.getBytes() è quello che stai cercando per

Answer 3

È possibile eseguire l'iterazione per ogni stringa e continuare ad aggiungersi all'array di byte finale.

String example = "This is an example"; 
//Convert String to byte[] using .getBytes() function 
byte[] bytes = example.getBytes(); 
//Convert byte[] to String using new String(byte[])  
String s = new String(bytes); 

Answer 4

Tu non dici quello che vuoi fare con il byte (a parte convertirli di nuovo ad un String[] dopo), ma supponendo che si può semplicemente trattarli come un sacchetto opaca dei dati (in modo da poter salvare in un file o inviarli tramite la rete o altro, ma non è necessario esaminarli o modificarli in alcun modo), penso che la soluzione migliore sia utilizzare la serializzazione. Per serializzare la stringa-array, si potrebbe scrivere qualcosa di simile:

final String[] stringArray = { "foo", "bar", "baz" }; 

final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); 
final ObjectOutputStream objectOutputStream = 
    new ObjectOutputStream(byteArrayOutputStream); 
objectOutputStream.writeObject(stringArray); 
objectOutputStream.flush(); 
objectOutputStream.close(); 

final byte[] byteArray = byteArrayOutputStream.toByteArray(); 

e di recuperarlo dopo, devi scrivere il contrario:

final ByteArrayInputStream byteArrayInputStream = 
    new ByteArrayInputStream(byteArray); 
final ObjectInputStream objectInputStream = 
    new ObjectInputStream(byteArrayInputStream); 

final String[] stringArray2 = (String[]) objectInputStream.readObject(); 

objectInputStream.close(); 

Answer 5

vorrei trattare questo come un problema di serializzazione e giusto implementato come segue (codice Java completo e funzionante):

import java.nio.ByteBuffer; 
import java.util.ArrayList; 

public class Serialization { 
    public static byte[] serialize(String[] strs) { 
     ArrayList<Byte> byteList = new ArrayList<Byte>(); 
     for (String str: strs) { 
      int len = str.getBytes().length; 
      ByteBuffer bb = ByteBuffer.allocate(4); 
      bb.putInt(len); 
      byte[] lenArray = bb.array(); 
      for (byte b: lenArray) { 
       byteList.add(b); 
      } 
      byte[] strArray = str.getBytes(); 
      for (byte b: strArray) { 
       byteList.add(b); 
      } 
     } 
     byte[] result = new byte[byteList.size()]; 
     for (int i=0; i<byteList.size(); i++) { 
      result[i] = byteList.get(i); 
     } 
     return result; 
    } 

    public static String[] unserialize(byte[] bytes) { 
     ArrayList<String> strList = new ArrayList<String>(); 
     for (int i=0; i< bytes.length;) { 
      byte[] lenArray = new byte[4]; 
      for (int j=i; j<i+4; j++) { 
       lenArray[j-i] = bytes[j]; 
      } 
      ByteBuffer wrapped = ByteBuffer.wrap(lenArray); 
      int len = wrapped.getInt(); 
      byte[] strArray = new byte[len]; 
      for (int k=i+4; k<i+4+len; k++) { 
       strArray[k-i-4] = bytes[k]; 
      } 
      strList.add(new String(strArray)); 
      i += 4+len; 
     } 
     return strList.toArray(new String[strList.size()]); 
    } 

    public static void main(String[] args) { 
     String[] input = {"This is","a serialization problem;","string concatenation will do as well","in some cases."}; 
     byte[] byteArray = serialize(input); 
     String[] output = unserialize(byteArray); 
     for (String str: output) { 
      System.out.println(str); 
     } 
    } 
} 

l'idea è che nel campo di byte risultante abbiamo memorizzare la lunghezza della prima stringa (che è sempre 4 byte se si usa il digitare int), seguito dai byte della prima stringa (la cui lunghezza può essere letta successivamente dai precedenti 4 byte), seguita dalla lunghezza della seconda stringa e dai byte della seconda stringa, e così via. In questo modo, l'array di stringhe può essere facilmente recuperato dall'array di byte risultante, come dimostrato dal codice precedente. E questo approccio di serializzazione può gestire qualsiasi situazione.

E il codice può essere molto più semplice se facciamo un presupposto alla matrice stringa di input:

public class Concatenation { 
    public static byte[] concatenate(String[] strs) { 
     StringBuilder sb = new StringBuilder(); 
     for (int i=0; i<strs.length; i++) { 
      sb.append(strs[i]); 
      if (i != strs.length-1) { 
       sb.append("*.*"); //concatenate by this splitter 
      } 
     } 
     return sb.toString().getBytes(); 
    } 

    public static String[] split(byte[] bytes) { 
     String entire = new String(bytes); 
     return entire.split("\\*\\.\\*"); 
    } 

    public static void main(String[] args) { 
     String[] input = {"This is","a serialization problem;","string concatenation will do as well","in some cases."}; 
     byte[] byteArray = concatenate(input); 
     String[] output = split(byteArray); 
     for (String str: output) { 
      System.out.println(str); 
     } 
    } 
} 

Il presupposto è che *.* non esiste in qualsiasi stringa dalla matrice di input. In altre parole, se si conosce in anticipo una sequenza speciale di simboli non apparirà in nessuna stringa dell'array di input, è possibile utilizzare quella sequenza come splitter.

Answer 6

È possibile controllare questo

package javaapplication2; 

import java.util.Arrays; 


/** 
* 
* @author Ali 
*/ 
public class JavaApplication2 { 


public static byte[] to_byte(String[] strs) { 
     byte[] bytes=new byte[strs.length]; 
     for (int i=0; i<strs.length; i++) { 
      bytes[i]=Byte.parseByte(strs[i]); 
     } 
     return bytes; 
    } 


    public static void main(String[] args) { 
     String[] input = {"1","2","3"};  //original data 
     byte[] byteArray = to_byte(input);//data to byte array 
     String[] recovered=Arrays.toString(byteArray).split(",");// recovered data 

    }  
} 

Answer 7

Prima dichiarare la stringa come ho dichiarato qui str="Suresh"
Seconda uso getBytes() per convertirlo in byte
getBytes restituisce l'array di byte.

String str="Suresh"; 
byte[] s=str.getBytes();