web-dev-qa-db-ja.com

文字列配列をバイト配列に変換する方法は？ （Java）

1次元のバイト配列に変換する1次元のString配列があります。どうすればよいですか？これにはByteBufferが必要ですか？これどうやってするの？ （文字列は任意の長さにすることができます。そのような動作を実行する方法を知りたいだけです。そして、それをバイト配列に変換した後、どうすれば文字列配列に戻すことができますか？

-ダン

javabytearrayconverterbytebufferarrays
13
Code Doggo

配列から配列変換して手動で解析して両側に変換する必要がありますが、文字列だけの場合はString.getBytes()およびnew String(byte[] data);このような

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

string []から1バイト[]の場合：

  • いくつかのデリミタを使用して各文字列からbyteArray連結バイト配列へ
  • 同じ区切り文字で分割されたバイト配列から、上記で説明したように文字列を作成します。
13
Sergii Zagriichuk

（後でString[]に変換することを除いて）バイトで何をしたいかは言いませんが、それらを不透明なデータのバッグとして扱うことができると仮定すると（それらをそれらをファイルするかネットワーク経由で送信しますが、何らかの方法でそれらを調べたり変更したりする必要はありません）、私はあなたの最善の策はシリアル化を使うことだと思います。文字列配列をシリアル化するには、次のように記述します。

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

後で回復するには、逆を書きます。

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

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

objectInputStream.close();
3
ruakh

最初ここで宣言したように文字列を宣言します_str="Suresh"_
2番目getBytes()を使用してバイトに変換します
getBytesは、バイトの配列を返します。

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

String.getBytes()？あなたが探しているものです。

0
Aniket Inge

文字列ごとに繰り返し、最後のバイト配列に追加し続けることができます。

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

これを確認できます

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

私はこれをシリアル化の問題として扱い、次のように実装しました（完全で機能する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);
        }
    }
}

アイデアは、結果のバイト配列に最初の文字列の長さ（タイプintを使用する場合は常に4バイト）を格納し、その後に最初の文字列のバイト（長さを読み取ることができる）が続くことです。その後、前の4バイトから）、2番目の文字列の長さ、2番目の文字列のバイトなどが続きます。このように、上記のコードで示されているように、結果のバイト配列から文字列配列を簡単に復元できます。そして、このシリアル化アプローチは、あらゆる状況を処理できます。

そして、入力文字列配列を仮定すると、コードははるかに単純になります。

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

前提は*.*は、入力配列のどの文字列にも存在しません。言い換えると、入力配列のどの文字列にも出現しない特別なシンボルのシーケンスが事前にわかっている場合は、そのシーケンスをスプリッターとして使用できます。

0
Terry Li