web-dev-qa-db-fra.com

Comment convertir un tableau String en un tableau Byte? (Java)

J'ai un tableau de chaîne à une dimension que je veux convertir en un tableau d'octets à une dimension. Comment puis-je faire cela? Est-ce que cela nécessite ByteBuffer? Comment puis-je faire ceci? (Les chaînes peuvent être de n'importe quelle longueur. Je veux juste savoir comment s'y prendre. Et après l'avoir converti en tableau d'octets, comment pourrais-je le reconvertir en tableau de chaînes?

-Dan

javabytearrayconverterbytebufferarrays
11
Dan Hoynoski

Tableau à tableau vous devez convertir manuellement avec une analyse syntaxique des deux côtés, mais si vous avez juste une chaîne, vous pouvez utiliser String.getBytes() et new String(byte[] data); Comme ceci

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 octet [] de la chaîne [], vous devez:

  • byteArray concat les tableaux d'octets de chaque chaîne en utilisant un délimiteur
  • de bytearray divisé par le même délimiteur et créer une chaîne comme décrit ci-dessus.
13
Sergii Zagriichuk

Vous ne dites pas ce que vous voulez faire avec les octets (à part les reconvertir en un String[] après), mais en supposant que vous puissiez les traiter comme un paquet de données opaque (pour pouvoir les sauvegarder dans un fichier ou les envoyer sur le réseau ou autre chose, mais vous n’avez pas besoin de les examiner ou de les modifier), je pense que votre meilleur choix est d’utiliser la sérialisation. Pour sérialiser votre tableau de chaînes, vous écrirez quelque chose comme:

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

et pour le récupérer ensuite, vous écrivez le contraire:

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

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

objectInputStream.close();
3
ruakh

First déclare la chaîne comme je l'ai déclaré ici str="Suresh"
Second utilisez getBytes() pour le convertir en octets
getBytes renvoie le tableau d'octets.

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

String.getBytes()? est ce que vous cherchez.

0
Aniket Inge

Vous pouvez itérer pour chaque chaîne et continuer à ajouter au tableau d'octets final.

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);
0
sumeet kumar

Vous pouvez vérifier cela 

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 

    }    
}
0
Ali Siam

Je considérerais cela comme un problème de sérialisation et l’implémenterais comme suit (code Java complet et fonctionnel):

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 résultant, nous stockons la longueur de la première chaîne (qui est toujours de 4 octets si nous utilisons le type int), suivie des octets de la première chaîne (dont la longueur peut être lue ultérieurement à partir de la chaîne précédente). octets), suivis de la longueur de la deuxième chaîne et des octets de la deuxième chaîne, et ainsi de suite. De cette façon, le tableau de chaînes peut être facilement récupéré à partir du tableau d'octets résultant, comme illustré par le code ci-dessus. Et cette approche de sérialisation peut gérer n'importe quelle situation.

Et le code peut être beaucoup plus simple si nous supposons le tableau de chaînes en entrée:

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 dans aucune chaîne du tableau en entrée. En d'autres termes, si vous savez à l'avance qu'une séquence spéciale de symboles n'apparaîtra dans aucune chaîne du tableau en entrée, vous pouvez utiliser cette séquence comme séparateur.

0
Terry Li