Comment faire pour convertir un tableau de Chaîne en un tableau d'Octets? (java)

Tableau à Tableau vous devez convertir manuellement avec l'analyse des deux côtés, mais si vous avez juste une Chaîne de caractères, vous pouvez String.getBytes() et new String(byte[] data);
comme ce

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

pour un byte[] à partir string[] vous devez:

• à byteArray concat tableaux d'octets de chaque chaîne à l'aide de certains délimiteur de
• de bytearray divisé par te même séparateur et de créer des chaînes comme je l'ai
  décrit ci-dessus.

OriginalL'auteur Sergii Zagriichuk

Première déclarer la chaîne comme je l'ai déclaré ici str="Suresh"

Deuxième utilisation getBytes() pour le convertir en octets

getBytes retourne un tableau de byte.

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

OriginalL'auteur suresh chaudhari

Je voudrais traiter ce problème de sérialisation et juste mis en œuvre comme suit(complète et travailler de code Java):

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'idée est que dans le tableau d'octets nous stocker la longueur de la première chaîne(qui est toujours de 4 octets si nous utilisons le type int), suivie par les octets de la première chaîne(dont la longueur peut être lu plus tard à partir de la précédente 4 octets), puis suivie par la longueur de la deuxième chaîne, et les octets de la deuxième chaîne, et ainsi de suite. De cette façon, le tableau de chaîne peut être facilement récupéré à partir de la résultante tableau d'octets, comme l'a démontré par le code ci-dessus. Et cette sérialisation approche peut gérer n'importe quelle situation.

Et le code peut être beaucoup plus simple si nous faisons une hypothèse à la chaîne d'entrée de tableau:

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

L'hypothèse est que *.* n'existe pas de chaîne à partir du tableau d'entrée. En d'autres termes, si vous savez à l'avance spéciale à la séquence de symboles n'apparaissent pas dans n'importe quelle chaîne de l'entrée de tableau, vous pouvez utiliser cette séquence que le séparateur.

OriginalL'auteur Terry Li

Vous pouvez effectuer une itération pour chaque chaîne et de garder l'ajout à la finale du tableau d'octets.

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

OriginalL'auteur sumeet kumar