如何将String数组转换为Byte数组？（Java）

Question

我有一个一维字符串数组，想将其转换为一维字节数组。我该怎么做？这需要 ByteBuffer 吗？如何做到这一点？（字符串的长度可以是任意的，只想知道如何进行此操作。将其转换为字节数组后，如何将其转换回字符串数组？） - Dan

- Code Doggo

---

你可以为每个字符串进行迭代，并将其附加到最终的字节数组中。例如：String example = "This is an example"; //使用.getBytes()函数将字符串转换为byte[] byte[] bytes = example.getBytes(); //使用new String(byte[])将byte[]转换为字符串 String s = new String(bytes); - sumeet kumar

你看过这个问题吗？https://dev59.com/sHI_5IYBdhLWcg3wEe1u - Alina B.

Ali B - 我认为你链接的问题回答了一个略微不同的问题 - 特别是当你看到被接受的答案时，它正确地指出，“如果你真的想在String类型中存储二进制数据，你应该使用Base64编码。” - Floris

字符串没有唯一的字节表示形式。您想使用哪种字符编码？ - Raedwald

Answer 1

数组转换为数组您应该通过解析手动进行双侧转换，但如果您只有一个字符串，您可以使用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;
}

---

如果你想从字符串数组转换为字节数组，你需要：

• 将每个字符串的字节数组连接起来，并使用某个分隔符
• 再根据相同的分隔符拆分字节数组，并按照上述方法创建字符串。

- Sergii Zagriichuk

Answer 2

除了把它们转换回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();

- ruakh

---

我喜欢这个方法，因为它可以分离字符串数组。所以如果你想要把数据写入文件并在后面重读它们，你不必担心字符串分隔符的问题。但是我的问题是，ObjectInputStream和ObjectOutputStream的行为会在Java的不同版本中保持一致吗？还是说旧版本的JRE保存的文件最终会变得不稳定？ - EngineerWithJava54321

Answer 3

首先像我这里声明字符串一样声明字符串str="Suresh"
第二步使用getBytes()将其转换为字节
getBytes返回字节数组。

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

- suresh chaudhari

Answer 4

我会将这视为序列化问题，并按照以下方式实现（完整且可工作的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个字节中读取），接着是第二个字符串的长度和字节，以此类推。这样，可以通过上面的代码轻松地从生成的字节数组中恢复字符串数组。而且，这种序列化方法可以处理任何情况。

如果我们对输入的字符串数组做出假设，那么代码可以更简单：

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

假设输入数组中没有任何字符串包含*.*。换句话说，如果您事先知道某些特殊符号序列不会出现在输入数组的任何字符串中，您可以将该序列用作分隔符。

- Terry Li

Answer 5

你可以检查这个。

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 

    }    
}

- Ali Siam

---

它抛出异常 - undefined

Answer 6

String.getBytes()? 这就是你要找的。

- Aniket Inge

---

我需要对每个字符串都这样做吗？但是那不仅仅是将单个字符串转换为字节数组吗？我有一堆想要放在一起成为字节数组的字符串...我猜我可以使用它，只是想看看是否有一种方法可以避免这样做。谢谢。 - Code Doggo

你可以先将它们连接成一个大字符串，然后在它们上面获取字节吗？@DanielH - Aniket Inge

@DanielH - 没有直接从 String[] 转换为 byte[] 的方法 - 您将需要遍历您的 String[] 并转换每个字符串，然后将其放入您的 byte[] 中。 - Brian Roach

谢谢。我从这些回复中收集到的所有信息都让我的程序正常运行了。再次感谢。 - Code Doggo

错误，String类没有那个方法。至少在我的Java中没有。 - Thufir

Answer 7

你可以对每个字符串进行迭代，并将其附加到最终的字节数组中。

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

- sumeet kumar